关于中断与进程切换的问题？

一个时钟中断产生时，会对被中断的进程进行时间片计算，如果时间片用完，那就应该引起进程切换，就是你这里提到的“rescheduling activity”

具体代码路径如下：

1. timer_interrupt() ---> do_timer_interrupt()  --->do_timer_interrupt_hook() ---> update_process_times() ---> scheduler_tick()
   
2. 
   
3. void scheduler_tick(void)
   
4. {
   
5.         int cpu = smp_processor_id();
   
6.         runqueue_t *rq = this_rq();
   
7.         task_t *p = current;
   
8.         unsigned long long now = sched_clock();
   
9. 
   
10.         update_cpu_clock(p, rq, now);
    
11. 
    
12.         rq->timestamp_last_tick = now;
    
13. 
    
14.         if (p == rq->idle) {
    
15.                 if (wake_priority_sleeper(rq))
    
16.                         goto out;
    
17.                 rebalance_tick(cpu, rq, SCHED_IDLE);
    
18.                 return;
    
19.         }
    
20. 
    
21.         /* Task might have expired already, but not scheduled off yet */
    
22.         if (p->array != rq->active) {
    
23.                 set_tsk_need_resched(p);
    
24.                 goto out;
    
25.         }
    
26.         spin_lock(&rq->lock);
    
27.         /*
    
28.          * The task was running during this tick - update the
    
29.          * time slice counter. Note: we do not update a thread's
    
30.          * priority until it either goes to sleep or uses up its
    
31.          * timeslice. This makes it possible for interactive tasks
    
32.          * to use up their timeslices at their highest priority levels.
    
33.          */
    
34.         if (rt_task(p)) {
    
35.                 /*
    
36.                  * RR tasks need a special form of timeslice management.
    
37.                  * FIFO tasks have no timeslices.
    
38.                  */
    
39.                 if ((p->policy == SCHED_RR) && !--p->time_slice) {
    
40.                         p->time_slice = task_timeslice(p);
    
41.                         p->first_time_slice = 0;
    
42.                         set_tsk_need_resched(p);
    
43. 
    
44.                         /* put it at the end of the queue: */
    
45.                         requeue_task(p, rq->active);
    
46.                 }
    
47.                 goto out_unlock;
    
48.         }
    
49.         if (!--p->time_slice) {
    
50.                 dequeue_task(p, rq->active);
    
51.                 set_tsk_need_resched(p);
    
52.                 p->prio = effective_prio(p);
    
53.                 p->time_slice = task_timeslice(p);
    
54.                 p->first_time_slice = 0;
    
55. 
    
56.                 if (!rq->expired_timestamp)
    
57.                         rq->expired_timestamp = jiffies;
    
58.                 if (!TASK_INTERACTIVE(p) || EXPIRED_STARVING(rq)) {
    
59.                         enqueue_task(p, rq->expired);
    
60.                         if (p->static_prio < rq->best_expired_prio)
    
61.                                 rq->best_expired_prio = p->static_prio;
    
62.                 } else
    
63.                         enqueue_task(p, rq->active);
    
64.         } else {
    
65.                 /*
    
66.                  * Prevent a too long timeslice allowing a task to monopolize
    
67.                  * the CPU. We do this by splitting up the timeslice into
    
68.                  * smaller pieces.
    
69.                  *
    
70.                  * Note: this does not mean the task's timeslices expire or
    
71.                  * get lost in any way, they just might be preempted by
    
72.                  * another task of equal priority. (one with higher
    
73.                  * priority would have preempted this task already.) We
    
74.                  * requeue this task to the end of the list on this priority
    
75.                  * level, which is in essence a round-robin of tasks with
    
76.                  * equal priority.
    
77.                  *
    
78.                  * This only applies to tasks in the interactive
    
79.                  * delta range with at least TIMESLICE_GRANULARITY to requeue.
    
80.                  */
    
81.                 if (TASK_INTERACTIVE(p) && !((task_timeslice(p) -
    
82.                         p->time_slice) % TIMESLICE_GRANULARITY(p)) &&
    
83.                         (p->time_slice >= TIMESLICE_GRANULARITY(p)) &&
    
84.                         (p->array == rq->active)) {
    
85. 
    
86.                         requeue_task(p, rq->active);
    
87.                         set_tsk_need_resched(p);
    
88.                 }
    
89.         }
    
90. out_unlock:
    
91.         spin_unlock(&rq->lock);
    
92. out:
    
93.         rebalance_tick(cpu, rq, NOT_IDLE);
    
94. }
    
