Scribd
Upload
24 views11 pages

Linux Process Management Commands Guide

Uploaded by

Abhishek Bhalla
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
24 views11 pages

Linux Process Management Commands Guide

Uploaded by

Abhishek Bhalla
Copyright
© All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd

PROCESS COMMANDS

1. ps
 This command stands for ‘Process Status’. It is similar to the
“Task Manager” that pop-ups in a Windows Machine when we
use Cntrl+Alt+Del.
 To check all the processes running under a user, use the
command –
ps ux
 To check the process status of a single process, use the
syntax –
ps PID

2. Top
 This utility tells the user about all the running processes on the
Linux machine.

 Press ‘q’ on the keyboard to move out of the process display.


3. pstree
 Pstree command in Linux that shows the running processes as a
tree which is a more convenient way to display the processes
hierarchy and makes the output more visually appealing. The root
of the tree is either init or the process with the given pid.
 To display process tree
pstree

4. nice
 Linux can run a lot of processes at a time, which can slow down
the speed of some high priority processes and result in poor
performance.
 To avoid this, you can tell your machine to prioritize processes
as per your requirements.
 This priority is called Niceness in Linux, and it has a value
between -20 to 19.
 The lower the Niceness index, the higher would be a priority
given to that task.
 The default value of all the processes is 0.
 To start a process with a niceness value other than the default
value use the following syntax
nice -n 'Nice value' process name

 In Linux, the nice & renice commands are used to change the
priority of a process, which, in effect, determines the urgency
with which it is executed in the system.

 The nice command configures the priority of a Linux process


before it is started. Once started, you cannot change the priority
using the nice command. This is where the renice command
comes in. The renice command sets the priority of an already
running process.

Priority Values in Linux


 In Linux systems, there are a total of 140 priorities with a nice
value that ranges from -20 to +19 where +19 represents the
lowest priority and -20 the highest priority. As you have noted,
this is an inverse proportionality relationship between the nice
value and the priority value.

 By default, any Linux process created by a user has a nice


value of 0.

 How to Check the Nice Value of Running Processes?


 There are a couple of ways of checking the nice value of
running processes. You can use the ps command with the -
l option, as follows:
$ ps-l

 The niceness value is denoted by the NI column header.


The PRI column header denotes the actual priority of the
process.
 Additionally, you can invoke the top command to check the
nice value of processes.
$ top

 The default niceness value for processes started by a regular


user is 0. In fact, you can easily verify the nice value for your
terminal or shell by executing nice command without any
arguments.

$ nice

How Set the Nice Value of a Process?


 The syntax of using the nice command is as follows:
$ nice -nice_value command-arguments
For example, to set a nice value of 5 to a command, run the
command below.

Here, we are downloading the WordPress installation file using wget


command with a nice value set to 5.

$ nice -5 wget [Link]

 To set a negative value to a command, use a double hyphen, as


shown. Be advised that you should run the command as root or sudo
user as you execute this.
$ sudo nice --5 wget [Link]

How to Change the Nice Value Using Renice?


The renice command changes the priority of a process that is already
running in the Linux system. To do so, use the syntax:

$ sudo renice –n nice_value -p pid_of_the_process

From the output, the nice value is 0. We are going to set it to 5, as shown
below. Note 8721 is the PID of the gnome-terminal process

$ sudo renice –n 5 -p 8721


SYSTEM CALLS IN LINUX

A system call is a procedure that provides the interface between a


process and the operating system. It is the way by which a computer
program requests a service from the kernel of the operating system.
Different operating systems execute different system calls.
In Linux, making a system call involves transferring control from
unprivileged user mode to privileged kernel mode; the details of this
transfer vary from architecture to architecture. The libraries take care of
collecting the system-call arguments and, if necessary, arranging those
arguments in the special form necessary to make the system call.
When running a computer, you interact with various programs that require
system resources like network, filesystem, memory, and CPU. And here's
where the concept of system calls kicks in! When a program requires a
system resource, it sends a request for that resource to the kernel by
making a system call.
The system calls are divided into five categories:

1. Process management system calls


2. File management system calls
3. Device management system calls
4. Network management system calls
5. System information system calls
PROCESS MANAGEMENT SYSTEM CALLS
These system calls are used to manage processes, such as starting new
ones, stopping existing ones, and waiting for them to finish. Fork(),
exec(), wait(), and exit() are all examples of process management
system calls ().
 fork(): As the name suggests, this creates a child process from the parent
process which results in the exact same process except for some values like
PID and parent PID.
 exec(): This system call replaces the current process image with the new
image and it is used when you want to run a different program from the
current process.
 wait(): This system call waits to will the child process gets terminated and
then gives some information about the child process. The prime example of
this would be the exit status.
 exit(): This system call terminates the current process and returns the
resources acquired by that process (which was terminated recently) to the
system.

FILE MANAGEMENT SYSTEM CALLS


These calls to the system are used to open, read, write, and close
documents, as well as to create, rename, and delete them.
 open(): As the name suggests, it is used to open the file.
 read(): This system call can be used to read data from a wide range of
data types including regular files, and special files like pipes and sockets,
and it can also read from device files like /dev directory. We cannot edit
the files with this system call. Multiple processes can execute the read()
system call on the same file simultaneously
 write(): It is used to modify files, generate log files, reports, etc. Multiple
processes cannot execute the write() system call on the same file
simultaneously
 close(): This will close the file and save the changes to the disk(if any).
DEVICE MANAGEMENT SYSTEM CALLS

The device management system calls are used to manage devices that are
connected to your system. In simple terms, the device management system
calls provides a way to read/write data, and control and configure those
devices.

Here are some common device management system calls:

ioctl(): It is referred to as Input and Output Control. It is used to send


control commands to the connected devices.

