首页 > 代码库 > linux内核情景分析之强制性调度

linux内核情景分析之强制性调度

2024-08-17 22:24:06   221人阅读

从系统调用返回到用户空间是否调度,从ret_with_reschedule可看出,是否真正调度,取决于当前进程的pcb中的need_resched是否设置为1,那如何设置为1取决于以下几种情况:
时间中断处理程序,发现当前进程运行时间过长:每次发生时间中断,都要递减该进程的时间片,一旦count为0,强制调度,剥夺当前进程运行
  1. void update_process_times(int user_tick)
  2. {
  3. 	struct task_struct *p = current;
  4. 	int cpu = smp_processor_id(), system = user_tick ^ 1;
  6. 	update_one_process(p, user_tick, system, cpu);//统计信息而已
  7. 	if (p->pid) {
  8. 		if (--p->counter <= 0) {
  9. 			p->counter = 0;
  10. 			p->need_resched = 1;//强制调度
  11. 		}
  12. 		if (p->nice > 0)
  13. 			kstat.per_cpu_nice[cpu] += user_tick;
  14. 		else
  15. 			kstat.per_cpu_user[cpu] += user_tick;
  16. 		kstat.per_cpu_system[cpu] += system;
  17. 	} else if (local_bh_count(cpu) || local_irq_count(cpu) > 1)
  18. 		kstat.per_cpu_system[cpu] += system;
  19. }
 如果此时在用户态发生中断，进入内核态，p->counter减为0，那么p->need_resched就置为1，中断返回时就会强制调度。

    如果此时发生系统调用，进入内核态，再发生中断，p->counter减为0，那么p->need_resched就置为1，中断返回后，然后系统调用返回时就会强制调度。

    如果此时在用户态发生异常，进入内核态，再发生中断，p->counter减为0，那么p->need_resched就置为1，中断返回后，然后异常返回时就会强制调度。


第二种情况
唤醒一个睡眠进程,发现被唤醒的进程比当前进程权值高,need_sched设置为1
  2. /*
  3.  * Wake up a process. Put it on the run-queue if it‘s not
  4.  * already there.  The "current" process is always on the
  5.  * run-queue (except when the actual re-schedule is in
  6.  * progress), and as such you‘re allowed to do the simpler
  7.  * "current->state = TASK_RUNNING" to mark yourself runnable
  8.  * without the overhead of this.
  9.  */
  10. inline void wake_up_process(struct task_struct * p)
  11. {
  12. 	unsigned long flags;
  14. 	/*
  15. 	 * We want the common case fall through straight, thus the goto.
  16. 	 */
  17. 	spin_lock_irqsave(&runqueue_lock, flags);
  18. 	p->state = TASK_RUNNING;//设置为可执行状态
  19. 	if (task_on_runqueue(p))//如果已经到run队列
  20. 		goto out;
  21. 	add_to_runqueue(p);//加入run队列
  22. 	reschedule_idle(p);//将唤醒进程与当前进程比较,如果唤醒进程比当前进程权值高,那就把当前进程的need_resched设置为1
  23. out:
  24. 	spin_unlock_irqrestore(&runqueue_lock, flags);
  25. }

  1. static void reschedule_idle(struct task_struct * p)
  2. {
  3.         ......
  4. 	int this_cpu = smp_processor_id();
  5. 	struct task_struct *tsk;
  7. 	tsk = cpu_curr(this_cpu);//获取当前进程的task_struct数据结构
  8. 	if (preemption_goodness(tsk, p, this_cpu) > 1)//比较当前进程和被唤醒的进程的综合权值
  9. 		tsk->need_resched = 1;//如果被唤醒的进程的综合权值比当前进程的大，那么强制调度
  11. }

 对于第三种情况，实际上应被视为自愿的让出。但是，从内核代码的形式上看，也是通过相同的办法，将当前进程的need_resched标志置为1，使得在进程返回用户空间前夕发生调度，所以也放在这一节。此类系统调用有两个，一个是sched_setscheduler()，另一个是sched_yield()。

    系统调用sched_setscheduler()的作用是改变进程的调度政策。用户登录到系统后，第一个进程的适用调度政策为SCHED_OTHER，也就是默认为无实时要求的交互式应用。在fork()创建新进程时则将此进程适用的调度政策遗传给了子进程。但是，用户可以通过系统调用sched_setscheduler()改变其适用调度政策。

