Linux0.11内核--进程调度分析之2.调度

【版权所有，转载请注明出处。出处：http://www.cnblogs.com/joey-hua/p/5596830.html 】

上一篇说到进程调度归根结底是调用timer_interrupt函数，在system_call.s中：

#### int32 -- (int 0x20) 时钟中断处理程序。中断频率被设置为100Hz(include/linux/sched.h,5)，
# 定时芯片8253/8254 是在(kernel/sched.c,406)处初始化的。因此这里jiffies 每10 毫秒加1。
# 这段代码将jiffies 增1，发送结束中断指令给8259 控制器，然后用当前特权级作为参数调用
# C 函数do_timer(long CPL)。当调用返回时转去检测并处理信号。
.align 2
_timer_interrupt:
push %ds 								# save ds,es and put kernel data space
push %es 								# into them. %fs is used by _system_call
push %fs
pushl %edx 							# we save %eax,%ecx,%edx as gcc doesn't
pushl %ecx 							# save those across function calls. %ebx
pushl %ebx 							# is saved as we use that in ret_sys_call
pushl %eax
movl $0x10,%eax 				# ds,es 置为指向内核数据段。
mov %ax,%ds
mov %ax,%es
movl $0x17,%eax 				# fs 置为指向局部数据段（出错程序的数据段）。
mov %ax,%fs
incl _jiffies
# 由于初始化中断控制芯片时没有采用自动EOI，所以这里需要发指令结束该硬件中断。
movb $0x20,%al 				# EOI to interrupt controller #1
outb %al,$0x20 					# 操作命令字OCW2 送0x20 端口。
# 下面3 句从选择符中取出当前特权级别(0 或3)并压入堆栈，作为do_timer 的参数。
movl CS(%esp),%eax
andl $3,%eax 						# %eax is CPL (0 or 3, 0=supervisor)
pushl %eax
# do_timer(CPL)执行任务切换、计时等工作，在kernel/shched.c,305 行实现。
call _do_timer 						# 'do_timer(long CPL)' does everything from
addl $4,%esp 						# task switching to accounting ...
jmp ret_from_sys_call

前面一堆push指令保存当前的寄存器，然后在ret_from_sys_call中弹出。

movl $0x10,%eax把段选择子0x10也就是内核数据段选择子赋值给eax，然后再赋给ds、es；

然后_jiffies加1，jiffies在sched.h中定义：

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

接下来三句指令比较关键：

movl CS(%esp),%eax
andl $3,%eax 						# %eax is CPL (0 or 3, 0=supervisor)
pushl %eax

从上面push的寄存器当中取出cs寄存器的值，也就是代码段选择子，根据选择的结构，0-1位是特权级，andl $3,%eax就是取eax中0-1位的值，然后把eax压栈当成do_timer的参数传递，4个字节。

好了，现在进入do_timer函数，在sched.c中：