95. 
    
96. 
    
97. 这里面有几个地方都调用了set_tsk_need_resched(p)
    
98. 
    
99. static inline void set_tsk_need_resched(struct task_struct *tsk)
    
100. {
     
101.         set_tsk_thread_flag(tsk,TIF_NEED_RESCHED);
     
102. }
     
103. 
     
104. 
     
105. static inline void set_tsk_thread_flag(struct task_struct *tsk, int flag)
     
106. {
     
107.         set_ti_thread_flag(task_thread_info(tsk), flag);
     
108. }
     
109. 
     
110. static inline void set_ti_thread_flag(struct thread_info *ti, int flag)
     
111. {
     
112.         set_bit(flag,&ti->flags);
     
113. }

复制代码

最后，在中断处理结束的点上，调用了ret_from_intr（在entry.S中）

1. ret_from_intr:
   
2.         GET_THREAD_INFO(p)
   
3.         movl EFLAGS(%esp), x                # mix EFLAGS and CS
   
4.         movb CS(%esp), %al
   
5.         testl $(VM_MASK | 3), x
   
6.         jz resume_kernel
   
7. ENTRY(resume_userspace)
   
8.         cli                                # make sure we don't miss an interrupt
   
9.                                         # setting need_resched or sigpending
   
10.                                         # between sampling and the iret
    
11.         movl TI_flags(p), x
    
12.         andl $_TIF_WORK_MASK, x        # is there any work to be done on
    
13.                                         # int/exception return?
    
14.         jne work_pending
    
15.         jmp restore_all
    
16. 
    
17. #ifdef CONFIG_PREEMPT
    
18. ENTRY(resume_kernel)
    
19.         cli
    
20.         cmpl $0,TI_preempt_count(p)        # non-zero preempt_count ?
    
21.         jnz restore_nocheck
    
22. need_resched:
    
23.         movl TI_flags(p), x        # need_resched set ?
    
24.         testb $_TIF_NEED_RESCHED, %cl
    
25.         jz restore_all
    
26.         testl $IF_MASK,EFLAGS(%esp)     # interrupts off (exception path) ?
    
27.         jz restore_all
    
28.         call preempt_schedule_irq
    
29.         jmp need_resched
    
30. #endif

复制代码

可以看到，最后是通过call preempt_schedule_irq进行进程切换的

1. asmlinkage void __sched preempt_schedule_irq(void)
   
2. {
   
3.         struct thread_info *ti = current_thread_info();
   
4. #ifdef CONFIG_PREEMPT_BKL
   
5.         struct task_struct *task = current;
   
6.         int saved_lock_depth;
   
7. #endif
   
8.         /* Catch callers which need to be fixed*/
   
9.         BUG_ON(ti->preempt_count || !irqs_disabled());
   
10. 
    
11. need_resched:
    
12.         add_preempt_count(PREEMPT_ACTIVE);
    
13.         /*
    
14.          * We keep the big kernel semaphore locked, but we
    
15.          * clear ->lock_depth so that schedule() doesnt
    
16.          * auto-release the semaphore:
    
17.          */
    
18. #ifdef CONFIG_PREEMPT_BKL
    
19.         saved_lock_depth = task->lock_depth;
    
20.         task->lock_depth = -1;
    
21. #endif
    
22.         local_irq_enable();
    
23.         [b]schedule();[/b]        local_irq_disable();
    
24. #ifdef CONFIG_PREEMPT_BKL
    
25.         task->lock_depth = saved_lock_depth;
    
26. #endif
    
27.         sub_preempt_count(PREEMPT_ACTIVE);
    
28. 
    
29.         /* we could miss a preemption opportunity between schedule and now */
    
30.         barrier();
    
31.         if (unlikely(test_thread_flag(TIF_NEED_RESCHED)))
    
32.                 goto need_resched;
    
33. }

复制代码

Hi, Linux!