标签：
一 关于进程的补充
进程调度的时机
中断处理过程（包括时钟中断、I/O中断、系统调用和异常）中，直接调用schedule()，或者返回用户态时根据need_resched标记调用schedule()；
内核线程可以直接调用schedule()进行进程切换，也可以在中断处理过程中进行调度，也就是说内核线程作为一类的特殊的进程可以主动调度，也可以被动调度；
用户态进程无法实现主动调度，仅能通过陷入内核态后的某个时机点进行调度，即在中断处理过程中进行调度。
进程的切换
为了控制进程的执行，内核必须有能力挂起正在CPU上执行的进程，并恢复以前挂起的某个进程的执行，这叫做进程切换、任务切换、上下文切换；
挂起正在CPU上执行的进程，与中断时保存现场是不同的，中断前后是在同一个进程上下文中，只是由用户态转向内核态执行；
进程上下文包含了进程执行需要的所有信息
用户地址空间： 包括程序代码，数据，用户堆栈等
控制信息 ：进程描述符，内核堆栈等
硬件上下文（注意中断也要保存硬件上下文只是保存的方法不同）
二 代码分析
（不同于上几次的模式，即先用gdb跟踪分析，再分析代码）linux中通过schedule()函数来实现进程的调度，涉及到知识很多，如，调度的策略，时间片的分配，进程上下文的切换等，这里只是粗浅的分析schedule等相关函数
先给出代码：schedule()
asmlinkage __visible void __sched schedule(void)
{
struct task_struct *tsk = current;
sched_submit_work(tsk);
__schedule();
}
其中 sched_submit_work（）是为了避免进程睡眠时发生死锁。
static inline void sched_submit_work(struct task_struct *tsk) { if (!tsk->state || tsk_is_pi_blocked(tsk)) return; /* * If we are going to sleep and we have plugged IO queued, * make sure to submit it to avoid deadlocks. */ if (blk_needs_flush_plug(tsk)) blk_schedule_flush_plug(tsk); }
__schedule() 是进程调度的函数（里面还有嵌套~）
1 static void __sched __schedule(void) 2 { 3 struct task_struct *prev, *next; 4 unsigned long *switch_count; 5 struct rq *rq; 6 int cpu; 7 8 need_resched: 9 preempt_disable(); 10 cpu = smp_processor_id(); 11 rq = cpu_rq(cpu); 12 rcu_note_context_switch(cpu); 13 prev = rq->curr; 14 15 schedule_debug(prev); 16 17 if (sched_feat(HRTICK)) 18 hrtick_clear(rq); 19 20 /* 21 * Make sure that signal_pending_state()->signal_pending() below 22 * can‘t be reordered with __set_current_state(TASK_INTERRUPTIBLE) 23 * done by the caller to avoid the race with signal_wake_up(). 24 */ 25 smp_mb__before_spinlock(); 26 raw_spin_lock_irq(&rq->lock); 27 28 switch_count = &prev->nivcsw; 29 if (prev->state && !(preempt_count() & PREEMPT_ACTIVE)) { 30 if (unlikely(signal_pending_state(prev->state, prev))) { 31 prev->state = TASK_RUNNING; 32 } else { 33 deactivate_task(rq, prev, DEQUEUE_SLEEP); 34 prev->on_rq = 0; 35 36 /* 37 * If a worker went to sleep, notify and ask workqueue 38 * whether it wants to wake up a task to maintain 39 * concurrency. 40 */ 41 if (prev->flags & PF_WQ_WORKER) { 42 struct task_struct *to_wakeup; 43 44 to_wakeup = wq_worker_sleeping(prev, cpu); 45 if (to_wakeup) 46 try_to_wake_up_local(to_wakeup); 47 } 48 } 49 switch_count = &prev->nvcsw; 50 } 51 52 if (task_on_rq_queued(prev) || rq->skip_clock_update < 0) 53 update_rq_clock(rq); 54 55 next = pick_next_task(rq, prev); 56 clear_tsk_need_resched(prev); 57 clear_preempt_need_resched(); 58 rq->skip_clock_update = 0; 59 60 if (likely(prev != next)) { 61 rq->nr_switches++; 62 rq->curr = next; 63 ++*switch_count; 64 65 context_switch(rq, prev, next); /* unlocks the rq */ 66 /* 67 * The context switch have flipped the stack from under us 68 * and restored the local variables which were saved when 69 * this task called schedule() in the past. prev == current 70 * is still correct, but it can be moved to another cpu/rq. 71 */ 72 cpu = smp_processor_id(); 73 rq = cpu_rq(cpu); 74 } else 75 raw_spin_unlock_irq(&rq->lock); 76 77 post_schedule(rq); 78 79 sched_preempt_enable_no_resched(); 80 if (need_resched()) 81 goto need_resched; 82 }
上面的红色给出了重点标记，context_switch()，进行了进程上下文切换。
1 static inline void 2 context_switch(struct rq *rq, struct task_struct *prev, 3 struct task_struct *next) 4 { 5 struct mm_struct *mm, *oldmm; 6 7 prepare_task_switch(rq, prev, next); 8 9 mm = next->mm; 10 oldmm = prev->active_mm; 11 /* 12 * For paravirt, this is coupled with an exit in switch_to to 13 * combine the page table reload and the switch backend into 14 * one hypercall. 15 */ 16 arch_start_context_switch(prev); 17 18 if (!mm) { 19 next->active_mm = oldmm; 20 atomic_inc(&oldmm->mm_count); 21 enter_lazy_tlb(oldmm, next); 22 } else 23 switch_mm(oldmm, mm, next); 24 25 if (!prev->mm) { 26 prev->active_mm = NULL; 27 rq->prev_mm = oldmm; 28 } 29 /* 30 * Since the runqueue lock will be released by the next 31 * task (which is an invalid locking op but in the case 32 * of the scheduler it‘s an obvious special-case), so we 33 * do an early lockdep release here: 34 */ 35 spin_release(&rq->lock.dep_map, 1, _THIS_IP_); 36 37 context_tracking_task_switch(prev, next); 38 /* Here we just switch the register state and the stack. */ 39 switch_to(prev, next, prev); 40 41 barrier(); 42 /* 43 * this_rq must be evaluated again because prev may have moved 44 * CPUs since it called schedule(), thus the ‘rq‘ on its stack 45 * frame will be invalid. 46 */ 47 finish_task_switch(this_rq(), prev); 48 }
前文中提到的进程上下文关于硬件上下文，将当前进程的寄存器中的内容保存，并装入下一进程的以前保存的堆栈，寄存器的内容，即下面的switch_to()实现：
1 #define switch_to(prev, next, last) 2 32do { 3 33 /* 4 34 * Context-switching clobbers all registers, so we clobber 5 35 * them explicitly, via unused output variables. 6 36 * (EAX and EBP is not listed because EBP is saved/restored 7 37 * explicitly for wchan access and EAX is the return value of 8 38 * __switch_to()) 9 39 */ 10 40 unsigned long ebx, ecx, edx, esi, edi; 11 41 12 42 asm volatile("pushfl\n\t" /* save flags */ 13 43 "pushl %%ebp\n\t" /* save EBP */ 14 44 "movl %%esp,%[prev_sp]\n\t" /* save ESP */ 15 45 "movl %[next_sp],%%esp\n\t" /* restore ESP */ 16 46 "movl $1f,%[prev_ip]\n\t" /* save EIP */ 17 47 "pushl %[next_ip]\n\t" /* restore EIP */ 18 48 __switch_canary 19 49 "jmp __switch_to\n" /* regparm call */ 20 50 "1:\t" 21 51 "popl %%ebp\n\t" /* restore EBP */ 22 52 "popfl\n" /* restore flags */ 23 53 24 54 /* output parameters */ 25 55 : [prev_sp] "=m" (prev->thread.sp), 26 56 [prev_ip] "=m" (prev->thread.ip), 27 57 "=a" (last), 28 58 29 59 /* clobbered output registers: */ 30 60 "=b" (ebx), "=c" (ecx), "=d" (edx), 31 61 "=S" (esi), "=D" (edi) 32 62 33 63 __switch_canary_oparam 34 64 35 65 /* input parameters: */ 36 66 : [next_sp] "m" (next->thread.sp), 37 67 [next_ip] "m" (next->thread.ip), 38 68 39 69 /* regparm parameters for __switch_to(): */ 40 70 [prev] "a" (prev), 41 71 [next] "d" (next) 42 72 43 73 __switch_canary_iparam 44 74 45 75 : /* reloaded segment registers */ 46 76 "memory"); 47 77} while (0) 48 78
可以从上面的嵌入汇编看出主要就是保存当前进程的flags，ebp,esp,eip，并装入下一进程的flags，ebp,esp,eip，当执行到 "pushl %[next_ip]\n\t" ，即进入到下一个进程的范畴了。
三 利用gdb工具跟踪
配置qemu环境：
设置断点：
发现gdb工具探测不到context_switch(),switch_to() ,只有断点1有效，下面的结果也验证了
停在第一个断点处。接着运行“c”，但是断点一直在schedule（）处
主要是context_switch(),switch_to() 两处设置不了断点，有待解决，希望大家指出是什么问题。。。。
三 总结分析
linux与任何分时系统一样，通过一个进程到另一个进程的快速切换，达到表面上看起来多个任务并行执行的效果。
schedule（）可以由几个内核控制路径调用，可以采取直接调用的方式或延迟调用的方式。
直接调用：如果current进程不能获得必须的资源而要立刻被阻塞，直接调用调度程序。
延迟调用：把current进程的TIF_NEED_RESCHED标志设置为1，而以延迟的方式调度调度程序。由于总是在恢复用户态进程的执行之前检查这个标志的值，所以schedule（）将在不久后的某个时刻被明确的执行。
by：方龙伟
原创作品 转载请注明出处
《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000
标签：
原文地址：http://www.cnblogs.com/-flw/p/5399310.html
