linux-schedule()学习——001

本文深入探讨Linux操作系统中的调度模块,包括无参宏定义防止头文件重复包含、任务状态和优先级、进程调度函数schedule的实现,以及系统启动过程中涉及的文件和函数。文章详细解析了任务状态段数据结构task_struct,涵盖进程状态、信号处理、时间数据成员、内存管理和文件系统等多个方面,旨在帮助读者理解Linux内核的调度机制。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

一 无参宏定义

#ifndef _SCHED_H

#define _SCHED_H

这是无参宏定义 :防止一个头文件被重复包含。

二 Linux各个功能模块之间的依赖关系



三 pc是怎样把操作系统从硬盘装载到内存中,并启动进程调度模块的。

   

    启动操作系统部分,涉及到三个文件:/arch/i386/boot/bootsect.s/arch/i386/boot/setup.s/arch/i386/boot/compressed/head.s。编译安装好一个Linux系统后,bootsect.s模块被放置在可启动设备的第一个扇区(磁盘引导扇区,512字节)。那么下面开始启动过程,三个文件在内存中的分布与位置如下图所述:


    


       在经过上图这一系列过程后,程序跳转到system模块中的初始化程序init执行,即/init/main.c文件。该程序执行一系列的初始化工作,如寄存器初始化、内存初始化、终端设置等。之后内存分配粗下图:


    此后cpu有序从内存中读取程序并执行,前面的main从内核态移动到用户态后,操作系统即简历了任务0,即进程调度程序。之后再由schedule模块进行整个linux操作系统中进程的创建(fork)、调度(schedule)、销毁(exit)及各种资源的分配与管理等操作了。注意:schedule将创建的第一个进程是init(pid=1),它不是前面的程序段。

  




三附录

inux_sched.h源码

#ifndef _SCHED_H

#define _SCHED_H//头文件内容  防止一个头文件被重复包含 无参数宏

#define NR_TASKS 64        // 系统中同时最多任务(进程)数。

#define HZ 100            // 定义系统时钟滴答频率(1 百赫兹,每个滴答10ms)

#define FIRST_TASK task[0]    // 任务比较特殊,所以特意给它单独定义一个符号。

#define LAST_TASK task[NR_TASKS-1]    // 任务数组中的最后一项任务。

#include <linux/head.h>   // head 头文件,定义了段描述符的简单结构,和几个选择符常量。

#include <linux/fs.h>   // 文件系统头文件。定义文件表结构(file,buffer_head,m_inode 等)。

#include <linux/mm.h>   // 内存管理头文件。含有页面大小定义和一些页面释放函数原型。

#include <signal.h>   // 信号头文件。定义信号符号常量,信号结构以及信号操作函数原型。

#if (NR_OPEN > 32)

#error "Currently the close-on-exec-flags are in one word, max 32 files/proc"

#endif

// 这里定义了进程运行可能处的状态。

#define TASK_RUNNING 0        // 进程正在运行或已准备就绪。

#define TASK_INTERRUPTIBLE 1    // 进程处于可中断等待状态。

#define TASK_UNINTERRUPTIBLE 2  // 进程处于不可中断等待状态,主要用于I/O 操作等待。

#define TASK_ZOMBIE 3        // 进程处于僵死状态,已经停止运行,但父进程还没发信号。

#define TASK_STOPPED 4        // 进程已停止。

#ifndef NULL

#define NULL ((void *) 0)    // 定义NULL 为空指针。

#endif

// 复制进程的页目录页表。Linus 认为这是内核中最复杂的函数之一。( mm/memory.c, 105 )

extern int copy_page_tables (unsigned long from, unsigned long to, long size);

// 释放页表所指定的内存块及页表本身。( mm/memory.c, 150 )

extern int free_page_tables (unsigned long from, unsigned long size);

// 调度程序的初始化函数。( kernel/sched.c, 385 )

extern void sched_init (void);

// 进程调度函数。( kernel/sched.c, 104 )

extern void schedule (void);

// 异常(陷阱)中断处理初始化函数,设置中断调用门并允许中断请求信号。( kernel/traps.c, 181 )

extern void trap_init (void);

// 显示内核出错信息,然后进入死循环。( kernel/panic.c, 16 )

extern void panic (const char *str);

// tty 上写指定长度的字符串。( kernel/chr_drv/tty_io.c, 290 )

extern int tty_write (unsigned minor, char *buf, int count);

typedef int (*fn_ptr) ();    // 定义函数指针类型。

// 下面是数学协处理器使用的结构,主要用于保存进程切换时i387 的执行状态信息。

struct i387_struct

{

  long cwd;            // 控制字(Control word)

  long swd;            // 状态字(Status word)

  long twd;            // 标记字(Tag word)

  long fip;            // 协处理器代码指针。

  long fcs;            // 协处理器代码段寄存器。

  long foo;

  long fos;

  long st_space[20];       

};

// 任务状态段数据结构(参见列表后的信息)。

struct tss_struct

{

  long back_link;       

  long esp0;

  long ss0;           

  long esp1;

  long ss1;           

  long esp2;

  long ss2;           

  long cr3;

  long eip;

  long eflags;

  long eax, ecx, edx, ebx;

  long esp;

  long ebp;

  long esi;

  long edi;

  long es;           

  long cs;           

  long ss;           

  long ds;           

  long fs;           

  long gs;           

  long ldt;           

  long trace_bitmap;       

  struct i387_struct i387;

};

// 这里是任务(进程)数据结构,或称为进程描述符。

// ==========================

// long state 任务的运行状态(-1 不可运行,可运行(就绪)>0 已停止)。

// long counter 任务运行时间计数(递减)(滴答数),运行时间片。

// long priority 运行优先数。任务开始运行时counter = priority,越大运行越长。

// long signal 信号。是位图,每个比特位代表一种信号,信号值=位偏移值+1

// struct sigaction sigaction[32] 信号执行属性结构,对应信号将要执行的操作和标志信息。

// long blocked 进程信号屏蔽码(对应信号位图)。

// --------------------------

// int exit_code 任务执行停止的退出码,其父进程会取。

// unsigned long start_code 代码段地址。

// unsigned long end_code 代码长度(字节数)。

// unsigned long end_data 代码长度 数据长度(字节数)。

// unsigned long brk 总长度(字节数)。

// unsigned long start_stack 堆栈段地址。

// long pid 进程标识号(进程号)

// long father 父进程号。

// long pgrp 父进程组号。

// long session 会话号。

// long leader 会话首领。

// unsigned short uid 用户标识号(用户id)。

// unsigned short euid 有效用户id

// unsigned short suid 保存的用户id

// unsigned short gid 组标识号(组id)。

// unsigned short egid 有效组id

// unsigned short sgid 保存的组id

// long alarm 报警定时值(滴答数)。

// long utime 用户态运行时间(滴答数)。

// long stime 系统态运行时间(滴答数)。

// long cutime 子进程用户态运行时间。

// long cstime 子进程系统态运行时间。

// long start_time 进程开始运行时刻。

// unsigned short used_math 标志:是否使用了协处理器。

// --------------------------

// int tty 进程使用tty 的子设备号。-1 表示没有使用。

// unsigned short umask 文件创建属性屏蔽位。

