linux 0.11 内核学习 -- sched.c，调度进程。
/*
* 2010-1-21
* 该文件时内核中有关任务调度的函数程序，其中包含基本函数sleep_on，
* wakeup，schedule等，以及一些简单的系统调用。同时将软盘的几个操作
* 函数也放置在这里。
*
* schedule函数首先对所有的任务检查，唤醒任何一个已经得到信号的任务，
* 具体的方法是针对任务数组中的每个任务，检查其警报定时值alarm。如果任务
* 的alarm已经超期（alarm < jiffies），则在它的信号位图中设置SIGALARM，然后
* 情书alarm值。jiffies是系统自从开机之后算起的滴答数。在scheed.h中定义，
* 如果进程信号的位图中除去被阻塞的信号之外还有其他信号，并且任务处于可
* 中断睡眠状态，则置任务为就绪状态。
* 随后是调度函数的核心处理，这部分代码根据进程时间片和优先权的调度机制，
* 来选择将要执行的程序。他首先是循环检查任务数组中的所有任务。根据每个就绪
* 任务剩余执行时间值counter中选取一个最大的，利用switch_to函数完成任务
* 转换。如果所有的就绪任务的该值都是0，则表示此刻所有任务的时间片都已运行完。
* 于是就根据任务的优先权值priority，重置每个任务的运行时间counter。在重新
* 循环检查所有的任务重的执行的时间片值。
* 另一个值得一说的是sleep_on函数，该函数虽短，却要比schedule函数难理解，
* 简单的讲，sleep_on函数主要的功能是当一个进程所请求的资源正在忙，或者是
* 不在内存中被切换出去，放在等待队列中等待一段时间。切换回来后在继续执行。
* 放入等待队列的方式是，利用了函数中的tmp指针为各个正在等待任务的联系。
* 还有一个函数interrupt_sleep_on，该函数的主要功能是在进程调度之前，把当前
* 任务设置为可中断等待状态，并在本任务被唤醒之后还需要查看队列上是否还有
* 后来的等待任务，如果有，先调度他们。
*
*/
/*
* linux/kernel/sched.c
*
* (C) 1991 Linus Torvalds
*/
/*
* 'sched.c' is the main kernel file. It contains scheduling primitives
* (sleep_on, wakeup, schedule etc) as well as a number of simple system
* call functions (type getpid(), which just extracts a field from
* current-task
*/
#include <linux/sched.h>
#include <linux/kernel.h>
#include <linux/sys.h>
#include <linux/fdreg.h> // 软驱头文件
#include <asm/system.h>
#include <asm/io.h>
#include <asm/segment.h> // 端操作头文件，定义端操作的汇编函数
#include <signal.h>
#define _S(nr) (1<<((nr)-1)) // 取nr（1-32）对应的位的二进制数值，取出的
// 并不是一位
// 定义除了SIGKILL和SIGSTOP之外，其他信号位全是阻塞的
#define _BLOCKABLE (~(_S(SIGKILL) | _S(SIGSTOP)))
//----------------------------------------------------------------------
// show_task
// 显示任务号nr，pid，进程状态和内核堆栈空闲字节
void show_task(int nr,struct task_struct * p)
{
int i,j = 4096-sizeof(struct task_struct);
printk("%d: pid=%d, state=%d, ",nr,p->pid,p->state);
i=0;
while (i<j && !((char *)(p+1))[i])
i++;
printk("%d (of %d) chars free in kernel stack/n/r",i,j);
}
//---------------------------------------------------------------------
// show_stat
// 显示所有任务的信息
void show_stat(void)
{
int i;
for (i=0;i<NR_TASKS;i++)
if (task[i]) // task是一个指针数组，如果存在”任务“
show_task(i,task[i]);
}
#define LATCH (1193180/HZ) // 每个时间片滴答数
extern void mem_use(void);
extern int timer_interrupt(void); // 时钟中断处理程序
extern int system_call(void); // 系统调用处理程序
union task_union
{
// 定义任务联合(任务结构成员和stack 字符数组程序成员),联合体是共享内存的
struct task_struct task; // 因为一个任务数据结构与其堆栈放在同一内存页中，所以
char stack[PAGE_SIZE]; // 从堆栈段寄存器ss 可以获得其数据段选择符
};
static union task_union init_task = {INIT_TASK,}; // 定义初始任务数据
long volatile jiffies=0; // 定义开机以来时钟滴答数
long startup_time=0; // 开机时间
struct task_struct *current = &(init_task.task); // 当前任务指针
struct task_struct *last_task_used_math = NULL; // 使用过协处理器的任务指针
struct task_struct * task[NR_TASKS] = {&(init_task.task), }; // 定义任务数组
long user_stack [ PAGE_SIZE>>2 ] ; // 定义系统堆栈指针
struct { // 该结果用于设置堆栈ss：esp
long * a;
short b;
} stack_start = { & user_stack [PAGE_SIZE>>2] , 0x10 };
//---------------------------------------------------------------------
// math_state_restore
/*
* 'math_state_restore()' saves the current math information in the
* old math state array, and gets the new ones from the current task
*/
/*
* 将当前协处理器内容保存在原来协处理器数组中，并将当前任务的协处理器
* 内容加载到协处理器
*
*/
// 当任务被调度交换之后，该函数用以保存员任务的协处理器的状态，并回复
// 新调度进来的当前协处理器的执行状态
void math_state_restore()
{
if (last_task_used_math == current) // 如果任务没有改变返回
return;
__asm__("fwait"); // 在发送协处理器指令之前首先发出wait指令
if (last_task_used_math) // 如果上个使用协处理器的进程存在
{
// 保存状态
__asm__("fnsave %0"::"m" (last_task_used_math->tss.i387));
}
last_task_used_math=current; // 现在last_task_used_math指向当前任务
if (current->used_math) // 如果当前的任务使用过协处理器
{
__asm__("frstor %0"::"m" (current->tss.i387));// 恢复状态
} else // 没有使用过协处理器
{
__asm__("fninit"::); // 初始化协处理器
current->used_math=1; // 设置使用协处理器标志
}
}
//--------------------------------------------------------------------
// schedule
/*
* 'schedule()' is the scheduler function. This is GOOD CODE! There
* probably won't be any reason to change this, as it should work well
* in all circumstances (ie gives IO-bound processes good response etc).
* The one thing you might take a look at is the signal-handler code here.
*
* NOTE!! Task 0 is the 'idle' task, which gets called when no other
* tasks can run. It can not be killed, and it cannot sleep. The 'state'
* information in task[0] is never used.
*/
void schedule(void)
{
int i,next,c;
struct task_struct ** p;
/* check alarm, wake up any interruptible tasks that have got a signal */
/* 检查alarm，唤醒任何已得到信号的可中断任务 */
// 从任务数组最后开始检查alarm
for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
if (*p) // 任务存在？
{
if ((*p)->alarm && (*p)->alarm < jiffies)
/*
* 下面是对(*p)->alarm < jiffies理解：
* 如果不调用alarm()函数，alarm的值就是0，但是调用了alarm函数
* 之后，比如说alarm(5),就是5秒后报警
*/
{
// 在位图信号中置位AIGALARM
(*p)->signal |= (1<<(SIGALRM-1));
// 将alarm值置位0
(*p)->alarm = 0;
}
// 如果信号位图中除被阻塞的信号外还有其他信号，即是该
// 进程申请的自愿被别的进程释放，或者是其他条件导致该
// 进程能够被执行，并且该任务处于的是可中断编程。linux
// 内核进程转换见文档<进程运行状态图.txt>。此时将该进程
// 进程状态置位就绪。
if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
(*p)->state==TASK_INTERRUPTIBLE)
(*p)->state=TASK_RUNNING;
}
/* this is the scheduler proper: */
/* 这是调度的主要部分 */
while (1) // 循环，直到存在counter的值大于0
{
c = -1;
next = 0;
i = NR_TASKS;
p = &task[NR_TASKS];
////////////////////////////////////////////////
// 下面的代码是寻找最大counter值的进程。counter
// 值的含义见文档 <linux0.11task_struct中counter解释.txt>
while (--i) {
if (!*--p)
continue;
if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
c = (*p)->counter, next = i;
}
////////////////////////////////////////////////
if (c) break; // 如果进程存在。退出，去执行switch_to
// 否则更新counter值
for(p = &LAST_TASK ; p > &FIRST_TASK ; --p)
if (*p)
(*p)->counter = ((*p)->counter >> 1) +
(*p)->priority;
}
switch_to(next);
}
//--------------------------------------------------------------------
// sys_pause
// 将当前任务设置为可中断，执行调度函数
int sys_pause(void)
{
current->state = TASK_INTERRUPTIBLE;
schedule();
return 0;
}
//-------------------------------------------------------------------
// sleep_on
// struct task_struct **p是等待队列头指针
// 该函数就是首先将当前任务设置为TASK_UNINTERRUPTIBLE，并让睡眠队列
// 头指针指向当前任务，执行调度函数，直到有明确的唤醒时，该任务才重新
// 开始执行。
void sleep_on(struct task_struct **p)
{
struct task_struct *tmp;
if (!p) // 无效指针
return;
if (current == &(init_task.task)) // 当前任务是0，死机
panic("task[0] trying to sleep");
tmp = *p;
*p = current;
current->state = TASK_UNINTERRUPTIBLE; // 设置状态
schedule(); // 执行调度，直到明确的唤醒
// 肯能存在多个任务此时被唤醒，那么如果还存在等待任务
// if (tmp),则将状态设置为”就绪“
if (tmp)
tmp->state=0;
}
//--------------------------------------------------------------------------
// interruptible_sleep_on
// struct task_struct **p是等待队列对头
void interruptible_sleep_on(struct task_struct **p)
{
/*
* 首先需要明确的是TASK_INTERRUPTIBLE。它是指当进
* 程处于可中断等待状态时，系统不会调度该进行执行。
*/
struct task_struct *tmp;
if (!p)
return;
if (current == &(init_task.task))
panic("task[0] trying to sleep");
tmp=*p;
*p=current; // 保存该任务指针
repeat: current->state = TASK_INTERRUPTIBLE;
schedule();
if (*p && *p != current)
{
/*
* *p != current表示当前任务不是原来保存的任务，即是
* 有新的任务插入到等待队列中了。由于本任务是不可中断的
*，所以首先执行其他的任务
*/
(**p).state=0;
goto repeat;
}
/*
* 下面的代码错误，应该是*p = tmp，让队列头指针指向队列中其他任务
*/
*p=NULL;
// 原因同上。sleep_on
if (tmp)
tmp->state=0;
}
//----------------------------------------------------------------
// wake_up
// 唤醒任务p
void wake_up(struct task_struct **p)
{
if (p && *p)
{
(**p).state=0; // 置状态为可运行
*p=NULL;
}
}
/*
* OK, here are some floppy things that shouldn't be in the kernel
* proper. They are here because the floppy needs a timer, and this
* was the easiest way of doing it.
*/
/*
* 由于软盘需要时钟，所以就将软盘的程序放到这里了
*/
// 利用下面的数组来存储的是马达运转或者是停止的滴答数，下列的
// 数组在函数do_floppy_timer中更新
static struct task_struct * wait_motor[4] = {NULL,NULL,NULL,NULL};
static int mon_timer[4]={0,0,0,0}; // 软驱到正常运转还需要的时间
static int moff_timer[4]={0,0,0,0}; // 马达到停止运转还剩下的时刻
unsigned char current_DOR = 0x0C; // 数字输出寄存器（初值：允许dma和中断请求，启动fdc）
// oxoc -- 0000,1100
//----------------------------------------------------------------
// ticks_to_floppy_on
// 指定软盘到正常运转所需的滴答数
// nr -- 软盘驱动号，该函数返回的是滴答数
int ticks_to_floppy_on(unsigned int nr)
{
extern unsigned char selected; // 当前选中软盘号
// ox10 -- 0001, 0000
unsigned char mask = 0x10 << nr; // 所选软盘对应的数字输出
// 寄存器启动马达比特位
/*
* 数字输出端口（数字控制端口）是一个8位寄存器，它控制驱动器马达开启
* ，驱动器选择，启动和复位FDC，以及允许和禁止DMA及中断请求。
* FDC的主状态寄存器也是一个8位寄存器，用户反映软盘控制器FDC和软盘
* 驱动器FDD的基本状态。通常，在CPU想FDC发送命令之前或者是从FDC获得
* 操作结果之前，都要读取主状态寄存器的状态位，以判定当前的数据是否
* 准备就绪，以及确定数据的传输方向
*
*/
if (nr>3) // 最多3个软盘驱动号
panic("floppy_on: nr>3");
moff_timer[nr]=10000; /* 100 s = very big :-) */
cli(); /* use floppy_off to turn it off 关中断 */
mask |= current_DOR; // mask =
// 如果不是当前软驱，则首先复位其它软驱的选择位，然后置对应软驱选择位
if (!selected)
{
mask &= 0xFC; // 0xfc -- 1111,1100
mask |= nr;
}
if (mask != current_DOR) // 如果数字输出寄存器的当前值和要求不同
// 即是需要的状态还没有到达
{
outb(mask,FD_DOR); // 于是向FDC数字输出端口输出新值
if ((mask ^ current_DOR) & 0xf0) // 如果需要启动的马达还没有
// 启动，则置相应的软驱马达定
// 时器值（50个滴答数）
mon_timer[nr] = HZ/2;
else if (mon_timer[nr] < 2)
mon_timer[nr] = 2;
current_DOR = mask; // 更新数字输出寄存器的值current_DOR，即是反映
// 当前的状态
}
sti(); // 开中断
return mon_timer[nr];
}
//--------------------------------------------------------------
// floppy_on
// 等待指定软驱马达启动所需时间，启动时间
void floppy_on(unsigned int nr)
{
cli(); // 关中断
while (ticks_to_floppy_on(nr))// 还没有到时间？
sleep_on(nr+wait_motor); // 为不可中断睡眠状态并放在
// 等待马达运行队列中
sti(); // 开中断
}
//---------------------------------------------------------------
// floppy_off
// 初始化数组moff_timer，即是表示置相应软驱马达停转定时器（3秒）
void floppy_off(unsigned int nr)
{
moff_timer[nr]=3*HZ;
}
//----------------------------------------------------------------
// do_floppy_timer
// 软盘定时处理子程序。更新马达启动定时值和马达关闭停转计时值。该子程序
// 是在时钟定时中断被调用，因此每一个滴答（10ms）被嗲用一次，更新马达开启
// 或者是停止转动定时器值。如果在某一个马达停转时刻到达，那么则将数字输出
// 寄存器马达启动复位标志
void do_floppy_timer(void)
{
int i;
unsigned char mask = 0x10;
for (i=0 ; i<4 ; i++,mask <<= 1) {
if (!(mask & current_DOR)) // 如果不是指定马达
continue;
if (mon_timer[i])
{
if (!--mon_timer[i])// 如果马达启动定时器到达
wake_up(i+wait_motor);//则唤醒进程
} else if (!moff_timer[i]) { // 如果马达停止运转时刻到达
current_DOR &= ~mask; // 复位相应马达启动位
outb(current_DOR,FD_DOR); // 更新数字输出寄存器
} else
moff_timer[i]--; // 马达停转计时器递减
}
}
#define TIME_REQUESTS 64
static struct timer_list {
long jiffies; // 定时滴答数
void (*fn)(); // 定时处理函数
struct timer_list * next;
} timer_list[TIME_REQUESTS], * next_timer = NULL;
//----------------------------------------------------------------------
// add_timer
// 增加定时器。输入参数为指定的定时器的滴答数和相应的处理函数指针。
// jiffies -- 以10ms计时的滴答数
// *fn() -- 定时时间到达时执行函数
void add_timer(long jiffies, void (*fn)(void))
{
struct timer_list * p;
if (!fn) // 如果处理函数为空
return; // 退出
cli(); // 关中断
if (jiffies <= 0) // 定时器到达
(fn)(); // 执行函数fn
else { // 否则，从定时器数组中，找到一个空闲项，使用fn来标识
for (p = timer_list ; p < timer_list + TIME_REQUESTS ; p++)
if (!p->fn)
break;
// 当上面的循环结束时，可能存在p == timer_list + TIME_REQUESTS
if (p >= timer_list + TIME_REQUESTS) // 这样的话，表明用完了数组
panic("No more time requests free");
// 将定时器数据结构填入相应信息
p->fn = fn;
p->jiffies = jiffies;
p->next = next_timer;
next_timer = p;
// 链表项按定时器值的大小排序。下面就是链表排序的实现。这样的好处是
// 在查看是否有定时器到期时，只需要查看链表的头结点即可
while (p->next && p->next->jiffies < p->jiffies) {
p->jiffies -= p->next->jiffies;
fn = p->fn;
p->fn = p->next->fn;
p->next->fn = fn;
jiffies = p->jiffies;
p->jiffies = p->next->jiffies;
p->next->jiffies = jiffies;
p = p->next;
}
}
sti(); // 开中断
}
//------------------------------------------------------------------------
// do_timer
// 时钟中断处理函数，在/kernel/system_call.s中_timer_interrupt_中被调用
// 参数cpl是当前的特权级0或3，0标识在内核代码段运行
// 对于一个进程由于时间片用完，则进行内核任务切换。并进行及时更新工作
void do_timer(long cpl)
{
extern int beepcount; // 扬声器发声时间滴答数
extern void sysbeepstop(void); // 关闭扬声器
if (beepcount)
if (!--beepcount) // 如果扬声器计数次数到
sysbeepstop(); // 关闭发生器
if (cpl) // 如果实在内核程序，即是超级用户
current->utime++; // 超级用户时间增加
else
current->stime++; // 普通用户运行时间增加
// 如果有用户定时器存在的话，则将第一个定时器的值减去1，如果已经等于0
// 那么调用函数fn，并将函数指针置为空值，然后去掉该定时器。注意的是上述
// 链表已经排序，同时在寻找空闲结点时，是通过fn是否为空来判断的，所以
// 将fn置位null
if (next_timer)
{
next_timer->jiffies--;
while (next_timer && next_timer->jiffies <= 0) {
void (*fn)(void); //
// 删除定时器
fn = next_timer->fn;
next_timer->fn = NULL;
next_timer = next_timer->next;
(fn)();
}
}
// 如果当前软盘控制器FDC的数字输出寄存器马达启动位有置位，则执行相应的
// 软盘定时程序
if (current_DOR & 0xf0)
do_floppy_timer();
if ((--current->counter)>0) return; // 如果进程运行时间还没有完，退出
current->counter=0;
if (!cpl) return; // 超级用户程序，不依赖counter值来调度
schedule();
}
//----------------------------------------------------------------------
// sys_alarm
// 如果已经设置了alarm的值，那么返回的是旧值，如果没有设置返回0
int sys_alarm(long seconds)
{
int old = current->alarm;
if (old)
old = (old - jiffies) / HZ;
current->alarm = (seconds>0)?(jiffies+HZ*seconds):0;
return (old);
}
//-----------------------------------------------------------------------
// sys_getpid
// 取得当前的进程号
int sys_getpid(void)
{
return current->pid;
}
//----------------------------------------------------------------------
// sys_getppid
// 取得父进程进程号
int sys_getppid(void)
{
return current->father;
}
//-----------------------------------------------------------------------
// sys_getuid
// 取得用户号uid
int sys_getuid(void)
{
return current->uid;
}
//------------------------------------------------------------------------
// sys_geteuid
// 取得用户号euid
int sys_geteuid(void)
{
return current->euid;
}
//----------------------------------------------------------------------
// sys_getgid
// 取得组号gid
int sys_getgid(void)
{
return current->gid;
}
//----------------------------------------------------------------------
// sys_getegid
// 取得进程的egid，有关egid的解释，参见文档<Linux 关于SUID和SGID的解释.txt>
int sys_getegid(void)
{
return current->egid;
}
//--------------------------------------------------------------------
// sys_nice
// 改变进程优先级
int sys_nice(long increment)
{
if (current->priority-increment>0)
current->priority -= increment;
return 0;
}
//----------------------------------------------------------------------
// sched_init
// 调度程序初始化，即是初始化进程0，init
void sched_init(void)
{
int i;
struct desc_struct * p;
if (sizeof(struct sigaction) != 16) // sigaction中存放的是信号状态结构
panic("Struct sigaction MUST be 16 bytes");
// 设置初始任务（任务0）的任务状态描述符表和局部数据描述符表
set_tss_desc(gdt+FIRST_TSS_ENTRY,&(init_task.task.tss));
set_ldt_desc(gdt+FIRST_LDT_ENTRY,&(init_task.task.ldt));
// 清楚任务数组和描述符表项
p = gdt+2+FIRST_TSS_ENTRY;
for(i=1;i<NR_TASKS;i++) {
task[i] = NULL;
p->a=p->b=0;
p++;
p->a=p->b=0;
p++;
}
/* Clear NT, so that we won't have troubles with that later on */
/* nt标志置位的话，那么当前的中断任务执行iret命令时引起任务的切换 */
__asm__("pushfl ; andl $0xffffbfff,(%esp) ; popfl");
ltr(0); // 将任务0的tss加载到寄存器
lldt(0); // 将局部描述符表加载到局部描述符表寄存器
// 是将gdt和相应的ldt描述符的选择符加载到ldtr。只是明确的加载这一次
// 以后任务的ldt加载，是cpu根据tss中的ldt自动加载的
// 初始化8253定时器
outb_p(0x36,0x43); /* binary, mode 3, LSB/MSB, ch 0 */
outb_p(LATCH & 0xff , 0x40); /* LSB */
outb(LATCH >> 8 , 0x40); /* MSB */
// 设置时钟中断控制处理程序句柄
set_intr_gate(0x20,&timer_interrupt);
// 修改中断控制器屏蔽码，允许时钟中断
outb(inb_p(0x21)&~0x01,0x21);
// 设置系统调用中断门
set_system_gate(0x80,&system_call);
}
/*
* 下面解释linux的init进程的整体认识
* 1.在系统的启动阶段时，bootsect.s文件只是见将系统加载到内存中，内核都
* 没有加载完成，谈不上对于进程管理的影响。setup.s中加载了全局的gdtr，
* 但是此时的gdt只是为了让程序运行在保护模式下，没有什么作用。在setup.s
* 文件中设置的gdt的格式如下 ：
* -----------
* | 0 0 0 0 |
* -----------
* | code seg|
* ------------
* | data seg|
* -----------
* | ...... |
* 在head.s文件中还需要改写该gdt。经过该文件的修改后新生成的gdt如下：
* -----------
* | 0 0 0 0 |
* -----------
* | code |
* -----------
* | data |
* -----------
* | system | -- do not use in linux
* -----------
* | | -|
* ----------- |--剩下的各项是预留给其他任务，用于放置ldt和tss
* | | -|
*
* 在main.c文件中调用函数sched_init，此函数加载进程init。
* 加载init进程的ldt和tdd段
* |
* 由程序来执行加载ldt和tss段寄存器的任务
* |
* 即实现init进程的加载，即是手工创建的第一次进程。
* 此时的gdt大概上讲是：
* ----------
* | 0 0 0 0 |
* -----------
* | code |
* -----------
* | data |
* -----------
* | system |
* -----------
* | ldt0 |
* -----------
* | tss0 |
* -----------
* | ... |
* 此后，进程使用fork系统调用来产生新的进程，同时进程调度开始起作用。
*
*/
参考《linux内核完全注释》和网上相关文章