sched_setscheduler，内核态对应的代码如下：


  1. asmlinkage long sys_sched_setscheduler(pid_t pid, int policy, 
  2. 				      struct sched_param *param)
  3. {
  4. 	return setscheduler(pid, policy, param);
  5. }
  7. asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param *param)
  8. {
  9. 	return setscheduler(pid, -1, param);
  10. }

  1. static int setscheduler(pid_t pid, int policy, 
  2. 			struct sched_param *param)
  3. {
  4. 	struct sched_param lp;
  5. 	struct task_struct *p;
  6. 	int retval;
  8. 	retval = -EINVAL;
  9. 	if (!param || pid < 0)
  10. 		goto out_nounlock;
  12. 	retval = -EFAULT;
  13. 	if (copy_from_user(&lp, param, sizeof(struct sched_param)))//从用户空间把sched_param结构拷贝到lp
  14. 		goto out_nounlock;
  16. 	/*
  17. 	 * We play safe to avoid deadlocks.
  18. 	 */
  19. 	read_lock_irq(&tasklist_lock);
  20. 	spin_lock(&runqueue_lock);
  22. 	p = find_process_by_pid(pid);//通过pid找到task_struct
  24. 	retval = -ESRCH;
  25. 	if (!p)
  26. 		goto out_unlock;
  27. 			
  28. 	if (policy < 0)//policy为-1
  29. 		policy = p->policy;//维持原来的政策
  30. 	else {
  31. 		retval = -EINVAL;
  32. 		if (policy != SCHED_FIFO && policy != SCHED_RR &&
  33. 				policy != SCHED_OTHER)//必须是这三种政策之一
  34. 			goto out_unlock;
  35. 	}
  36. 	
  37. 	/*
  38. 	 * Valid priorities for SCHED_FIFO and SCHED_RR are 1..99, valid
  39. 	 * priority for SCHED_OTHER is 0.
  40. 	 */
  41. 	retval = -EINVAL;
  42. 	if (lp.sched_priority < 0 || lp.sched_priority > 99)//实时进程的priority必须处于0-99
  43. 		goto out_unlock;
  44. 	if ((policy == SCHED_OTHER) != (lp.sched_priority == 0))//如果政策是SCHED_OTHER，sched_priority必须是0
  45. 		goto out_unlock;
  47. 	retval = -EPERM;
  48. 	if ((policy == SCHED_FIFO || policy == SCHED_RR) && 
  49. 	    !capable(CAP_SYS_NICE))
  50. 		goto out_unlock;
  51. 	if ((current->euid != p->euid) && (current->euid != p->uid) &&
  52. 	    !capable(CAP_SYS_NICE))
  53. 		goto out_unlock;
  55. 	retval = 0;
  56. 	p->policy = policy;
  57. 	p->rt_priority = lp.sched_priority;
  58. 	if (task_on_runqueue(p))
  59. 		move_first_runqueue(p);//从可执行进程队列的当前位置移到队列的前部，使其在调度时处于较为有利的地位
  61. 	current->need_resched = 1;//强制调度
  63. out_unlock:
  64. 	spin_unlock(&runqueue_lock);
  65. 	read_unlock_irq(&tasklist_lock);
  67. out_nounlock:
  68. 	return retval;
  69. }


  另一个系统调用sched_yield()，使运行中的进程可以为其他进程"让路"，但并不进入睡眠。内核的实现sys_sched_yield，代码如下：
  2. asmlinkage long sys_sched_yield(void)
  3. {
  4. 	/*
  5. 	 * Trick. sched_yield() first counts the number of truly 
  6. 	 * ‘pending‘ runnable processes, then returns if it‘s
  7. 	 * only the current processes. (This test does not have
  8. 	 * to be atomic.) In threaded applications this optimization
  9. 	 * gets triggered quite often.
  10. 	 */
  12. 	int nr_pending = nr_running;
  14. #if CONFIG_SMP
  15. 	int i;
  17. 	// Substract non-idle processes running on other CPUs.
  18. 	for (i = 0; i < smp_num_cpus; i++)
  19. 		if (aligned_data[i].schedule_data.curr != idle_task(i))
  20. 			nr_pending--;
  21. #else
  22. 	// on UP this process is on the runqueue as well
  23. 	nr_pending--;
  24. #endif
  25. 	if (nr_pending) {//正在等待的运行的进程数
  26. 		/*
  27. 		 * This process can only be rescheduled by us,
  28. 		 * so this is safe without any locking.
  29. 		 */
  30. 		if (current->policy == SCHED_OTHER)//当前进程调度策略为sched_other
  31. 			current->policy |= SCHED_YIELD;//SCHED_YIELD标志位置1，在_schedule_tail清0
  32. 		current->need_resched = 1;//强制调度
  33. 	}
  34. 	return 0;
  35. }




来自为知笔记(Wiz)


linux内核情景分析之强制性调度


联系
我们