// struct m_inode * pwd 当前工作目录节点结构。

// struct m_inode * root 根目录节点结构。

// struct m_inode * executable 执行文件节点结构。

// unsigned long close_on_exec 执行时关闭文件句柄位图标志。(参见include/fcntl.h

// struct file * filp[NR_OPEN] 进程使用的文件表结构。

// --------------------------

// struct desc_struct ldt[3] 本任务的局部表描述符。0-空,1-代码段cs2-数据和堆栈段ds&ss

// --------------------------

// struct tss_struct tss 本进程的任务状态段信息结构。

// ==========================

struct task_struct

{

 

  long state;           

  long counter;

  long priority;

  long signal;

  struct sigaction sigaction[32];

  long blocked;           

 

  int exit_code;

  unsigned long start_code, end_code, end_data, brk, start_stack;

  long pid, father, pgrp, session, leader;

  unsigned short uid, euid, suid;

  unsigned short gid, egid, sgid;

  long alarm;

  long utime, stime, cutime, cstime, start_time;

  unsigned short used_math;

 

  int tty;           

  unsigned short umask;

  struct m_inode *pwd;

  struct m_inode *root;

  struct m_inode *executable;

  unsigned long close_on_exec;

  struct file *filp[NR_OPEN];

 

  struct desc_struct ldt[3];

 

  struct tss_struct tss;

};

 

 

// 对应上面任务结构的第个任务的信息。

#define INIT_TASK \

{ 0,15,15, \    // state, counter, priority

0,

{

  {

  }

,}

, 0, \                // signal, sigaction[32], blocked

                    0, 0, 0, 0, 0, 0, \

                    // exit_code,start_code,end_code,end_data,brk,start_stack

                    0, -1, 0, 0, 0, \

                    // pid, father, pgrp, session, leader

                    0, 0, 0, 0, 0, 0, \

                    // uid, euid, suid, gid, egid, sgid

                    0, 0, 0, 0, 0, 0, \

                    // alarm, utime, stime, cutime, cstime, start_time

                0, \

                // used_math

                            -1, 0022, NULL, NULL, NULL, 0, \

                            // tty,umask,pwd,root,executable,close_on_exec

 

{

NULL,}

, \                // filp[20]

{

  \                // ldt[3]

  {

  0, 0}

  ,

 

  {

  0x9f, 0xc0fa00}

  , \                // 代码长640K,基址0x0G=1D=1DPL=3P=1 TYPE=0x0a

  {

  0x9f, 0xc0f200}

  , \                // 数据长640K,基址0x0G=1D=1DPL=3P=1 TYPE=0x02

}

,

 

{

  0, PAGE_SIZE + (long) &init_task, 0x10, 0, 0, 0, 0, (long) &pg_dir, \    // tss

    0, 0, 0, 0, 0, 0, 0, 0,

    0, 0, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, _LDT (0), 0x80000000,

  {

  }

}

,}

extern struct task_struct *task[NR_TASKS];    // 任务数组。

extern struct task_struct *last_task_used_math;    // 上一个使用过协处理器的进程。

extern struct task_struct *current;    // 当前进程结构指针变量。

extern long volatile jiffies;    // 从开机开始算起的滴答数(10ms/滴答)。

extern long startup_time;    // 开机时间。从1970:0:0:0 开始计时的秒数。

#define CURRENT_TIME (startup_time+jiffies/HZ)    // 当前时间(秒数)。

// 添加定时器函数(定时时间jiffies 滴答数,定时到时调用函数*fn())。( kernel/sched.c,272)

extern void add_timer (long jiffies, void (*fn) (void));

// 不可中断的等待睡眠。( kernel/sched.c, 151 )

extern void sleep_on (struct task_struct **p);

// 可中断的等待睡眠。( kernel/sched.c, 167 )

extern void interruptible_sleep_on (struct task_struct **p);

// 明确唤醒睡眠的进程。( kernel/sched.c, 188 )

extern void wake_up (struct task_struct **p);

 

 

// 全局表中第个任务状态段(TSS)描述符的选择符索引号。

#define FIRST_TSS_ENTRY 4

// 全局表中第个局部描述符表(LDT)描述符的选择符索引号。

#define FIRST_LDT_ENTRY (FIRST_TSS_ENTRY+1)

// 宏定义,计算在全局表中第个任务的TSS 描述符的索引号(选择符)。

#define _TSS(n) ((((unsigned long) n)<<4)+(FIRST_TSS_ENTRY<<3))

// 宏定义,计算在全局表中第个任务的LDT 描述符的索引号。

#define _LDT(n) ((((unsigned long) n)<<4)+(FIRST_LDT_ENTRY<<3))

// 宏定义,加载第个任务的任务寄存器tr

#define ltr(n) __asm__( "ltr %%ax":: "a" (_TSS(n)))

// 宏定义,加载第个任务的局部描述符表寄存器ldtr

#define lldt(n) __asm__( "lldt %%ax":: "a" (_LDT(n)))

// 取当前运行任务的任务号(是任务数组中的索引值,与进程号pid 不同)。

// 返回:n - 当前任务号。用于( kernel/traps.c, 79)

#define str(n) \

__asm__( "str %%ax\n\t" \    // 将任务寄存器中TSS 段的有效地址??ax

"subl %2,%%eax\n\t" \        // (eax - FIRST_TSS_ENTRY*8)??eax

  "shrl $4,%%eax" \        // (eax/16)??eax = 当前任务号。

: "=a" (n):"a" (0), "i" (FIRST_TSS_ENTRY << 3))

 

 

// 输入:%0 - TSS 的偏移地址(*&__tmp.a); %1 - 存放新TSS 的选择符值(*&__tmp.b)

// dx - 新任务的选择符;ecx - 新任务指针task[n]

// 其中临时数据结构__tmp 中,的值是32 位偏移值,为新TSS 的选择符。在任务切换时,

// 没有用(忽略)。在判断新任务上次执行是否使用过协处理器时,是通过将新任务状态段的地址与

// 保存在last_task_used_math 变量中的使用过协处理器的任务状态段的地址进行比较而作出的。

#define switch_to(n) {\

struct {long a,b;} __tmp; \

__asm__( "cmpl %%ecx,_current\n\t" \    // 任务是当前任务吗?(current ==task[n]?)

  "je 1f\n\t" \            // 是,则什么都不做,退出。

  "movw %%dx,%1\n\t" \        // 将新任务的选择符??*&__tmp.b

  "xchgl %%ecx,_current\n\t" \    // current = task[n]ecx = 被切换出的任务。

  "ljmp %0\n\t" \        // 执行长跳转至*&__tmp,造成任务切换。

// 在任务切换回来后才会继续执行下面的语句。

  "cmpl %%ecx,_last_task_used_math\n\t" \    // 新任务上次使用过协处理器吗?

  "jne 1f\n\t" \        // 没有则跳转,退出。

  "clts\n" \            // 新任务上次使用过协处理器,则清cr0 TS 标志。

  "1:"::"m" (*&__tmp.a), "m" (*&__tmp.b),

  "d" (_TSS (n)), "c" ((long) task[n]));

}

// 页面地址对准。(在内核代码中没有任何地方引用!!

