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

从系统调用返回到用户空间是否调度,从ret_with_reschedule可看出,是否真正调度,取决于当前进程的pcb中的need_resched是否设置为1,那如何设置为1取决于以下几种情况:

时间中断处理程序,发现当前进程运行时间过长:每次发生时间中断,都要递减该进程的时间片,一旦count为0,强制调度,剥夺当前进程运行

    

  1. void update_process_times(int user_tick)
    2. 

  2. {
    3. 

  3. 	struct task_struct *p = current;
    4. 

  4. 	int cpu = smp_processor_id(), system = user_tick ^ 1;
    5. 

    6. 

  6. 	update_one_process(p, user_tick, system, cpu);//统计信息而已
    7. 

  7. 	if (p->pid) {
    8. 

  8. 		if (--p->counter <= 0) {
    9. 

  9. 			p->counter = 0;
    10. 

  10. 			p->need_resched = 1;//强制调度
    11. 

  11. 		}
    12. 

  12. 		if (p->nice > 0)
    13. 

  13. 			kstat.per_cpu_nice[cpu] += user_tick;
    14. 

  14. 		else
    15. 

  15. 			kstat.per_cpu_user[cpu] += user_tick;
    16. 

  16. 		kstat.per_cpu_system[cpu] += system;
    17. 

  17. 	} else if (local_bh_count(cpu) || local_irq_count(cpu) > 1)
    18. 

  18. 		kstat.per_cpu_system[cpu] += system;
    19. 

  19. }
    20.

如果此时在用户态发生中断，进入内核态，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. 

  2. /*
    3. 

  3.  * Wake up a process. Put it on the run-queue if it‘s not
    4. 

  4.  * already there.  The "current" process is always on the
    5. 

  5.  * run-queue (except when the actual re-schedule is in
    6. 

  6.  * progress), and as such you‘re allowed to do the simpler
    7. 

  7.  * "current->state = TASK_RUNNING" to mark yourself runnable
    8. 

  8.  * without the overhead of this.
    9. 

  9.  */
    10. 

  10. inline void wake_up_process(struct task_struct * p)
    11. 

  11. {
    12. 

  12. 	unsigned long flags;
    13. 

    14. 

  14. 	/*
    15. 

  15. 	 * We want the common case fall through straight, thus the goto.
    16. 

  16. 	 */
    17. 

  17. 	spin_lock_irqsave(&runqueue_lock, flags);
    18. 

  18. 	p->state = TASK_RUNNING;//设置为可执行状态
    19. 

  19. 	if (task_on_runqueue(p))//如果已经到run队列
    20. 

  20. 		goto out;
    21. 

  21. 	add_to_runqueue(p);//加入run队列
    22. 

  22. 	reschedule_idle(p);//将唤醒进程与当前进程比较,如果唤醒进程比当前进程权值高,那就把当前进程的need_resched设置为1
    23. 

  23. out:
    24. 

  24. 	spin_unlock_irqrestore(&runqueue_lock, flags);
    25. 

  25. }
    26. 



    

  1. static void reschedule_idle(struct task_struct * p)
    2. 

  2. {
    3. 

  3.         ......
    4. 

  4. 	int this_cpu = smp_processor_id();
    5. 

  5. 	struct task_struct *tsk;
    6. 

    7. 

  7. 	tsk = cpu_curr(this_cpu);//获取当前进程的task_struct数据结构
    8. 

  8. 	if (preemption_goodness(tsk, p, this_cpu) > 1)//比较当前进程和被唤醒的进程的综合权值
    9. 

  9. 		tsk->need_resched = 1;//如果被唤醒的进程的综合权值比当前进程的大，那么强制调度
    10. 

    11. 

  11. }
    12.