mmap(): It is used to map the partition of a file into the memory of the own
process. This results in direct access to the memory-mapped data as if it
was a part of the process's own memory.

For example, let's say you want to process a large file in a program so
rather than loading a whole file, you can map a portion of a file, use it and
then unmap it.

OR we can say ,

This function call is used to map or unmap files or devices into memory. The
mmap() system call is responsible for mapping the content of the file to the
virtual memory space of the process.
SYSTEM INFORMATION SYSTEM CALL
The system information system calls are used to get various kinds of
information such as system resources, system time, system configuration,
etc.

Here are some of the most commonly used system information calls:

 getpid(): Gets the PID (process ID) of the current process.


 getppid(): Gets the parent PID of the current process.
 getuid(): It will get the UID (used ID) of the current process.
 getgid(): It will get the GID (group ID) of the current process.
 uname(): This system call gets the information about the system name,
version, release info, and other system-related info.
 sysinfo(): It gets general information about the system which includes
free memory, total memory, number of current processes, etc.
 time(): It gets the current system time in seconds

NETWORK SYSTEM CALLS


The network system calls are used to manage networks, send/receive data,
resolve network addresses, etc.

And here are some of the popular network system calls:

 socket(): This system call is used to create sockets which are endpoints for
communication.
 bind(): It is used to bind a socket to the specific address and port on the
local network.
 listen(): It is used to mark the socket as a passive listener so it can accept
incoming requests from the other hosts.
 accept(): This system call is used to accept the new incoming connection
request.
 connect(): It establishes the connection to the external network endpoint.
 send(): As the name suggests, it is used to send data over the socket.
 recv(): It is used to receive data over the socket.

Common questions

Powered by AI

System calls in Linux enable applications to request services from the kernel, acting as an interface between user mode and kernel mode . These calls fall into different categories: process management (e.g., fork, exec), which handles the creation and termination of processes ; file management, which involves operations like opening and reading files ; device management for controlling hardware devices ; network management for socket-based communication ; and system information for retrieving system status and configuration details . Each of these categories addresses specific functional areas required by applications to efficiently utilize system resources.

Linux provides utilities like 'ps', 'top', 'nice', and 'renice' to monitor and alter the priority of running processes . 'ps' and 'top' offer insights into process states and priority levels . 'Nice' sets initial process priorities, while 'renice' adjusts them dynamically for running processes . By increasing or decreasing process priorities according to workload needs (e.g., by assigning lower nice values to more critical processes), system administrators can effectively allocate CPU resources, enhancing real-time efficiency and ensuring that essential tasks receive more attention from the scheduler, thus optimizing overall performance.

The 'nice' command in Linux determines the initial priority of a process before it starts, allowing users to set its niceness value, which affects its scheduling priority . A lower nice value means higher priority, making the process run more frequently. 'Renice', on the other hand, alters the priority of an already running process . This ability to dynamically adjust priorities helps manage CPU time allocation among processes, which can optimize system performance by ensuring that high-priority tasks are not unnecessarily delayed.

The 'fork()' system call in Linux is used to create a child process that is a duplicate of the parent process . This duplication includes the memory, process state, and all resources, except for the process identifier (PID), which is unique for each process. The child process can run concurrently with the parent process, allowing for parallel task execution. This ability significantly affects the process structure by increasing the number of processes and enabling multitasking.

The 'getpid()' system call retrieves the process ID of the current process, enabling processes to uniquely identify themselves within the system . 'getuid()' provides the user ID of the process, which is critical for security and access control, helping to determine the permissions associated with a process . 'uname()', on the other hand, offers extensive details about the running system, including its name, version, and hardware architecture . These system calls collectively facilitate process management and provide foundational information for configuring and troubleshooting within the Linux environment.

In a Linux-based network application, 'socket()' initializes a new socket for communication, acting as a direct endpoint . 'bind()' assigns the socket a specific address and port, making it available to network interfaces . 'listen()' transforms the socket into a passive listener, waiting for incoming connection attempts . Finally, 'accept()' confirms these connection requests, allowing data exchange . These system calls facilitate establishing reliable network communication channels essential for client-server architectures and distributed applications, enabling efficient data transmission across networks.

System calls like 'open()', 'read()', and 'close()' are crucial for managing file operations in Linux. 'open()' initializes access to a file, allowing subsequent operations . 'read()' retrieves data from a file, supporting multi-process access but preventing concurrent modification to maintain data integrity . Finally, 'close()' ends the file session, ensuring that any data is written to disk and freeing system resources . These calls collectively ensure controlled access to filesystem resources, maintaining data consistency and system stability.

Improperly setting process priorities with 'nice' and 'renice' can degrade system performance by misallocating CPU resources. For example, inadvertently giving a low-priority to critical system tasks might delay essential operations, leading to bottlenecks . Conversely, assigning high priority to less important processes can result in resource hogging, starving other processes of CPU time . These risks can be mitigated by carefully assessing process requirements before altering priorities, often starting with monitoring commands like 'top' or 'ps' to understand current resource usage. Using predictive algorithms or policy-based management can also automate priority settings, avoiding manual errors.

Unlike 'fork()', which creates a new child process, the 'exec()' system call replaces the existing process with a new program image, effectively changing the command executed by the process without altering its PID . This means that 'exec()' does not create a new process; it transforms the process content entirely while maintaining its identity. This is used when a different program should be executed within the same process ID structure created by a 'fork()' call or equivalent.

'pstree' presents running processes as a hierarchical tree, which makes it easier to understand the parent-child relationships between processes . This visualization is more intuitive than linear listings from commands like 'ps', where processes are listed in a non-hierarchical manner . The visual appeal and structure of 'pstree' help quickly identify related processes and their dependencies, enhancing the ability to diagnose process-related issues.

You might also like