#define PAGE_ALIGN(n) (((n)+0xfff)&0xfffff000)

// 设置位于地址addr 处描述符中的各基地址字段(基地址是base),参见列表后说明。

// %0 - 地址addr 偏移2%1 - 地址addr 偏移4%2 - 地址addr 偏移7edx - 基地址base

#define _set_base(addr,base) \

__asm__( "movw %%dx,%0\n\t" \    // 基址base 16 (15-0)??[addr+2]

"rorl $16,%%edx\n\t" \        // edx 中基址高16 (31-16)??dx

  "movb %%dl,%1\n\t" \        // 基址高16 位中的低(23-16)??[addr+4]

  "movb %%dh,%2" \        // 基址高16 位中的高(31-24)??[addr+7]

::"m" (*((addr) + 2)), "m" (*((addr) + 4)), "m" (*((addr) + 7)), "d" (base):"dx")

// 设置位于地址addr 处描述符中的段限长字段(段长是limit)

// %0 - 地址addr%1 - 地址addr 偏移处;edx - 段长值limit

#define _set_limit(addr,limit) \

__asm__( "movw %%dx,%0\n\t" \    // 段长limit 16 (15-0)??[addr]

  "rorl $16,%%edx\n\t" \    // edx 中的段长高(19-16)??dl

  "movb %1,%%dh\n\t" \        // 取原[addr+6]字节??dh,其中高位是些标志。

  "andb $0xf0,%%dh\n\t" \    // dh 的低(将存放段长的位19-16)

  "orb %%dh,%%dl\n\t" \        // 将原高位标志和段长的高(19-16)合成字节,

  "movb %%dl,%1" \        // 并放会[addr+6]处。

::"m" (*(addr)), "m" (*((addr) + 6)), "d" (limit):"dx")

// 设置局部描述符表中ldt 描述符的基地址字段。

#define set_base(ldt,base) _set_base( ((char *)&(ldt)) , base )

// 设置局部描述符表中ldt 描述符的段长字段。

#define set_limit(ldt,limit) _set_limit( ((char *)&(ldt)) , (limit-1)>>12 )

// 从地址addr 处描述符中取段基地址。功能与_set_base()正好相反。

// edx - 存放基地址(__base)%1 - 地址addr 偏移2%2 - 地址addr 偏移4%3 - addr 偏移7

#define _get_base(addr) ({\

unsigned long __base; \

__asm__( "movb %3,%%dh\n\t" \    // [addr+7]处基址高16 位的高(31-24)??dh

  "movb %2,%%dl\n\t" \        // [addr+4]处基址高16 位的低(23-16)??dl

  "shll $16,%%edx\n\t" \    // 基地址高16 位移到edx 中高16 位处。

  "movw %1,%%dx" \        // [addr+2]处基址低16 (15-0)??dx

:"=d" (__base) \        // 从而edx 中含有32 位的段基地址。

:"m" (*((addr) + 2)), "m" (*((addr) + 4)), "m" (*((addr) + 7)));

__base;

}

)

// 取局部描述符表中ldt 所指段描述符中的基地址。

#define get_base(ldt) _get_base( ((char *)&(ldt)) )

// 取段选择符segment 的段长值。

// %0 - 存放段长值(字节数)%1 - 段选择符segment

#define get_limit(segment) ({ \

unsigned long __limit; \

__asm__( "lsll %1,%0\n\tincl %0": "=r" (__limit): "r" (segment)); \

__limit;})

#endif

 

 

 

 

linuxsched.h源码文件分析

2011-05-08 22:17:04

