Task_struct structure comment

Task_struct structure comment

======================================

Long state task running status (-1 is not running, 0 is running (ready),> 0 is stopped ).

Long counter task running time count (descending) (tick answer count), run time slice.

Long priority running priority count. Counter = priority when the task starts to run. The larger the task, the longer it runs.

Long signal. Is a bitmap. Each bit represents a signal. The signal value is equal to the bit offset value + 1.

Struct sigaction [32] signal execution attribute structure, corresponding to the operation and Flag Information of the signal to be executed.

Long blocked process signal shielding code (corresponding signal Bitmap ).

--------------------------

The exit code for the int exit_code task to stop. The exit code is obtained by the parent process.

Unsigned long start_code code segment address.

Unsigned long end_code code length (number of bytes ).

Unsigned long end_data code length + Data Length (bytes ).

Unsigned long BRK total length (number of bytes ).

Unsigned long start_stack stack segment address.

Long PID process ID (process ID ).

Long father parent process ID.

Long pgrp parent process group number.

Long session number.

Long leader session leader.

Unsigned short uid user ID (User ID ).

Unsigned short EUID valid user ID.

Unsigned short suid.

Unsigned short GID group ID ).

Unsigned short EGID valid group ID.

The Group ID that unsigned short SGID saves.

Long alarm time value (number of tick answers ).

Long utime user running time (number of tick answers ).

Long stime system running time (number of tick answers ).

Long cutime sub-process user running time.

Long cstime sub-process system running time.

Long start_time indicates the start time of the process.

Unsigned short used_math flag: whether the coprocessor is used.

--------------------------

The Int tty process uses the sub-device Number of TTY. -1 indicates that it is not used.

Unsigned short umask file.

Struct m_inode * Pwd the structure of the I node in the current working directory.

Struct m_inode * root directory I node structure.

Struct m_inode * executable execution file I node structure.

Unsigned long close_on_exec disables the file handle bitmap flag during execution. (See include/fcntl. h)

The structure of the file table used by the struct file * filp [nr_open] process.

--------------------------

Struct desc_struct LDT [3] local table descriptor of this task. 0-null, 1-code segment CS, 2-data and stack segment DS & SS.

--------------------------

Struct tss_struct TSS the task status segment information structure of this process.

======================================

1. scheduling data member

(1) Volatile long states;

Indicates the current status of the process:

* Task_running: A running process or a running process in the ready queue run-queue. The process is actually scheduled.

* Task_interruptible: a process in the waiting queue that wakes up when the resource is valid. Other processes can wake up by signal (signal) or scheduled interruption to enter the ready queue run-queue.

* Task_uninterruptible: Processes in the waiting queue wake up when the resources are valid. Other processes cannot wake up through signals or scheduled interruptions.

* Task_zombie: A State that indicates that the process has ended but has not died ). At this point, the process has ended and most resources have been released, but the process control block has not been released.

* Task_stopped: the process is paused and can be awakened only by signals from other processes. There are two reasons for this status: Response to the signal sigstop, sigstp, sigttin or sigttou, or control by the ptrace System Call of other processes, temporarily handing over the CPU to the control process.

* Task_swapping: process in which the process page is swapped out of memory.

(2) unsigned long flags;

Process flag:

* Pf_alignwarn prints "alignwarn" warning information.

* Pf_ptraced is monitored by the ptrace system call.

* Pf_tracesys is being tracked.

* The pf_forknoexec process has just been created but has not been executed yet.

* Pf_superpriv Super User Privilege.

* Pf_dumpcore dumped core.

* The pf_signaled process is killed by the signal (signal.

* The pf_starting process is being created.

* The pf_exiting process is disabled.

* Pf_usedfpu this process uses FPU (SMP only ).

* Pf_dtrace delayed trace (used on m68k ).

(3) Long priority;

Process Priority. The value of priority indicates the time (in jiffies) that a process can use after obtaining the CPU ). The priority can be changed by calling sys_setpriorty (in kernel/sys. C ).

(4) unsigned long rt_priority;

Rt_priority indicates the priority of the real-time process. rt_priority + 1000 indicates the time that the process can use after obtaining the CPU (also based on jiffies ). The priority of a real-time process can be changed by calling sys_sched_setscheduler () (see kernel/sched. C ).

(5) Long counter;

During rotation scheduling, it indicates how long the process can run. When the process starts running, it is assigned a value of priority, and the number of tick (clock interruption) decreases by 1 every other time. When it is reduced to 0, a new round of tuning is triggered. Rescheduling selects the ready process with the highest counter value from the run_queue queue and gives the CPU permission. Therefore, counter plays a role in the dynamic priority of the process (priority is the static priority ).

