已解决 关于进程调度schedule的疑问

seufy88

内核版本: LINUX 2.4.0平台： X86 SMP多CPU场合

部分代码：

1. asmlinkage void <b>schedule</b>(void)
   
2. 
   
3. next = idle_task(this_cpu);
   
4.         c = -1000;
   
5.         if (prev->state == TASK_RUNNING)
   
6.                 goto still_running;
   
7. 
   
8. still_running_back:
   
9.         list_for_each(tmp, &runqueue_head) {
   
10.                 p = list_entry(tmp, struct task_struct, run_list);
    
11.                 if (<b>can_schedule</b>(p, this_cpu)) {
    
12.                         int weight = goodness(p, this_cpu, prev->active_mm);
    
13.                         if (weight > c)
    
14.                                 c = weight, next = p;
    
15.                 }
    
16.                
    
17.                
    
18. #ifdef CONFIG_SMP
    
19. <b>         next->has_cpu = 1;</b>
    
20.         next->processor = this_cpu;
    
21. #endif
    
22. 
    
23. 
    
24. switch_to(prev, next, prev);
    
25.         __schedule_tail(prev);

复制代码

1. #define can_schedule(p,cpu) ((!(p)->has_cpu) && \
   
2.                                 ((p)->cpus_allowed & (1 << cpu)))

复制代码

1. static inline void __schedule_tail(struct task_struct *prev)
   
2. {
   
3. #ifdef CONFIG_SMP
   
4. 
   
5. <b>        prev->has_cpu = 0;</b>

复制代码

疑问：
has_cpu表示该进程正被某个CPU占用，是禁止被调度的。
当前进程(prev)调用switch_to切换出去时，为什么只将next的has_cpu设为1，而自己的has_cpu没有被清为0？
那prev的has_cpu一直为1的情况下，难道不是一直不会被调度从而切换回来吗
prev不再从switch_to被切换回来时，那在__schedule_tail中将prev的has_cpu清0是否妥当？
一个进程A在已经占用CPU的情况下，schedule到其他进程，但进程A没有清除自己的has_cpu (=0)
而has_cpu等于1的情况下是不允许被调度的，所以进程A不会在被调度回来
而进程A的has_cpu清零被安排在了切换回来后的__schedule_tail中
这是否有个矛盾在里面？

seufy88

问题2：

1. #define switch_to(prev,next,last) do {                                        \
   
2.         asm volatile("pushl %%esi\n\t"                                        \
   
3.                      "pushl %%edi\n\t"                                        \
   
4.                      "pushl %%ebp\n\t"                                        \
   
5.                      "movl %%esp,%0\n\t"        /* save ESP */                \
   
6.                      "movl %3,%%esp\n\t"        /* restore ESP */        \
   
7.                      "movl $1f,%1\n\t"                /* save EIP */                \
   
8.                      "pushl %4\n\t"                /* restore EIP */        \
   
9.                      "jmp __switch_to\n"                                \
   
10.                      "1:\t"                                                \
    
11.                      "popl %%ebp\n\t"                                        \
    
12.                      "popl %%edi\n\t"                                        \
    
13.                      "popl %%esi\n\t"                                        \
    
14.                      :"=m" (prev->thread.esp),"=m" (prev->thread.eip),        \
    
15.                       "=b" (last)                                        \
    
16.                      :"m" (next->thread.esp),"m" (next->thread.eip),        \
    
17.                       "a" (prev), "d" (next),                                \
    
18.                       "b" (prev));                                        \
    
19. } while (0)

复制代码

在jmp到__switch_to这个函数后，它需要2个参数，而根据switch_to宏中的内容，发现是edi,ebp这2个寄存器被压入栈中，来充当__switch_to的参数
但这为2个内容为什么可以当作prev_p和next_p呢？

1. void __switch_to(struct task_struct *prev_p, struct task_struct *next_p)

复制代码

seufy88

第一个问题，已解决。

1. #define switch_to(prev,next,last) do {                                        \
   
2.         asm volatile("pushl %%esi\n\t"                                        \
   
3.                      "pushl %%edi\n\t"                                        \
   
4.                      "pushl %%ebp\n\t"                                        \
   
5.                      "movl %%esp,%0\n\t"        /* save ESP */                \
   
6.                      "movl %3,%%esp\n\t"        /* restore ESP */        \
   
7.                      "movl $1f,%1\n\t"                /* save EIP */                \
   
8.                      "pushl %4\n\t"                /* restore EIP */        \
   
9.                      "jmp __switch_to\n"                                \
   
10.                      "1:\t"                                                \
    
11.                      "popl %%ebp\n\t"                                        \
    
12.                      "popl %%edi\n\t"                                        \
    
13.                      "popl %%esi\n\t"                                        \
    
14.                      :"=m" (prev->thread.esp),"=m" (prev->thread.eip),        \
    
15.                       "=b" (last)                                        \
    
16.                      :"m" (next->thread.esp),"m" (next->thread.eip),        \
    
17.                       "a" (prev), "d" (next),                                \
    
18.                       "b" (prev));                                        \
    
19. } while (0)

复制代码

进程A切换到进程B，在内核栈从A变成B后，该嵌入汇编最后会将EBX寄存器的内容赋值给LAST变量，而EBX又是输入寄存器，在整个SWITCH过程中并不改，一直存放着PREV的内容，注意这里的PREV是进程A的内核栈上的内容。也就是进程A的current
在执行完SWITCH的最后，将EBX赋值给LAST变量，而由于内核栈已经切换到B,这里的LAST变量虽然也是栈上的局部变量，但已经是进程B栈上的了。
所以切换到B后，对B来讲PREV局部变量中已经是存放着上一个被切过来的进程A的TAKS_struct了。接着调用schedule_tail，传入RREV,将进程A的has_cpu清0，让进程A将来可以再次被调度。