#ifndef _SCHED_H
#define _SCHED_H
#define NR_TASKS 64 // 系统中同时最多任务(进程)数。
#define HZ 100 // 定义系统时钟滴答频率(1 百赫兹,每个滴答10ms)
#define FIRST_TASK task[0] // 任务比较特殊,所以特意给它单独定义一个符号。
#define LAST_TASK task[NR_TASKS-1] // 任务数组中的最后一项任务。
#include <linux/head.h> // head 头文件,定义了段描述符的简单结构,和几个选择符常量。
#include <linux/fs.h> // 文件系统头文件。定义文件表结构(file,buffer_head,m_inode 等)。
#include <linux/mm.h> // 内存管理头文件。含有页面大小定义和一些页面释放函数原型。
#include <signal.h> // 信号头文件。定义信号符号常量,信号结构以及信号操作函数原型。
#if (NR_OPEN > 32)
#error "Currently the close-on-exec-flags are in one word, max 32 files/proc"
#endif
// 这里定义了进程运行可能处的状态。
#define TASK_RUNNING 0 // 进程正在运行或已准备就绪。
#define TASK_INTERRUPTIBLE 1 // 进程处于可中断等待状态。
#define TASK_UNINTERRUPTIBLE 2 // 进程处于不可中断等待状态,主要用于I/O 操作等待。
#define TASK_ZOMBIE 3 // 进程处于僵死状态,已经停止运行,但父进程还没发信号。
#define TASK_STOPPED 4 // 进程已停止。
#ifndef NULL
#define NULL ((void *) 0) // 定义NULL 为空指针。
#endif
// 复制进程的页目录页表。Linus 认为这是内核中最复杂的函数之一。( mm/memory.c, 105 )
extern int copy_page_tables (unsigned long from, unsigned long to, long size);
// 释放页表所指定的内存块及页表本身。( mm/memory.c, 150 )
extern int free_page_tables (unsigned long from, unsigned long size);
// 调度程序的初始化函数。( kernel/sched.c, 385 )
extern void sched_init (void);
// 进程调度函数。( kernel/sched.c, 104 )
extern void schedule (void);
// 异常(陷阱)中断处理初始化函数,设置中断调用门并允许中断请求信号。( kernel/traps.c, 181 )
extern void trap_init (void);
// 显示内核出错信息,然后进入死循环。( kernel/panic.c, 16 )
extern void panic (const char *str);
// tty 上写指定长度的字符串。( kernel/chr_drv/tty_io.c, 290 )
extern int tty_write (unsigned minor, char *buf, int count);
typedef int (*fn_ptr) (); // 定义函数指针类型。
// 下面是数学协处理器使用的结构,主要用于保存进程切换时i387 的执行状态信息。
struct i387_struct
{
  long cwd; // 控制字(Control word)
  long swd; // 状态字(Status word)
  long twd; // 标记字(Tag word)
  long fip; // 协处理器代码指针。
  long fcs; // 协处理器代码段寄存器。
  long foo;
  long fos;
  long st_space[20]; /* 8*10 bytes for each FP-reg = 80 bytes */
};
// 任务状态段数据结构(参见列表后的信息)。
struct tss_struct
{
  long back_link; /* 16 high bits zero */
  long esp0;
  long ss0; /* 16 high bits zero */
  long esp1;
  long ss1; /* 16 high bits zero */
  long esp2;
  long ss2; /* 16 high bits zero */
  long cr3;
  long eip;
  long eflags;
  long eax, ecx, edx, ebx;
  long esp;
  long ebp;
  long esi;
  long edi;
  long es; /* 16 high bits zero */
  long cs; /* 16 high bits zero */
  long ss; /* 16 high bits zero */
  long ds; /* 16 high bits zero */
  long fs; /* 16 high bits zero */
  long gs; /* 16 high bits zero */
  long ldt; /* 16 high bits zero */
  long trace_bitmap; /* bits: trace 0, bitmap 16-31 */
  struct i387_struct i387;
};
// 这里是任务(进程)数据结构,或称为进程描述符。
// ==========================
// long state 任务的运行状态(-1 不可运行,可运行(就绪)>0 已停止)。
// long counter 任务运行时间计数(递减)(滴答数),运行时间片。
// long priority 运行优先数。任务开始运行时counter = priority,越大运行越长。
// long signal 信号。是位图,每个比特位代表一种信号,信号值=位偏移值+1
// struct sigaction sigaction[32] 信号执行属性结构,对应信号将要执行的操作和标志信息。
// long blocked 进程信号屏蔽码(对应信号位图)。
// --------------------------
// int exit_code 任务执行停止的退出码,其父进程会取。
// unsigned long start_code 代码段地址。
// unsigned long end_code 代码长度(字节数)。
// unsigned long end_data 代码长度 数据长度(字节数)。
// unsigned long brk 总长度(字节数)。
// unsigned long start_stack 堆栈段地址。
// long pid 进程标识号(进程号)
// long father 父进程号。
// long pgrp 父进程组号。
// long session 会话号。
// long leader 会话首领。
// unsigned short uid 用户标识号(用户id)。
// unsigned short euid 有效用户id
// unsigned short suid 保存的用户id
// unsigned short gid 组标识号(组id)。
// unsigned short egid 有效组id
// unsigned short sgid 保存的组id
// long alarm 报警定时值(滴答数)。
// long utime 用户态运行时间(滴答数)。
// long stime 系统态运行时间(滴答数)。
// long cutime 子进程用户态运行时间。
// long cstime 子进程系统态运行时间。
// long start_time 进程开始运行时刻。
// unsigned short used_math 标志:是否使用了协处理器。
// --------------------------
// int tty 进程使用tty 的子设备号。-1 表示没有使用。
// unsigned short umask 文件创建属性屏蔽位。
// struct m_inode * pwd 当前工作目录节点结构。
// struct m_inode * root 根目录节点结构。
// struct m_inode * executable 执行文件节点结构。
// unsigned long close_on_exec 执行时关闭文件句柄位图标志。(参见include/fcntl.h
// struct file * filp[NR_OPEN] 进程使用的文件表结构。
// --------------------------
// struct desc_struct ldt[3] 本任务的局部表描述符。0-空,1-代码段cs2-数据和堆栈段ds&ss
// --------------------------
// struct tss_struct tss 本进程的任务状态段信息结构。
// ==========================
struct task_struct
{
/* these are hardcoded - don't touch */
  long state; /* -1 unrunnable, 0 runnable, >0 stopped */
  long counter;
  long priority;
  long signal;
  struct sigaction sigaction[32];
  long blocked; /* bitmap of masked signals */
/* various fields */
  int exit_code;
  unsigned long start_code, end_code, end_data, brk, start_stack;
  long pid, father, pgrp, session, leader;
  unsigned short uid, euid, suid;
  unsigned short gid, egid, sgid;
  long alarm;
  long utime, stime, cutime, cstime, start_time;
  unsigned short used_math;
/* file system info */
  int tty; /* -1 if no tty, so it must be signed */
  unsigned short umask;
  struct m_inode *pwd;
  struct m_inode *root;
  struct m_inode *executable;
  unsigned long close_on_exec;
  struct file *filp[NR_OPEN];
/* ldt for this task 0 - zero 1 - cs 2 - ds&ss */
  struct desc_struct ldt[3];
/* tss for this task */
  struct tss_struct tss;
};
/*
* INIT_TASK is used to set up the first task table, touch at
* your own risk!. Base=0, limit=0x9ffff (=640kB)
*/
/*
* INIT_TASK 用于设置第个任务表,若想修改,责任自负?
基址Base = 0,段长limit = 0x9ffff=640kB)。
*/
// 对应上面任务结构的第个任务的信息。
#define INIT_TASK \
/* state etc */ { 0,15,15, \ // state, counter, priority
/* signals */ 0,
{
  {
  }
,}
, 0, \ // signal, sigaction[32], blocked
                    /* ec,brk... */ 0, 0, 0, 0, 0, 0, \
                    // exit_code,start_code,end_code,end_data,brk,start_stack
                    /* pid etc.. */ 0, -1, 0, 0, 0, \
                    // pid, father, pgrp, session, leader
                    /* uid etc */ 0, 0, 0, 0, 0, 0, \
                    // uid, euid, suid, gid, egid, sgid
                    /* alarm */ 0, 0, 0, 0, 0, 0, \
                    // alarm, utime, stime, cutime, cstime, start_time
                /* math */ 0, \
                // used_math
                            /* fs info */ -1, 0022, NULL, NULL, NULL, 0, \
                            // tty,umask,pwd,root,executable,close_on_exec
/* filp */
{
NULL,}
, \ // filp[20]
{
  \ // ldt[3]
  {
  0, 0}
  ,
/* ldt */
  {
  0x9f, 0xc0fa00}
  , \ // 代码长640K,基址0x0G=1D=1DPL=3P=1 TYPE=0x0a
  {
  0x9f, 0xc0f200}
  , \ // 数据长640K,基址0x0G=1D=1DPL=3P=1 TYPE=0x02
}
,
/*tss*/
{
  0, PAGE_SIZE + (long) &init_task, 0x10, 0, 0, 0, 0, (long) &pg_dir, \ // tss
    0, 0, 0, 0, 0, 0, 0, 0,
    0, 0, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, _LDT (0), 0x80000000,
  {
  }
}
,}
extern struct task_struct *task[NR_TASKS]; // 任务数组。
extern struct task_struct *last_task_used_math; // 上一个使用过协处理器的进程。
extern struct task_struct *current; // 当前进程结构指针变量。
extern long volatile jiffies; // 从开机开始算起的滴答数(10ms/滴答)。
extern long startup_time; // 开机时间。从1970:0:0:0 开始计时的秒数。
#define CURRENT_TIME (startup_time+jiffies/HZ) // 当前时间(秒数)。
// 添加定时器函数(定时时间jiffies 滴答数,定时到时调用函数*fn())。( kernel/sched.c,272)
extern void add_timer (long jiffies, void (*fn) (void));
// 不可中断的等待睡眠。( kernel/sched.c, 151 )
extern void sleep_on (struct task_struct **p);
// 可中断的等待睡眠。( kernel/sched.c, 167 )
extern void interruptible_sleep_on (struct task_struct **p);
// 明确唤醒睡眠的进程。( kernel/sched.c, 188 )
extern void wake_up (struct task_struct **p);
/*
* Entry into gdt where to find first TSS. 0-nul, 1-cs, 2-ds, 3-syscall
* 4-TSS0, 5-LDT0, 6-TSS1 etc ...
*/
/*
寻找第TSS 在全局表中的入口。0-没有用nul1-代码段cs2-数据段ds3-系统段syscall
* 4-任务状态段TSS05-局部表LTD06-任务状态段TSS1,等。
*/
// 全局表中第个任务状态段(TSS)描述符的选择符索引号。
#define FIRST_TSS_ENTRY 4
// 全局表中第个局部描述符表(LDT)描述符的选择符索引号。
#define FIRST_LDT_ENTRY (FIRST_TSS_ENTRY+1)
// 宏定义,计算在全局表中第个任务的TSS 描述符的索引号(选择符)。
#define _TSS(n) ((((unsigned long) n)<<4)+(FIRST_TSS_ENTRY<<3))
// 宏定义,计算在全局表中第个任务的LDT 描述符的索引号。
#define _LDT(n) ((((unsigned long) n)<<4)+(FIRST_LDT_ENTRY<<3))
// 宏定义,加载第个任务的任务寄存器tr
#define ltr(n) __asm__( "ltr %%ax":: "a" (_TSS(n)))
// 宏定义,加载第个任务的局部描述符表寄存器ldtr
#define lldt(n) __asm__( "lldt %%ax":: "a" (_LDT(n)))
// 取当前运行任务的任务号(是任务数组中的索引值,与进程号pid 不同)。
// 返回:n - 当前任务号。用于( kernel/traps.c, 79)
#define str(n) \
__asm__( "str %%ax\n\t" \ // 将任务寄存器中TSS 段的有效地址??ax
"subl %2,%%eax\n\t" \ // (eax - FIRST_TSS_ENTRY*8)??eax
  "shrl $4,%%eax" \ // (eax/16)??eax = 当前任务号。
: "=a" (n):"a" (0), "i" (FIRST_TSS_ENTRY << 3))
/*
* switch_to(n) should switch tasks to task nr n, first
* checking that n isn't the current task, in which case it does nothing.
* This also clears the TS-flag if the task we switched to has used
* tha math co-processor latest.
*/
/*
* switch_to(n)将切换当前任务到任务nr,即n。首先检测任务不是当前任务,
如果是则什么也不做退出。如果我们切换到的任务最近(上次运行)使用过数学
协处理器的话,则还需复位控制寄存器cr0 中的TS 标志。
*/
// 输入:%0 - TSS 的偏移地址(*&__tmp.a); %1 - 存放新TSS 的选择符值(*&__tmp.b)
// dx - 新任务的选择符;ecx - 新任务指针task[n]
// 其中临时数据结构__tmp 中,的值是32 位偏移值,为新TSS 的选择符。在任务切换时,
// 没有用(忽略)。在判断新任务上次执行是否使用过协处理器时,是通过将新任务状态段的地址与
// 保存在last_task_used_math 变量中的使用过协处理器的任务状态段的地址进行比较而作出的。
#define switch_to(n) {\
struct {long a,b;} __tmp; \
__asm__( "cmpl %%ecx,_current\n\t" \ // 任务是当前任务吗?(current ==task[n]?)
  "je 1f\n\t" \ // 是,则什么都不做,退出。
  "movw %%dx,%1\n\t" \ // 将新任务的选择符??*&__tmp.b
  "xchgl %%ecx,_current\n\t" \ // current = task[n]ecx = 被切换出的任务。
  "ljmp %0\n\t" \ // 执行长跳转至*&__tmp,造成任务切换。
// 在任务切换回来后才会继续执行下面的语句。
  "cmpl %%ecx,_last_task_used_math\n\t" \ // 新任务上次使用过协处理器吗?
  "jne 1f\n\t" \ // 没有则跳转,退出。
  "clts\n" \ // 新任务上次使用过协处理器,则清cr0 TS 标志。
  "1:"::"m" (*&__tmp.a), "m" (*&__tmp.b),
  "d" (_TSS (n)), "c" ((long) task[n]));
}
// 页面地址对准。(在内核代码中没有任何地方引用!!
#define PAGE_ALIGN(n) (((n)+0xfff)&0xfffff000)
// 设置位于地址addr 处描述符中的各基地址字段(基地址是base),参见列表后说明。
// %0 - 地址addr 偏移2%1 - 地址addr 偏移4%2 - 地址addr 偏移7edx - 基地址base
#define _set_base(addr,base) \
__asm__( "movw %%dx,%0\n\t" \ // 基址base 16 (15-0)??[addr+2]
"rorl $16,%%edx\n\t" \ // edx 中基址高16 (31-16)??dx
  "movb %%dl,%1\n\t" \ // 基址高16 位中的低(23-16)??[addr+4]
  "movb %%dh,%2" \ // 基址高16 位中的高(31-24)??[addr+7]
::"m" (*((addr) + 2)), "m" (*((addr) + 4)), "m" (*((addr) + 7)), "d" (base):"dx")
// 设置位于地址addr 处描述符中的段限长字段(段长是limit)
// %0 - 地址addr%1 - 地址addr 偏移处;edx - 段长值limit
#define _set_limit(addr,limit) \
__asm__( "movw %%dx,%0\n\t" \ // 段长limit 16 (15-0)??[addr]
  "rorl $16,%%edx\n\t" \ // edx 中的段长高(19-16)??dl
  "movb %1,%%dh\n\t" \ // 取原[addr+6]字节??dh,其中高位是些标志。
  "andb $0xf0,%%dh\n\t" \ // dh 的低(将存放段长的位19-16)
  "orb %%dh,%%dl\n\t" \ // 将原高位标志和段长的高(19-16)合成字节,
  "movb %%dl,%1" \ // 并放会[addr+6]处。
::"m" (*(addr)), "m" (*((addr) + 6)), "d" (limit):"dx")
// 设置局部描述符表中ldt 描述符的基地址字段。
#define set_base(ldt,base) _set_base( ((char *)&(ldt)) , base )
// 设置局部描述符表中ldt 描述符的段长字段。
#define set_limit(ldt,limit) _set_limit( ((char *)&(ldt)) , (limit-1)>>12 )
// 从地址addr 处描述符中取段基地址。功能与_set_base()正好相反。
// edx - 存放基地址(__base)%1 - 地址addr 偏移2%2 - 地址addr 偏移4%3 - addr 偏移7
#define _get_base(addr) ({\
unsigned long __base; \
__asm__( "movb %3,%%dh\n\t" \ // [addr+7]处基址高16 位的高(31-24)??dh
  "movb %2,%%dl\n\t" \ // [addr+4]处基址高16 位的低(23-16)??dl
  "shll $16,%%edx\n\t" \ // 基地址高16 位移到edx 中高16 位处。
  "movw %1,%%dx" \ // [addr+2]处基址低16 (15-0)??dx
:"=d" (__base) \ // 从而edx 中含有32 位的段基地址。
:"m" (*((addr) + 2)), "m" (*((addr) + 4)), "m" (*((addr) + 7)));
__base;
}
)
// 取局部描述符表中ldt 所指段描述符中的基地址。
#define get_base(ldt) _get_base( ((char *)&(ldt)) )
// 取段选择符segment 的段长值。
// %0 - 存放段长值(字节数)%1 - 段选择符segment
#define get_limit(segment) ({ \
unsigned long __limit; \
__asm__( "lsll %1,%0\n\tincl %0": "=r" (__limit): "r" (segment)); \
__limit;})

 

 

 