对于第三种情况，实际上应被视为自愿的让出。但是，从内核代码的形式上看，也是通过相同的办法，将当前进程的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. 

  2. 				      struct sched_param *param)
    3. 

  3. {
    4. 

  4. 	return setscheduler(pid, policy, param);
    5. 

  5. }
    6. 

    7. 

  7. asmlinkage long sys_sched_setparam(pid_t pid, struct sched_param *param)
    8. 

  8. {
    9. 

  9. 	return setscheduler(pid, -1, param);
    10. 

  10. }
    11. 



    

  1. static int setscheduler(pid_t pid, int policy, 
    2. 

  2. 			struct sched_param *param)
    3. 

  3. {
    4. 

  4. 	struct sched_param lp;
    5. 

  5. 	struct task_struct *p;
    6. 

  6. 	int retval;
    7. 

    8. 

  8. 	retval = -EINVAL;
    9. 

  9. 	if (!param || pid < 0)
    10. 

  10. 		goto out_nounlock;
    11. 

    12. 

  12. 	retval = -EFAULT;
    13. 

  13. 	if (copy_from_user(&lp, param, sizeof(struct sched_param)))//从用户空间把sched_param结构拷贝到lp
    14. 

  14. 		goto out_nounlock;
    15. 

    16. 

  16. 	/*
    17. 

  17. 	 * We play safe to avoid deadlocks.
    18. 

  18. 	 */
    19. 

  19. 	read_lock_irq(&tasklist_lock);
    20. 

  20. 	spin_lock(&runqueue_lock);
    21. 

    22. 

  22. 	p = find_process_by_pid(pid);//通过pid找到task_struct
    23. 

    24. 

  24. 	retval = -ESRCH;
    25. 

  25. 	if (!p)
    26. 

  26. 		goto out_unlock;
    27. 

  27. 			
    28. 

  28. 	if (policy < 0)//policy为-1
    29. 

  29. 		policy = p->policy;//维持原来的政策
    30. 

  30. 	else {
    31. 

  31. 		retval = -EINVAL;
    32. 

  32. 		if (policy != SCHED_FIFO && policy != SCHED_RR &&
    33. 

  33. 				policy != SCHED_OTHER)//必须是这三种政策之一
    34. 

  34. 			goto out_unlock;
    35. 

  35. 	}
    36. 

  36. 	
    37. 

  37. 	/*
    38. 

  38. 	 * Valid priorities for SCHED_FIFO and SCHED_RR are 1..99, valid
    39. 

  39. 	 * priority for SCHED_OTHER is 0.
    40. 

  40. 	 */
    41. 

  41. 	retval = -EINVAL;
    42. 

  42. 	if (lp.sched_priority < 0 || lp.sched_priority > 99)//实时进程的priority必须处于0-99
    43. 

  43. 		goto out_unlock;
    44. 

  44. 	if ((policy == SCHED_OTHER) != (lp.sched_priority == 0))//如果政策是SCHED_OTHER，sched_priority必须是0
    45. 

  45. 		goto out_unlock;
    46. 

    47. 

  47. 	retval = -EPERM;
    48. 

  48. 	if ((policy == SCHED_FIFO || policy == SCHED_RR) && 
    49. 

  49. 	    !capable(CAP_SYS_NICE))
    50. 

  50. 		goto out_unlock;
    51. 

  51. 	if ((current->euid != p->euid) && (current->euid != p->uid) &&
    52. 

  52. 	    !capable(CAP_SYS_NICE))
    53. 

  53. 		goto out_unlock;
    54. 

    55. 

  55. 	retval = 0;
    56. 

  56. 	p->policy = policy;
    57. 

  57. 	p->rt_priority = lp.sched_priority;
    58. 

  58. 	if (task_on_runqueue(p))
    59. 

  59. 		move_first_runqueue(p);//从可执行进程队列的当前位置移到队列的前部，使其在调度时处于较为有利的地位
    60. 

    61. 

  61. 	current->need_resched = 1;//强制调度
    62. 

    63. 

  63. out_unlock:
    64. 

  64. 	spin_unlock(&runqueue_lock);
    65. 

  65. 	read_unlock_irq(&tasklist_lock);
    66. 

    67. 

  67. out_nounlock:
    68. 

  68. 	return retval;
    69. 

  69. }
    70.

另一个系统调用sched_yield()，使运行中的进程可以为其他进程"让路"，但并不进入睡眠。内核的实现sys_sched_yield，代码如下：

    

    2. 

  2. asmlinkage long sys_sched_yield(void)
    3. 

  3. {
    4. 

  4. 	/*
    5. 

  5. 	 * Trick. sched_yield() first counts the number of truly 
    6. 

  6. 	 * ‘pending‘ runnable processes, then returns if it‘s
    7. 

  7. 	 * only the current processes. (This test does not have
    8. 

  8. 	 * to be atomic.) In threaded applications this optimization
    9. 

  9. 	 * gets triggered quite often.
    10. 

  10. 	 */
    11. 

    12. 

  12. 	int nr_pending = nr_running;
    13. 

    14. 

  14. #if CONFIG_SMP
    15. 

  15. 	int i;
    16. 

    17. 

  17. 	// Substract non-idle processes running on other CPUs.
    18. 

  18. 	for (i = 0; i < smp_num_cpus; i++)
    19. 

  19. 		if (aligned_data[i].schedule_data.curr != idle_task(i))
    20. 

  20. 			nr_pending--;
    21. 

  21. #else
    22. 

  22. 	// on UP this process is on the runqueue as well
    23. 

  23. 	nr_pending--;
    24. 

  24. #endif
    25. 

  25. 	if (nr_pending) {//正在等待的运行的进程数
    26. 

  26. 		/*
    27. 

  27. 		 * This process can only be rescheduled by us,
    28. 

  28. 		 * so this is safe without any locking.
    29. 

  29. 		 */
    30. 

  30. 		if (current->policy == SCHED_OTHER)//当前进程调度策略为sched_other
    31. 

  31. 			current->policy |= SCHED_YIELD;//SCHED_YIELD标志位置1，在_schedule_tail清0
    32. 

  32. 		current->need_resched = 1;//强制调度
    33. 

  33. 	}
    34. 

  34. 	return 0;
    35. 

  35. }
    36.

