378-LKP: Lecture 09

Linux Process Management

Feb 15, 2002
Yongguang Zhang

Today's Lecture

Q&A
- Any Questions about the 8 Choices?
Process Management

Linux Process Structure

Process: "a program in execution"
Contents
- Kernel-mode virtual address space (code, data, and stack)
- Program counter, CPU's registers
- Other states

Process Descriptor

Process is often referred as "task" in Linux kernel
All Kernel Information about a Process is in one Data Structure: struct task_struct
- Defined in include/linux/sched.h
- One per process
- Many many fields

Process State

task_struct field:
- long state;

5 States (see include/linux/sched.h):

#define TASK_RUNNING            0
#define TASK_INTERRUPTIBLE      1
#define TASK_UNINTERRUPTIBLE    2
#define TASK_ZOMBIE             4
#define TASK_STOPPED            8

Process IDs

task_struct fields:

pid_t pid
pid_t pgrp
uid_t uid,euid, ...
gid_t gid,egid, ...

Storage for Process Descriptors

8K per process to Store Both Process Descriptor and Stack

In include/linux/sched.h:

# define INIT_TASK_SIZE 2048*sizeof(long)
...
union task_union {
	struct task_struct task;
	unsigned long stack[INIT_TASK_SIZE/sizeof(long)];
};

Q: Why Per-process Stack?

Allocating Task Union

To create a new task union, call alloc_task_struct()
- In include/asm-i386/processor.h:
```
#define alloc_task_struct() ((struct task_struct *) __get_free_pages(GFP_KERNEL,1))
```
- This gets exactly 8K = 2 physical pages
- __get_free_pages(gfp_mask, order)
  - Allocate 2^order contiguous frames
To release a task union, call free_task_struct()

Process Lists and Links

List of All Processes
PID Hash
Run List
Wait Queues
Links to Related Tasks

Process List

Double Linked List for All Task Descriptors

task_struct fields:

struct task_struct *next_task, *prev_task;

First Process in the list: init_task

include/linux/sched.h:
```
#define INIT_TASK(tsk)  ...
    
```

arch/i386/kernel/init_task.c:

union task_union init_task_union = { INIT_TASK(init_task_union.task) };

include/asm/arch/processor.h:

#define init_task	(init_task_union.task)

PID Hash

Data Structure to Optimize PID-lookup in the Process List: Hash by PID

In include/linux/sched.h

#define PIDHASH_SZ (4096 >> 2)
extern struct task_struct *pidhash[PIDHASH_SZ];
#define pid_hashfn(x)   ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))

Hash Operations:
- hash_pid(), unhash_pid(), *find_task_by_pid(int pid)

task_struct Fields: (for hash collision)

struct task_struct *pidhash_next;
struct task_struct **pidhash_pprev;

Run Queue

List of all processes in TASK_RUNNING state
task_struct fields:
```
struct list_head run_list;
  
```
struct list_head
- A generic double-linked list data structure widely used in Linux kernel
- Defined in include/linux/list.h
```
struct list_head {
	struct list_head *next, *prev;
};
```

Wait Queues

List of process waiting for a particular event
- TASK_INTERRUPTIBLE
- TASK_UNINTERRUPTIBLE

Data structure in include/linux/wait.h

struct __wait_queue {
	unsigned int flags;
	struct task_struct * task;
	struct list_head task_list;
};
typedef struct __wait_queue wait_queue_t;

Process Links

Links To
- Original parent
- Parent
- Child (youngest)
- Younger sibling
- Older sibling
task_struct fields:
- struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;

Other Fields

Virtual Memory Management
- task_struct field: struct mm_struct *mm
Filesystem information ($HOME, $CWD)
- task_struct field: struct fs_struct *fs
Open File Information
- task_struct field: struct files_struct *files
Signal handlers
Limits

The CPU State

task_struct field:
```
struct thread_struct thread;
```
The Thread of Execution
Contents
- Program counter, CPU's registers, etc.

The Data Structure `thread_struct`

In include/asm-i386/processor.h:
```
struct thread_struct
```

Fields

Hardware Registers

unsigned long esp0, eip, esp, fs, gs;

Hardware debugging registers
```
unsigned long debugreg[8];
    
```

Fault info

unsigned long cr2, trap_no, error_code;

Floating point info,Virtual 86 mode info, IO permissions

Process Data Structure Summary

Kernel Thread

A Kernel Thread is a "lightweight" Process
- Has a Process Descriptor and schedulable
- Runs only in kernel mode (has not user-mode address space)
- Share kernel address space with other kernel threads
- Share other kernel data structure
  - File systems (home directory, current work directory)
  - Open file descriptors
- A Typical Kernel has many Threads
  - Depends on configuration

Well-known Kernel Threads

Process 0 (swapper)
Process 1: init

Other Threads: (ps ax)

    2 ?        SW     0:00 [keventd]
    3 ?        SW     0:00 [kapm-idled]
    4 ?        SWN    0:00 [ksoftirqd_CPU0]
    5 ?        SW     4:45 [kswapd]
    6 ?        SW     0:00 [kreclaimd]
    7 ?        SW     0:00 [bdflush]
    8 ?        SW     0:00 [kupdated]
    9 ?        SW<    0:00 [mdrecoveryd]
   10 ?        SW     0:00 [phpd_notify]
   14 ?        SW     0:40 [kjournald]
   80 ?        SW     0:00 [khubd]

Homework

Finish Your Project Selection
Starting Doing First Group Project