(6) unsigned long policy;

The process scheduling policy of this process can be changed by calling sys_sched_setscheduler () (see kernel/sched. C ). Scheduling policies include:

* Sched_other 0 is a non-real-time process. It is based on the round robin (Round Robin) method ).

* Sched_fifo 1 Real-time process, with the first-in-first-out algorithm.

* Sched_rr 2 Real-time process, which uses the priority-based rotation method.

　　2. Signal Processing

(1) unsigned long signal;

The signal received by the process. Each represents a signal of 32 types. The specified location is valid.

(2) unsigned long blocked;

The bitmask that the process can accept. The position indicates blocking, And the reset indicates not blocking.

(3) struct signal_struct * SIG;

Because both signal and blocked are 32-bit variables, Linux can only accept up to 32 signals. For each signal, each process can choose to use a custom processing function or the system's default processing function from the SIG attribute of the PCB. The structure of various information processing functions is defined in include/Linux/sched. h. The signal check is arranged after the system call ends and after the "slow" interrupt service program ends (IRQ # _ interrupt (), see 9. Section 5 "Start the kernel ").

3. Process queue pointer

(1) struct task_struct * next_task, * prev_task;

All processes (in the form of PCB) form a two-way linked list. Next_task and are the front and back pointers of the linked list. Both the head and end of the linked list are init_task (process 0 ).

(2) struct task_struct * next_run, * prev_run;

A two-way cyclic linked list consisting of running or runable processes whose process statuses are task_running, that is, run_queue ready queue. The forward and backward pointers of the linked list use next_run and prev_run. The head and tail of the linked list are init_task (process 0 ).

(3) struct task_struct * p_opptr, * p_pptr; and struct task_struct * p_cptr, * p_ysptr, * p_osptr;