//// 时钟中断C 函数处理程序，在kernel/system_call.s 中的_timer_interrupt（176 行）被调用。
// 参数cpl 是当前特权级0 或3，0 表示内核代码在执行。
// 对于一个进程由于执行时间片用完时，则进行任务切换。并执行一个计时更新工作。
void do_timer (long cpl)
{
  extern int beepcount;		// 扬声器发声时间滴答数(kernel/chr_drv/console.c,697)
  extern void sysbeepstop (void);	// 关闭扬声器(kernel/chr_drv/console.c,691)

  // 如果发声计数次数到，则关闭发声。(向0x61 口发送命令，复位位0 和1。位0 控制8253
  // 计数器2 的工作，位1 控制扬声器)。
  if (beepcount)
    if (!--beepcount)
      sysbeepstop ();

  // 如果当前特权级(cpl)为0（最高，表示是内核程序在工作），则将内核程序运行时间stime 递增；
  // [ Linus 把内核程序统称为超级用户(supervisor)的程序，见system_call.s,193 行上的英文注释]
  // 如果cpl > 0，则表示是一般用户程序在工作，增加utime。
  if (cpl)
    current->utime++;
  else
    current->stime++;

  // 如果有用户的定时器存在，则将链表第1 个定时器的值减1。如果已等于0，则调用相应的处理
  // 程序，并将该处理程序指针置为空。然后去掉该项定时器。
  if (next_timer)
    {				// next_timer 是定时器链表的头指针(见270 行)。
      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 的数字输出寄存器中马达启动位有置位的，则执行软盘定时程序(245 行)。
  if (current_DOR & 0xf0)
    do_floppy_timer ();
  if ((--current->counter) > 0)
    return;			// 如果进程运行时间还没完，则退出。
  current->counter = 0;
  if (!cpl)
    return;			// 对于超级用户程序(内核态程序)，不依赖counter 值进行调度。
  schedule ();
}

传递来的参数cpl的作用就是如果为0，表示是内核程序，则stime加1，否则都是普通用户程序，则utime加1。

用户定时器等用到再说。

接下来判断时间片counter，在sched.h的进程描述符中：

long counter;		// long counter 任务运行时间计数(递减)（滴答数），运行时间片。

如果还有时间片则不调用调度函数schedule()，然后时间片减1并退出此函数。

如果时间片已用完（<=0），则置时间片为0，紧接着判断特权级，如果是内核级程序则直接退出函数。否则进入最核心的调度函数schedule：

/*
 * 'schedule()'是调度函数。这是个很好的代码！没有任何理由对它进行修改，因为它可以在所有的
 * 环境下工作（比如能够对IO-边界处理很好的响应等）。只有一件事值得留意，那就是这里的信号
 * 处理代码。
 * 注意！！任务0 是个闲置('idle')任务，只有当没有其它任务可以运行时才调用它。它不能被杀
 * 死，也不能睡眠。任务0 中的状态信息'state'是从来不用的。
 */
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)
      {
    	// 如果设置过任务的定时值alarm，并且已经过期(alarm<jiffies),则在信号位图中置SIGALRM 信号，
    	// 即向任务发送SIGALARM 信号。然后清alarm。该信号的默认操作是终止进程。
    	// jiffies 是系统从开机开始算起的滴答数（10ms/滴答）。定义在sched.h 第139 行。
	if ((*p)->alarm && (*p)->alarm < jiffies)
	  {
	    (*p)->signal |= (1 << (SIGALRM - 1));
	    (*p)->alarm = 0;
	  }
	// 如果信号位图中除被阻塞的信号外还有其它信号，并且任务处于可中断状态，则置任务为就绪状态。
	// 其中'~(_BLOCKABLE & (*p)->blocked)'用于忽略被阻塞的信号，但SIGKILL 和SIGSTOP 不能被阻塞。
	if (((*p)->signal & ~(_BLOCKABLE & (*p)->blocked)) &&
	    (*p)->state == TASK_INTERRUPTIBLE)
	  (*p)->state = TASK_RUNNING;	//置为就绪（可执行）状态。
      }

  /* this is the scheduler proper: */
  /* 这里是调度程序的主要部分 */

  while (1)
    {
      c = -1;
      next = 0;
      i = NR_TASKS;
      p = &task[NR_TASKS];
      // 这段代码也是从任务数组的最后一个任务开始循环处理，并跳过不含任务的数组槽。比较每个就绪
      // 状态任务的counter（任务运行时间的递减滴答计数）值，哪一个值大，运行时间还不长，next 就
      // 指向哪个的任务号。
      while (--i)
	{
	  if (!*--p)
	    continue;
	  if ((*p)->state == TASK_RUNNING && (*p)->counter > c)
	    c = (*p)->counter, next = i;
	}
      // 如果比较得出有counter 值大于0 的结果，则退出124 行开始的循环，执行任务切换（141 行）。
      if (c)
	break;
      // 否则就根据每个任务的优先权值，更新每一个任务的counter 值，然后回到125 行重新比较。
      // counter 值的计算方式为counter = counter /2 + priority。[右边counter=0??]这里计算过程不考虑进程的状态。
      for (p = &LAST_TASK; p > &FIRST_TASK; --p)
	if (*p)
	  (*p)->counter = ((*p)->counter >> 1) + (*p)->priority;
    }
  // 切换到任务号为next 的任务运行。在126 行next 被初始化为0。因此若系统中没有任何其它任务
  // 可运行时，则next 始终为0。因此调度函数会在系统空闲时去执行任务0。此时任务0 仅执行
  // pause()系统调用，并又会调用本函数。
  switch_to (next);		// 切换到任务号为next 的任务，并运行之。
}

