Process as Execution Unit

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# Examine resources owned by process 1234
$ ls -la /proc/1234/fd/          # Open file descriptors
$ cat /proc/1234/maps            # Memory mappings
$ cat /proc/1234/status          # Process status and limits
$ cat /proc/1234/limits          # Resource limits
$ cat /proc/1234/environ         # Environment variables (null-separated)
 
# Example output of /proc/1234/fd/ (file descriptors)
lrwx------ 1 user user 64 Jan 15 10:00 0 -> /dev/pts/0     # stdin
lrwx------ 1 user user 64 Jan 15 10:00 1 -> /dev/pts/0     # stdout
lrwx------ 1 user user 64 Jan 15 10:00 2 -> /dev/pts/0     # stderr
lr-x------ 1 user user 64 Jan 15 10:00 3 -> /etc/passwd    # open file
lrwx------ 1 user user 64 Jan 15 10:00 4 -> socket:[12345] # network socket
 
# When process 1234 terminates, ALL of these are automatically cleaned up

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// From include/linux/sched.h (heavily simplified)
// The actual structure is over 700 lines with hundreds of fields
 
struct task_struct {
    // State and flags
    unsigned int            state;          // TASK_RUNNING, etc.
    unsigned int            flags;          // PF_EXITING, PF_KTHREAD, etc.
    
    // Process identification
    pid_t                   pid;            // Process ID
    pid_t                   tgid;           // Thread group ID (same as pid for main thread)
    
    // Scheduling
    int                     prio;           // Dynamic priority
    int                     static_prio;    // Static priority (nice value based)
    unsigned int            policy;         // SCHED_NORMAL, SCHED_FIFO, SCHED_RR
    
    // Memory management
    struct mm_struct        *mm;            // Memory descriptor
    struct mm_struct        *active_mm;     // Active address space
    
    // File system
    struct fs_struct        *fs;            // Filesystem information
    struct files_struct     *files;         // Open file descriptors
    
    // Signal handling
    struct signal_struct    *signal;        // Signal handlers and state
    sigset_t                blocked;        // Blocked signals
    
    // Process hierarchy
    struct task_struct      *parent;        // Parent process
    struct list_head        children;       // List of children
    struct list_head        sibling;        // Linkage in parent's children list
    
    // CPU state (architecture-specific)
    struct thread_struct    thread;         // CPU registers, saved when not running
    
    // ... hundreds more fields for accounting, namespaces, cgroups, etc.
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# View current shell's identity
$ echo "PID: $$"
PID: 1234
 
# View parent's PID
$ echo "PPID: $PPID"
PPID: 1200
 
# Detailed view of a process's identity
$ ps -o pid,ppid,pgid,sid,uid,gid,comm -p $$
  PID  PPID  PGID   SID   UID   GID COMMAND
 1234  1200  1234  1234  1000  1000 bash
 
# Process groups: all processes in a pipeline share PGID
$ sleep 100 | grep foo | wc -l &
$ ps -o pid,pgid,comm | tail -5
  PID  PGID COMMAND
 1235  1235 sleep      # All share PGID 1235
 1236  1235 grep
 1237  1235 wc
 
# Sending signal to process group kills all three
$ kill -TERM -1235   # Negative PID = process group

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# View the full process tree
$ pstree
systemd─┬─ModemManager───2*[{ModemManager}]
        ├─NetworkManager───2*[{NetworkManager}]
        ├─sshd───sshd───sshd───bash───pstree
        ├─cron
        ├─dockerd─┬─containerd───8*[{containerd}]
        │         └─10*[{dockerd}]
        └─...
 
# Show PIDs in the tree
$ pstree -p
systemd(1)─┬─sshd(500)───sshd(1234)───sshd(1235)───bash(1236)───pstree(1250)
           ├─cron(600)
           └─dockerd(700)───containerd(800)─┬─container(850)
                                            └─container(900)
 
# Show a specific process and its ancestors
$ pstree -s -p 1250
systemd(1)───sshd(500)───sshd(1234)───bash(1236)───pstree(1250)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <stdio.h>
#include <unistd.h>
#include <sys/wait.h>
 
int global_var = 100;   // Shared at fork, then isolated
 
int main() {
    pid_t pid = fork();
    
    if (pid == 0) {
        // Child process
        global_var = 200;   // Modify in child
        printf("Child: global_var = %d (at %p)
", 
               global_var, (void*)&global_var);
        sleep(1);
        printf("Child: global_var still = %d
", global_var);
    } else {
        // Parent process
        sleep(0.5);
        printf("Parent: global_var = %d (at %p)
", 
               global_var, (void*)&global_var);
        global_var = 300;   // Modify in parent
        printf("Parent: global_var now = %d
", global_var);
        wait(NULL);
    }
    return 0;
}
 
/* Output:
Child: global_var = 200 (at 0x55a4b3b1c010)
Parent: global_var = 100 (at 0x55a4b3b1c010)   // SAME address, DIFFERENT values!
Parent: global_var now = 300
Child: global_var still = 200                  // Child's value unchanged by parent
*/