尽管内核模块不象应用程序一样顺序执行内核做的大部分动作是代表一个特定进程的内核代码可以引用当前进程通过存取全局项 current, 它在 <asm/current.h> 中定义它产生一个指针指向结构 task_struct, 在 <linux/sched.h> 定义. current 指针指向当前在运行的进程在一个系统调用执行期间例如 open 或者 read, 当前进程是发出调用的进程内核代码可以通过使用 current 来使用进程特定的信息如果它需要这样.

实际上, current 不真正地是一个全局变量支持 SMP 系统的需要强迫内核开发者去开发一种机制在相关的 CPU 上来找到当前进程这种机制也必须快速因为对 current 的引用非常频繁地发生结果就是一个依赖体系的机制常常隐藏了一个指向 task_struct 的指针在内核堆栈内实现的细节对别的内核子系统保持隐藏一个设备驱动可以只包含 <linux/sched.h> 并且引用当前进程例如下面的语句打印了当前进程的进程 ID 和命令名称通过存取结构 task_struct 中的某些字段.

printk(KERN_INFO "The process is \"%s\" (pid %i)\n", current->comm, current->pid);

存于 current->comm

的命令名称是由当前进程执行的程序文件的基本名称( 截短到 15 个字符, 如果需要 ).

 


task_struct在linux的定义如下:

struct task_struct {
    volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
    struct thread_info *thread_info;
    atomic_t usage;
    unsigned long flags;    /* per process flags, defined below */
    unsigned long ptrace;

    int lock_depth;     /* Lock depth */

    int prio, static_prio;
    struct list_head run_list;
    prio_array_t *array;

    unsigned long sleep_avg;
    long interactive_credit;
    unsigned long long timestamp;
    int activated;

    unsigned long policy;
    cpumask_t cpus_allowed;
    unsigned int time_slice, first_time_slice;

    struct list_head tasks;
    /*
    * ptrace_list/ptrace_children forms the list of my children
    * that were stolen by a ptracer.
    */
    struct list_head ptrace_children;
    struct list_head ptrace_list;

    struct mm_struct *mm, *active_mm;

/* task state */
    struct linux_binfmt *binfmt;
    int exit_code, exit_signal;
    int pdeath_signal; /* The signal sent when the parent dies */
    /* ??? */
    unsigned long personality;
    int did_exec:1;
    pid_t pid;
    pid_t tgid;
    /* 
    * pointers to (original) parent process, youngest child, younger sibling,
    * older sibling, respectively. (p->father can be replaced with 
    * p->parent->pid)
    */
    struct task_struct *real_parent; /* real parent process (when being debugged) */
    struct task_struct *parent; /* parent process */
    /*
    * children/sibling forms the list of my children plus the
    * tasks I'm ptracing.
    */
    struct list_head children; /* list of my children */
    struct list_head sibling;   /* linkage in my parent's children list */
    struct task_struct *group_leader;   /* threadgroup leader */

    /* PID/PID hash table linkage. */
    struct pid_link pids[PIDTYPE_MAX];

    wait_queue_head_t wait_chldexit;    /* for wait4() */
    struct completion *vfork_done;      /* for vfork() */
    int __user *set_child_tid;      /* CLONE_CHILD_SETTID */
    int __user *clear_child_tid;        /* CLONE_CHILD_CLEARTID */

    unsigned long rt_priority;
    unsigned long it_real_value, it_prof_value, it_virt_value;
    unsigned long it_real_incr, it_prof_incr, it_virt_incr;
    struct timer_list real_timer;
    unsigned long utime, stime, cutime, cstime;
    unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw; /* context switch counts */
    u64 start_time;
/* mm fault and swap info: this can arguably be seen as either mm-specific or thread-specific */
    unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
/* process credentials */
    uid_t uid,euid,suid,fsuid;
    gid_t gid,egid,sgid,fsgid;
    struct group_info *group_info;
    kernel_cap_t   cap_effective, cap_inheritable, cap_permitted;
    int keep_capabilities:1;
    struct user_struct *user;
/* limits */
    struct rlimit rlim[RLIM_NLIMITS];
    unsigned short used_math;
    char comm[16];
/* file system info */
    int link_count, total_link_count;
/* ipc stuff */
    struct sysv_sem sysvsem;
/* CPU-specific state of this task */
    struct thread_struct thread;
/* filesystem information */
    struct fs_struct *fs;
/* open file information */
    struct files_struct *files;
/* namespace */
    struct namespace *namespace;
/* signal handlers */
    struct signal_struct *signal;
    struct sighand_struct *sighand;

    sigset_t blocked, real_blocked;
    struct sigpending pending;

    unsigned long sas_ss_sp;
    size_t sas_ss_size;
    int (*notifier)(void *priv);
    void *notifier_data;
    sigset_t *notifier_mask;
    
    void *security;
    struct audit_context *audit_context;

/* Thread group tracking */
   u32 parent_exec_id;
   u32 self_exec_id;
/* Protection of (de-)allocation: mm, files, fs, tty */
    spinlock_t alloc_lock;
/* Protection of proc_dentry: nesting proc_lock, dcache_lock, write_lock_irq(&tasklist_lock); */
    spinlock_t proc_lock;
/* context-switch lock */
    spinlock_t switch_lock;

/* journalling filesystem info */
    void *journal_info;

/* VM state */
    struct reclaim_state *reclaim_state;

    struct dentry *proc_dentry;
    struct backing_dev_info *backing_dev_info;

    struct io_context *io_context;

    unsigned long ptrace_message;
    siginfo_t *last_siginfo; /* For ptrace use. */

#ifdef CONFIG_NUMA
struct mempolicy *mempolicy;
short il_next;      /* could be shared with used_math */
#endif
};