前面的比较好理解，直接分析主要部分，此部分的主要工作就是从所有的任务中找出时间片最大的任务，也就意味着运行的时间较少，next就指向这个任务并跳出循环去切换任务。

如果所有任务的时间片都为0，就根据每个任务的优先权值来更新每个任务的时间片counter值。然后重新找到next，最后切换任务，调用switch_to(next)：

// 宏定义，计算在全局表中第n 个任务的TSS 描述符的索引号（选择符）。
#define _TSS(n) ((((unsigned long) n)<<4)+(FIRST_TSS_ENTRY<<3))

/*
* switch_to(n)将切换当前任务到任务nr，即n。首先检测任务n 不是当前任务，
* 如果是则什么也不做退出。如果我们切换到的任务最近（上次运行）使用过数学
* 协处理器的话，则还需复位控制寄存器cr0 中的TS 标志。
*/
// 输入：%0 - 新TSS 的偏移地址(*&__tmp.a)； %1 - 存放新TSS 的选择符值(*&__tmp.b)；
// dx - 新任务n 的选择符；ecx - 新任务指针task[n]。
// 其中临时数据结构__tmp 中，a 的值是32 位偏移值，b 为新TSS 的选择符。在任务切换时，a 值
// 没有用（忽略）。在判断新任务上次执行是否使用过协处理器时，是通过将新任务状态段的地址与
// 保存在last_task_used_math 变量中的使用过协处理器的任务状态段的地址进行比较而作出的。
#define switch_to(n) {\
struct {long a,b;} __tmp; \
__asm__( "cmpl %%ecx,_current\n\t" \	// 任务n 是当前任务吗?(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]));
}

分析这段代码前先要知道，在32位保护模式下，有2种直接发起任务切换的方法：

1.call 0x0010:0x00000000

2.jmp 0x0010:0x00000000

在这两种情况下，call和jmp指令的操作数是任务的TSS描述符选择子或任务门。当处理器执行这两条指令时，首先用指令中给出的描述符选择子访问GDT，分析它的描述符类型。如果是一般的代码段描述符，就按普通的段间转移规则执行；如果是调用门，按调用门的规则执行；如果是TSS描述符，或者任务门，则执行任务切换。此时，指令中给出的32位偏移量被忽略，原因是执行任务切换时，所有处理器的状态都可以从TSS中获得。

当任务切换发生的时候，TR寄存器的内容也会跟着指向新任务的TSS。在任务切换时，任务寄存器tr 由CPU 自动加载。这个过程是这样的：首先，处理器将当前任务的现场信息保存到由TR寄存器指向的TSS；然后，再使TR寄存器指向新任务的TSS，并从新任务的TSS中恢复现场。

注意：任务门描述符可以安装在中断描述符表中，也可以安装在GDT或者LDT中。

知道了理论知识，上面的代码就不难分析了，关键的一句是把新任务的TSS选择子赋值给%1也就是*&_tmp.b处，现在b的值就是TSS选择子，注意这里ljmp %0相当于ljmp *%0，表示是间接跳转，相当于“ljmp *__tmp.a”，也就是跳转到地址&__tmp.a中包含的48bit逻辑地址处。而按struct _tmp的定义，这也就意味着__tmp.a即为该逻辑地址的offset部分，__tmp.b的低16bit为seg_selector(高16bit无用)部分。

直到这行指令执行完，才算真正的任务切换！至此进程调度分析结束。