The above are pointers to the original parent process (original parent), parent process (parent), child process (youngest child), and new and old brother processes (younger sibling, older sibling.

　　4. process ID

(1) unsigned short uid, Gid;

UID and GID are the user ID and user group ID of the running process.

(2) int groups [ngroups];

Like most modern Unix operating systems, Linux allows processes to have a group of user group numbers at the same time. When a process accesses a file, these group numbers can be used for validity checks.

(3) unsigned short EUID, EGID;

EUID and EGID are also called valid UID and GID. For the sake of system security permissions, check the validity of EUID and EGID when running the program. Generally, uid is equal to EUID, and GID is equal to EGID. Sometimes, the system will grant the general user temporary root UID and GID (as the EUID and EGID of the user process) for easy operation.

(4) unsigned short fsuid, fsgid;

Fsuid and fsgid are called the UID and gid of the file system. They are used to check the validity of file system operations and are unique identification types in Linux. Generally, they are the same as EUID and EGID, but in the NFS file system, the NFS server must be used as a special process to access the file. In this case, only the fsuid and fsgid of the customer process are modified.

(5) unsigned short SUID, SGID;

SUID and SGID are introduced according to POSIX standards. They are used to retain the real UID and GID when the system call changes UID and GID.

(6) int PID, pgrp, session;

Process ID, process organization ID, and session ID. system calls (see program kernel/sys. c) Include sys_setpgid, sys_getpgid, sys_setpgrp, sys_getpgrp, sys_getsid, and sys_setsid.

(7) int leader;

Whether it is the session supervisor or a Boolean value.

　　5. Time data member

(1) unsigned long timeout;

It is used for Software Timing to indicate how long the process interval has been awakened again. Tick is used.

(2) unsigned long it_real_value, it_real_iner;

It is used for Interval timer Software Timing. Jiffies is used as the unit, and each tick reduces it_real_value to 0 to send signal sigalrm to the process, and reset the initial value. The initial values are saved by it_real_incr. For specific code, see the it_real_fn () function in kernel/itimer. C ().

(3) struct timer_list real_timer;

A timer structure (two timer structures are available in Linux, and the other is called old_timer ). The data structure is defined in include/Linux/Timer. H. For the relevant operation functions, see add_timer () and del_timer () in kernel/sched. C.

(4) unsigned long it_1__value, it_1__incr;

Timing of the itimer software related to the process user State execution time. Jiffies is used. When a process is running in the user State, each tick causes it_0000_value to be reduced to 1, and when it is reduced to 0, it sends signal sigvtalrm to the process, and resets the initial value. The initial values are saved by it_virt_incr. For specific code, see the do_it_virt () function in kernel/sched. C ().

(5) unsigned long it_prof_value, it_prof_incr;

It is also the timing of the itimer software. Jiffies is used. No matter whether the process is running in the user or kernel state, each tick will reduce it_prof_value by 1 and send signal sigprof to the process when it is reduced to 0, and reset the initial value. The initial values are saved by it_prof_incr. For specific code, see the do_it_prof function in kernel/sched. C.

(6) Long utime, stime, cutime, cstime, start_time;

The preceding steps show the running time of processes in the user State, the running time of processes in the kernel state, the total running time of all levels of sub-processes in the user State, and the running of all levels of sub-processes in the core state. total time, and the time when the process was created.

　　6. semaphore data member

(1) struct sem_undo * semundo;

Each semaphore in a process generates an Undo operation for this operation, which is described by the sem_undo structure. The linked list consisting of Undo operations of the same process is indicated by the semundo attribute. When a process stops abnormally, the system calls the Undo operation. The sem_undo member semadj points to a data array, indicating the number of Undo tasks. The structure is defined in include/Linux/SEM. h.

(2) struct sem_queue * semsleeping;

Each set of semaphores corresponds to a sem_queue waiting queue (see include/Linux/SEM. h ). When a process is blocked by operating on the semaphore set, it is mounted to the sem_queue queue of the Set indicated by semsleeping. In turn, semsleeping. Sleeper points to the PCB of the process.

. Process context

(1) struct desc_struct * LDT;

The pointer of the process's Local Descriptor Table for CPU-Segment Storage Management, used to simulate wine Windows programs. In other cases, if the value is null, the LDT of the process is the arch ult_ldt defined by arch/i386/traps. C.

(2) struct thread_struct TSS;

Task status segment, whose content corresponds to Intel cpu tss, such as various General registers. during CPU scheduling, the TSS of the currently running process is saved to the TSS of the PCB, And the TSS of the newly selected process is copied to the TSS of the CPU. The structure is defined in include/Linux/tasks. h.

(3) unsigned long saved_kernel_stack;

Stack pointer saved for the simulation program of the MS-DOS (or called the system call vm86.

(4) unsigned long kernel_stack_page;

During kernel-state running, each process has a kernel stack, and its base address is stored in kernel_stack_page.

　　8. File System Data Member

(1) struct fs_struct * FS;

FS stores the relationship message between the process itself and VFS, where Root points to the root directory node, PWD points to the current directory node, umask provides the access mode for the new file (which can be changed by the System Call umask). Count is a reserved attribute of Linux, as shown in the following figure. The structure is defined in include/Linux/sched. h.

(2) struct files_struct * files;

Files contains the files currently opened by the process (struct file * FD [nr_open]). In Linux, a process can open up to nr_open files at the same time. In addition, the first three items are pre-configured as standard input, standard output, and error message output files.

(3) int link_count;

The number of links.

　　9. Memory Data Member

(1) struct mm_struct * mm;

In Linux, The on-demand paging policy is used to address the memory requirements of processes. The data member mm of task_struct points to the mm_struct structure about storage management. It contains a virtual memory queue MMAP pointing to the virtual memory block described by several vm_area_struct. To speed up access, mmap_avl in mm maintains an AVL Tree. In the tree, all vm_area_struct virtual memory blocks point from the left pointer to the adjacent low virtual memory blocks, and the right pointer to the adjacent high virtual memory blocks. The structure is defined in include/Linux/sched. h.

　　10. Page Management

(1) int swappable: 1;

Whether the Memory Page occupied by the process can be swapped out. If the value of swappable is 1, it indicates that swappable can be swapped out. The reset and placement of this flag are all executed in the do_fork () function (see kerenl/fork. C ).

(2) unsigned long swap_address;

The process page with a VM address lower than swap_address has previously been swapped out or has been swapped out. The next page that can be swapped out by a process starts with swap_address. See swap_out_process () and swap_out_pmd () (see mm/vmscan. C ).

(3) unsigned long min_flt, maj_flt;

The total number of minor missing pages and the number of major missing pages of the process. Maj_flt is basically the same as min_flt, but the Count range is wider than that of the latter (see fs/buffer. C and mm/page_alloc.c ). Min_flt only counts newly added write-able pages in do_no_page () and do_wp_page () (see mm/memory. C.

(4) unsigned long nswap;

The total number of pages exchanged by this process.

(5) unsigned long cmin_flt, cmaj_flt, cnswap;

The total number of child processes at all levels of this process as the ancestor is counted in and out pages.

(6) unsigned long old_maj_flt, dec_flt;

(7) unsigned long swap_cnt;

The maximum number of pages that can be exchanged for the next signal.

　　11. Support for data members in symmetric multi-processor (SMP) Mode

(1) int processor;

CPU used by the process.

(2) int last_processor;

The CPU used by the process for the last time.

(3) int lock_depth;

The depth of the system kernel lock during context switching.

12. Other data members

(1) unsigned short used_math;

Whether to use FPU.

(2) Char comm [16];

The name of the executable file that the process is running.

(3) struct rlimit rlim [rlim_nlimits];

Rlimit is used for resource management. It is defined in Linux/include/Linux/resource. in H, there are two members: rlim_cur is the current maximum number of resources, and rlim_max is the maximum number of resources. In the i386 environment, the controlled resources have a total of rlim_nlimits items, that is, 10 items, which are defined in Linux/include/ASM/resource. H. See the following table:

(4) int errno;

The system call error code for the last error. 0 indicates no error. This error number is also available for the full process returned by the system call.

(5) Long debugreg [8];

Saves the Intel CPU debugging register value, which is used in ptrace system calls.

(6) struct exec_domain * exec_domain;

Linux can run programs that comply with the ibcs2 standard generated by other UNIX operating systems on the 80386 platform. Messages about the differences between such programs and Linux programs are saved in the exec_domain structure.

(7) unsigned long personality;

Linux can run programs that comply with the ibcs2 standard generated by other UNIX operating systems on the 80386 platform. Personality further describes the UNIX platform's "personality" information of the program being executed by the process. Per_linux, per_linux_32bit, per_linux_em86, per_svr3, per_scosvr3, kernel, per_iscr4, per_bsd, per_xenix, and per_mask. For details, see include/Linux/personality. h.

(8) struct linux_binfmt * binfmt;

Point to the global execution File Format Structure of the process, a in total. Out, script, elf, and Java. The structure is defined in include/Linux/binfmts. H (core_dump, load_shlib (FD), load_binary, and use_count ).

(9) int exit_code, exit_signal;

The return code exit_code that causes the process to exit, causing the wrong signal name exit_signal.

(10) int dumpable: 1;

Boolean, indicating whether memory dump can be performed when an error occurs.

(11) int did_exec: 1;

The POSIX-based Boolean design distinguishes whether the process is executing the old program code or executing the new Code loaded by execve.

(12) int tty_old_pgrp;

The process displays the group ID of the terminal.

(13) struct tty_struct * tty;

Point to the display terminal where the process is located. If the process does not need to display terminals, such as process 0, the pointer is null. The structure is defined in include/Linux/tty. h.

(14) struct wait_queue * wait_chldexit;

After the process ends or wait4 is called by the system, you can sleep yourself (parent process) in the queue to wait for the child process to end. The structure is defined in include/Linux/Wait. H.

　　13. global variables of the Process queue

(1) Current;

The pointer to the currently running process. In SMP, it points to the current process of the CPU being scheduled in the CPU group:

# Define current (0 + current_set [smp_processor_id ()])/* sched. H */

Struct task_struct * current_set [nr_cpus];

(2) struct task_struct init_task;

That is, the PCB of process 0 is the "root" of the process, and the initial value is always init_task.

(3) struct task_struct * task [nr_tasks];

The maximum number of processes that the system can run simultaneously (see kernel/sched. C ). Nr_tasks is defined in include/Linux/tasks. h and the value is 512. Each process occupies an array element (the subscript of the element is not necessarily the PID of the process). task [0] must point to init_task (process 0 ). You can use the task [] array to traverse the PCB of all processes. However, Linux also provides a macro definition for_each_task () (see include/Linux/sched. h), which traverses the PCB of all processes through next_task:

# Define for_each_task (P )/

For (P = & init_task; (P = p-> next_task )! = & Init_task ;)

(4) unsigned long volatile jiffies;

Linux benchmark time (see kernal/sched. C ). When the system is initialized, the value 0 is cleared. After that, the clock interruption service program do_timer () increases by 1 every 10 ms.

(5) int need_resched;

Reschedule flag bit (see kernal/sched. C ). When Linux scheduling is required. Determine whether the flag is set before the system call returns (or in other cases. Call schedule immediately for CPU scheduling.

(6) unsigned long intr_count;

Record the number of nested layers of the interrupt service program (see kernal/softirq. C ). During normal operation, the intr_count value is 0. When processing hardware interruptions, executing tasks in the task queue, or executing tasks in the bottom half queue, intr_count is not 0. In this case, the kernel prohibits some operations, such as rescheduling.