来自为知笔记(Wiz)

时间： 2024-10-07 09:23:24

linux内核情景分析之强制性调度的相关文章

linux内核情景分析之execve()

用来描述用户态的cpu寄存器在内核栈中保存情况.可以获取用户空间的信息 struct pt_regs { long ebx; //可执行文件路径的指针(regs.ebx中 long ecx; //命令行参数的指针(regs.ecx中) long edx; //环境变量的指针(regs.edx中). long esi; long edi; long ebp; long eax; int xds; int xes; long orig_eax; long eip; int xcs; long efl

Linux内核情景分析的alloc_pages

NUMA结构的alloc_pages ==================== mm/numa.c 43 43 ==================== 43 #ifdef CONFIG_DISCONTIGMEM ==================== mm/numa.c 91 128 ==================== 91 /* 92 * This can be refined. Currently, tries to do round robin, instead 93 * sho

linux内核情景分析之exit与Wait

//第一层系统调用 asmlinkage long sys_exit(int error_code) { do_exit((error_code&0xff)<<8); } 其主体是do_exit,接下来我们来看看do_exit的实现 NORET_TYPE void do_exit(long code) { struct task_struct *tsk = current;//获取当前进程描述符 if (in_interrupt())//禁止中断时调用do_exit panic(&qu

Linux内核情景分析之异常访问,用户堆栈的扩展

情景假设: 在堆内存中申请了一块内存,然后释放掉该内存,然后再去访问这块内存.也就是所说的野指针访问. 当cpu产生页面错误时,会把失败的线性地址放在cr2寄存器.线性地址缺页异常的4种情况 1.如果cpu访问的行现地址在内核态,那么很可能访问的是非连续区,需要vmalloc_fault处理. 2.缺页异常发生在中断或者内核线程时,直接失败,因为不可修改页表 3.地址在一个区间内,那就可能是已经物理地址映射了但权限问题(错误处理)或者其物理地址没有分配(分配物理内存) 4.如果找到一个在线性地址

Linux内核源代码分析方法

Linux内核源代码分析方法   一.内核源代码之我见 Linux内核代码的庞大令不少人"望而生畏",也正由于如此,使得人们对Linux的了解仅处于泛泛的层次.假设想透析Linux,深入操作系统的本质,阅读内核源代码是最有效的途径.我们都知道,想成为优秀的程序猿,须要大量的实践和代码的编写.编程固然重要,可是往往仅仅编程的人非常easy把自己局限在自己的知识领域内.假设要扩展自己知识的广度,我们须要多接触其它人编写的代码,尤其是水平比我们更高的人编写的代码.通过这样的途径,我们能够跳出

Linux内核Crash分析

转载自:http://linux.cn/article-3475-1.html 在工作中经常会遇到一些内核crash的情况,本文就是根据内核出现crash后的打印信息,对其进行了分析,使用的内核版本为:Linux2.6.32. 每一个进程的生命周期内,其生命周期的范围为几毫秒到几个月.一般都是和内核有交互,例如用户空间程序使用系统调用进入内核空间.这时使用的不再是用户空 间的栈空间,使用对应的内核栈空间.对每一个进程来说,Linux内核都会把两个不同的数据结构紧凑的存放在一个单独为进程分配的存储

Linux源代码情景分析读书笔记 物理页面的分配

函数 alloc_pages流程图 Linux源代码情景分析读书笔记 物理页面的分配,布布扣,bubuko.com

linux 内核源代码分析 - 获取数组的大小

#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0])) 測试程序: #include<stdio.h> #include<stdlib.h> struct dev { int a; char b; float c; }; struct dev devs[]= { { 1,'a',7.0, }, { 1,'a',7.0, }, { 1,'a',7.0, }, }; int main() { printf("int is %d \

Linux内核启动分析

张超<Linux内核分析>MOOC课程http://mooc.study.163.com/course/USTC-1000029000 我的代码可见https://www.shiyanlou.com/courses/reports/986221 在这里我们用的是linux-3.18.6版本,以下简写成linux. start_kernel在 /linux/init/main.c中定义: 这个函数是内核由引导程序引导以后,由自解压程序解压以后执行的第一个函数,可以认为是整个内核的入口函数,以后我