1. 调度数据成员(1) volatile long states;
表示进程的当前状态:
? TASK_RUNNING:正在运行或在就绪队列run-queue中准备运行的进程,实际参与进程调度。
? TASK_INTERRUPTIBLE:处于等待队列中的进程,待资源有效时唤醒,也可由其它进程通过信号(signal)或定时中断唤醒后进入就绪队列run-queue。
? TASK_UNINTERRUPTIBLE:处于等待队列中的进程,待资源有效时唤醒,不可由其它进程通过信号(signal)或定时中断唤醒。
? TASK_ZOMBIE:表示进程结束但尚未消亡的一种状态(僵死状态)。此时,进程已经结束运行且释放大部分资源,但尚未释放进程控制块。
?TASK_STOPPED:进程被暂停,通过其它进程的信号才能唤醒。导致这种状态的原因有二,或者是对收到SIGSTOP、SIGSTP、SIGTTIN或SIGTTOU信号的反应,或者是受其它进程的ptrace系统调用的控制而暂时将CPU交给控制进程。
? TASK_SWAPPING: 进程页面被交换出内存的进程。
(2) unsigned long flags;
进程标志:
?PF_ALIGNWARN 打印“对齐”警告信息。
?PF_PTRACED 被ptrace系统调用监控。
?PF_TRACESYS 正在跟踪。
?PF_FORKNOEXEC 进程刚创建,但还没执行。
?PF_SUPERPRIV 超级用户特权。
?PF_DUMPCORE dumped core。
?PF_SIGNALED 进程被信号(signal)杀出。
?PF_STARTING 进程正被创建。
?PF_EXITING 进程开始关闭。
?PF_USEDFPU 该进程使用FPU(SMP only)。
?PF_DTRACE delayed trace (used on m68k)。
(3) long priority;
进程优先级。 Priority的值给出进程每次获取CPU后可使用的时间(按jiffies计)。优先级可通过系统调用sys_setpriorty改变(在kernel/sys.c中)。
(4) unsigned long rt_priority;
rt_priority 给出实时进程的优先级,rt_priority+1000给出进程每次获取CPU后可使用的时间(同样按jiffies计)。实时进程的优先级可通过系统 调用sys_sched_setscheduler()改变(见kernel/sched.c)。
(5) long counter;
在 轮转法调度时表示进程当前还可运行多久。在进程开始运行是被赋为priority的值,以后每隔一个tick(时钟中断)递减1,减到0时引起新一轮调 度。重新调度将从run_queue队列选出counter值最大的就绪进程并给予CPU使用权,因此counter起到了进程的动态优先级的作用 (priority则是静态优先级)。
(6) unsigned long policy;
该进程的进程调度策略,可以通过系统调用sys_sched_setscheduler()更改(见kernel/sched.c)。调度策略有:
?SCHED_OTHER 0 非实时进程,基于优先权的轮转法(round robin)。
?SCHED_FIFO 1 实时进程,用先进先出算法。
?SCHED_RR 2 实时进程,用基于优先权的轮转法。
2. 信号处理
(1) unsigned long signal;
进程接收到的信号。每位表示一种信号,共32种。置位有效。
(2) unsigned long blocked;
进程所能接受信号的位掩码。置位表示屏蔽,复位表示不屏蔽。
(3) struct signal_struct *sig;
因 为signal和blocked都是32位的变量,Linux最多只能接受32种信号。对每种信号,各进程可以由PCB的sig属性选择使用自定义的处理 函数,或是系统的缺省处理函数。指派各种信息处理函数的结构定义在include/linux/sched.h中。对信号的检查安排在系统调用结束后,以 及“慢速型”中断服务程序结束后(IRQ#_interrupt(),参见9。5节“启动内核”)。
3. 进程队列指针
(1) struct task_struct *next_task,*prev_task;
所有进程(以PCB的形式)组成一个双向链表。next_task和就是链表的前后指针。链表的头和尾都是init_task(即0号进程)。
(2) struct task_struct *next_run,*prev_run;
由正在运行或是可以运行的,其进程状态均为TASK_RUNNING的进程所组成的一个双向循环链表,即run_queue就绪队列。该链表的前后向指针用next_run和prev_run,链表的头和尾都是init_task(即0号进程)。
(3) struct task_struct *p_opptr,*p_pptr;和struct task_struct *p_cptr,*p_ysptr,*p_osptr;
以上分别是指向原始父进程(original parent)、父进程(parent)、子进程(youngest child)及新老兄弟进程(younger sibling,older sibling)的指针。

4. 进程标识
(1) unsigned short uid,gid;
uid和gid是运行进程的用户标识和用户组标识。
(2) int groups[NGROUPS];
与多数现代UNIX操作系统一样,Linux允许进程同时拥有一组用户组号。在进程访问文件时,这些组号可用于合法性检查。
(3) unsigned short euid,egid;
euid 和egid又称为有效的uid和gid。出于系统安全的权限的考虑,运行程序时要检查euid和egid的合法性。通常,uid等于euid,gid等于 egid。有时候,系统会赋予一般用户暂时拥有root的uid和gid(作为用户进程的euid和egid),以便于进行运作。
(4) unsigned short fsuid,fsgid;
fsuid 和fsgid称为文件系统的uid和gid,用于文件系统操作时的合法性检查,是Linux独特的标识类型。它们一般分别和euid和egid一致,但在 NFS文件系统中NFS服务器需要作为一个特殊的进程访问文件,这时只修改客户进程的fsuid和fsgid。
(5) unsigned short suid,sgid;
suid和sgid是根据POSIX标准引入的,在系统调用改变uid和gid时,用于保留真正的uid和gid。
(6) int pid,pgrp,session;
进程标识号、进程的组织号及session标识号,相关系统调用(见程序kernel/sys.c)有sys_setpgid、sys_getpgid、sys_setpgrp、sys_getpgrp、sys_getsid及sys_setsid几种。
(7) int leader;
是否是session的主管,布尔量。
5. 时间数据成员
(1) unsigned long timeout;
用于软件定时,指出进程间隔多久被重新唤醒。采用tick为单位。
(2) unsigned long it_real_value,it_real_iner;
用 于itimer(interval timer)软件定时。采用jiffies为单位,每个tick使it_real_value减到0时向进程发信号SIGALRM,并重新置初值。初值由 it_real_incr保存。具体代码见kernel/itimer.c中的函数it_real_fn()。
(3) struct timer_list real_timer;
一种定时器结构(Linux共有两种定时器结构,另一种称作old_timer)。数据结构的定义在include/linux/timer.h中,相关操作函数见kernel/sched.c中add_timer()和del_timer()等。
(4) unsigned long it_virt_value,it_virt_incr;
关 于进程用户态执行时间的itimer软件定时。采用jiffies为单位。进程在用户态运行时,每个tick使it_virt_value减1,减到0时 向进程发信号SIGVTALRM,并重新置初值。初值由it_virt_incr保存。具体代码见kernel/sched.c中的函数 do_it_virt()。
(5) unsigned long it_prof_value,it_prof_incr;
同样是 itimer软件定时。采用jiffies为单位。不管进程在用户态或内核态运行,每个tick使it_prof_value减1,减到0时向进程发信号 SIGPROF,并重新置初值。初值由it_prof_incr保存。 具体代码见kernel/sched.c中的函数do_it_prof。
(6) long utime,stime,cutime,cstime,start_time;
以上分别为进程在用户态的运行时间、进程在内核态的运行时间、所有层次子进程在用户态的运行时间总和、所有层次子进程在核心态的运行时间总和,以及创建该进程的时间。
6. 信号量数据成员
(1) struct sem_undo *semundo;
进 程每操作一次信号量,都生成一个对此次操作的undo操作,它由sem_undo结构描述。这些属于同一进程的undo操作组成的链表就由semundo 属性指示。当进程异常终止时,系统会调用undo操作。sem_undo的成员semadj指向一个数据数组,表示各次undo的量。结构定义在 include/linux/sem.h。
(2) struct sem_queue *semsleeping;
每一信号量集合对应一 个sem_queue等待队列(见include/linux/sem.h)。进程因操作该信号量集合而阻塞时,它被挂到semsleeping指示的关 于该信号量集合的sem_queue队列。反过来,semsleeping。sleeper指向该进程的PCB。
7. 进程上下文环境
(1) struct desc_struct *ldt;
进程关于CPU段式存储管理的局部描述符表的指针,用于仿真WINE Windows的程序。其他情况下取值NULL,进程的ldt就是arch/i386/traps.c定义的default_ldt。
(2) struct thread_struct tss;
任务状态段,其内容与INTEL CPU的TSS对应,如各种通用寄存器.CPU调度时,当前运行进程的TSS保存到PCB的tss,新选中进程的tss内容复制到CPU的TSS。结构定义在include/linux/tasks.h中。
(3) unsigned long saved_kernel_stack;
为MS-DOS的仿真程序(或叫系统调用vm86)保存的堆栈指针。
(4) unsigned long kernel_stack_page;
在内核态运行时,每个进程都有一个内核堆栈,其基地址就保存在kernel_stack_page中。
8. 文件系统数据成员
(1) struct fs_struct *fs;
fs 保存了进程本身与VFS的关系消息,其中root指向根目录结点,pwd指向当前目录结点,umask给出新建文件的访问模式(可由系统调用umask更 改),count是Linux保留的属性,如下页图所示。结构定义在include/linux/sched.h中。
(2) struct files_struct *files;
files包含了进程当前所打开的文件(struct file *fd[NR_OPEN])。在Linux中,一个进程最多只能同时打开NR_OPEN个文件。而且,前三项分别预先设置为标准输入、标准输出和出错消息输出文件。 
(3) int link_count;
文件链(link)的数目。
9. 内存数据成员
(1) struct mm_struct *mm;
在linux 中,采用按需分页的策略解决进程的内存需求。task_struct的数据成员mm指向关于存储管理的mm_struct结构。其中包含了一个虚存队列 mmap,指向由若干vm_area_struct描述的虚存块。同时,为了加快访问速度,mm中的mmap_avl维护了一个AVL树。在树中,所有的 vm_area_struct虚存块均由左指针指向相邻的低虚存块,右指针指向相邻的高虚存块。 结构定义在include/linux/sched.h中。
10. 页面管理
(1) int swappable:1;
进程占用的内存页面是否可换出。swappable为1表示可换出。对该标志的复位和置位均在do_fork()函数中执行(见kerenl/fork.c)。
(2) unsigned long swap_address;
虚存地址比swap_address低的进程页面,以前已经换出或已换出过,进程下一次可换出的页面自swap_address开始。参见swap_out_process()和swap_out_pmd()(见mm/vmscan.c)。
(3) unsigned long min_flt,maj_flt;
该 进程累计的minor缺页次数和major缺页次数。maj_flt基本与min_flt相同,但计数的范围比后者广(参见fs/buffer.c和 mm/page_alloc.c)。min_flt只在do_no_page()、do_wp_page()里(见mm/memory.c)计数新增的可 以写操作的页面。
(4) unsigned long nswap;
该进程累计换出的页面数。
(5) unsigned long cmin_flt,cmaj_flt,cnswap;
以本进程作为祖先的所有层次子进程的累计换入页面、换出页面计数。
(6) unsigned long old_maj_flt,dec_flt;
(7) unsigned long swap_cnt;
下一次信号最多可换出的页数。
11. 支持对称多处理器方式(SMP)时的数据成员
(1) int processor;
进程正在使用的CPU。
(2) int last_processor;
进程最后一次使用的CPU。
(3) int lock_depth;
上下文切换时系统内核锁的深度。
12. 其它数据成员
(1) unsigned short used_math;
是否使用FPU。
(2) char comm[16];
进程正在运行的可执行文件的文件名。
(3) struct rlimit rlim[RLIM_NLIMITS];
结 构rlimit用于资源管理,定义在linux/include/linux/resource.h中,成员共有两项:rlim_cur是资源的当前最大 数目;rlim_max是资源可有的最大数目。在i386环境中,受控资源共有RLIM_NLIMITS项,即10项,定义在 linux/include/asm/resource.h中,见下表:
(4) int errno;
最后一次出错的系统调用的错误号,0表示无错误。系统调用返回时,全程量也拥有该错误号。
(5) long debugreg[8];
保存INTEL CPU调试寄存器的值,在ptrace系统调用中使用。
(6) struct exec_domain *exec_domain;
Linux可以运行由80386平台其它UNIX操作系统生成的符合iBCS2标准的程序。关于此类程序与Linux程序差异的消息就由exec_domain结构保存。
(7) unsigned long personality;
Linux 可以运行由80386平台其它UNIX操作系统生成的符合iBCS2标准的程序。 Personality进一步描述进程执行的程序属于何种UNIX平台的“个性”信息。通常有PER_Linux、PER_Linux_32BIT、 PER_Linux_EM86、PER_SVR3、PER_SCOSVR3、PER_WYSEV386、PER_ISCR4、PER_BSD、 PER_XENIX和PER_MASK等,参见include/linux/personality.h。
(8) struct linux_binfmt *binfmt;
指向进程所属的全局执行文件格式结构,共有a。out、script、elf和java等四种。结构定义在include/linux/binfmts.h中(core_dump、load_shlib(fd)、load_binary、use_count)。
(9) int exit_code,exit_signal;
引起进程退出的返回代码exit_code,引起错误的信号名exit_signal。
(10) int dumpable:1;
布尔量,表示出错时是否可以进行memory dump。
(11) int did_exec:1;
按POSIX要求设计的布尔量,区分进程是正在执行老程序代码,还是在执行execve装入的新代码。
(12) int tty_old_pgrp;
进程显示终端所在的组标识。
(13) struct tty_struct *tty;
指向进程所在的显示终端的信息。如果进程不需要显示终端,如0号进程,则该指针为空。结构定义在include/linux/tty.h中。
(14) struct wait_queue *wait_chldexit;
在进程结束时,或发出系统调用wait4后,为了等待子进程的结束,而将自己(父进程)睡眠在该队列上。结构定义在include/linux/wait.h中。
13. 进程队列的全局变量
(1) current;
当前正在运行的进程的指针,在SMP中则指向CPU组中正被调度的CPU的当前进程:
#define current(0+current_set[smp_processor_id()])/*sched.h*/
struct task_struct *current_set[NR_CPUS];
(2) struct task_struct init_task;
即0号进程的PCB,是进程的“根”,始终保持初值INIT_TASK。
(3) struct task_struct *task[NR_TASKS];
进 程队列数组,规定系统可同时运行的最大进程数(见kernel/sched.c)。NR_TASKS定义在include/linux/tasks.h 中,值为512。每个进程占一个数组元素(元素的下标不一定就是进程的pid),task[0]必须指向init_task(0号进程)。可以通过 task[]数组遍历所有进程的PCB。但Linux也提供一个宏定义for_each_task()(见 include/linux/sched.h),它通过next_task遍历所有进程的PCB:
#define for_each_task(p) \
for(p=&init_task;(p=p->next_task)!=&init_task;)
(4) unsigned long volatile jiffies;
Linux的基准时间(见kernal/sched.c)。系统初始化时清0,以后每隔10ms由时钟中断服务程序do_timer()增1。
(5) int need_resched;
重新调度标志位(见kernal/sched.c)。当需要Linux调度时置位。在系统调用返回前(或者其它情形下),判断该标志是否置位。置位的话,马上调用schedule进行CPU调度。
(6) unsigned long intr_count;
记 录中断服务程序的嵌套层数(见kernal/softirq.c)。正常运行时,intr_count为0。当处理硬件中断、执行任务队列中的任务或者执 行bottom half队列中的任务时,intr_count非0。这时,内核禁止某些操作,例如不允许重新调度。

 

 

 

 

 


评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值