完成一个简单的时间片轮转多道程序内核

注：袁帅+ 原创作品转载请注明出处 + 《Linux内核分析》MOOC课程http://mooc.study.163.com/course/USTC-1000029000 

linux内核分析的第二课：完成一个简单的时间片轮转多道程序内核代码

使用下面的程序来进行分析，在实验楼的环境下操作：

mypcb.h：

1. #define MAX_TASK_NUM 4
2. #define KERNEL_STACK_SIZE 1024*8
4. structTread{
5. unsignedlong eip;
6. unsignedlong esp;
7. };
9. typedef struct PCB{
10. long pid;
11. long state;
12. char stack[KERNEL_STACK_SIZE];
13. long task_entry;
14. structTread thread;
15. struct PCB*next;
16. }PCB_t;
18. void my_schedule(void);

mymain.c:

1. #include<linux/types.h>
2. #include<linux/module.h>
3. #include<linux/proc_fs.h>
4. #include<linux/kernel.h>
5. #include<linux/syscalls.h>
6. #include<linux/stackprotector.h>
7. #include<linux/string.h>
8. #include<linux/ctype.h>
9. #include<linux/delay.h>
10. #include<linux/ioport.h>
11. #include<linux/init.h>
12. #include<linux/initrd.h>
13. #include<linux/bootmem.h>
14. #include<linux/acpi.h>
15. #include<linux/tty.h>
16. #include<linux/percpu.h>
17. #include<linux/kmod.h>
18. #include<linux/vmalloc.h>
19. #include<linux/kernel_stat.h>
20. #include<linux/start_kernel.h>
21. #include<linux/security.h>
22. #include<linux/smp.h>
23. #include<linux/profile.h>
24. #include<linux/rcupdate.h>
25. #include<linux/moduleparam.h>
26. #include<linux/kallsyms.h>
27. #include<linux/writeback.h>
28. #include<linux/cpu.h>
29. #include<linux/cpuset.h>
30. #include<linux/cgroup.h>
31. #include<linux/efi.h>
32. #include<linux/tick.h>
33. #include<linux/interrupt.h>
34. #include<linux/taskstats_kern.h>
35. #include<linux/delayacct.h>
36. #include<linux/unistd.h>
37. #include<linux/rmap.h>
38. #include<linux/mempolicy.h>
39. #include<linux/key.h>
40. #include<linux/buffer_head.h>
41. #include<linux/page_cgroup.h>
42. #include<linux/debug_locks.h>
43. #include<linux/debugobjects.h>
44. #include<linux/lockdep.h>
45. #include<linux/kmemleak.h>
46. #include<linux/pid_namespace.h>
47. #include<linux/device.h>
48. #include<linux/kthread.h>
49. #include<linux/sched.h>
50. #include<linux/signal.h>
51. #include<linux/idr.h>
52. #include<linux/kgdb.h>
53. #include<linux/ftrace.h>
54. #include<linux/async.h>
55. #include<linux/kmemcheck.h>
56. #include<linux/sfi.h>
57. #include<linux/shmem_fs.h>
58. #include<linux/slab.h>
59. #include<linux/perf_event.h>
60. #include<linux/file.h>
61. #include<linux/ptrace.h>
62. #include<linux/blkdev.h>
63. #include<linux/elevator.h>
65. #include<asm/io.h>
66. #include<asm/bugs.h>
67. #include<asm/setup.h>
68. #include<asm/sections.h>
69. #include<asm/cacheflush.h>
71. #include"mypcb.h"
73. #ifdef CONFIG_X86_LOCAL_APIC
74. #include<asm/smp.h>
75. #endif

2. PCB_t task[MAX_TASK_NUM];
3. PCB_t* my_current = NULL;
4. int my_need_schedule=0;
5. void my_process(void);

/*my_start_kernel首先初始化任务0的PCB，然后在初始化其他任务的PCB*/

1. void __init my_start_kernel(void)
2. {
3. int pid =0;
4. /* initail task 0*/
5. task[0].pid=0;
6. task[0].state=0;
7. task[0].task_entry= task[0].thread.eip=(unsignedlong)my_process;
8. task[0].thread.esp=(unsignedlong)&task[0].stack;
9. task[0].next=&task[0];
10. /*fork task*/
11. int i;
12. for(i=1;i<MAX_TASK_NUM;i++){
13. memcpy(&task[i],&task[0],sizeof(task[0]));
14. task[i].pid= i;
15. task[i].state=-1;
16. task[i].thread.esp=(unsignedlong)&task[i].stack;
17. task[i].next= task[i-1].next;
18. task[i-1].next=&task[i];
19. }
20. pid=0;
21. my_current=&task[0];
22. /*这段内嵌汇编代码很重要，是用来启动任务0的*/
23. asmvolatile(
24. "movl %1,%%esp\n\t"//这里恢复任务0的内核栈
25. "pushl %1\n\t" //保存任务0的内核栈
26. "pushl %0\n\t" //把EIP入栈
27. "ret\n\t" //执行完这条指令，eip寄存器的值就执行了任务0的入口(即my_process)
28. "popl %%ebp\n\t" //正常情况下，是不会运行到这里的
29. :
30. :"c"(task[0].thread.eip),"d"(task[0].thread.esp)
31. :
32. );
33. }

/*每执行10000000次判断一下是否需要调度*/

1. void my_process(void)
2. {
3. int i=0;
4. while(1){
5. i++;
6. if(i%10000000==0){
7. i=0;
8. printk("this is process %ld -\n",my_current->pid);
9. if(my_need_schedule==1){
10. my_need_schedule=0;
11. my_schedule();
12. }
13. printk("this is process %ld +\n",my_current->pid);
14. }
15. }
16. }

myinterrupt.c:

1. #include<linux/kernel_stat.h>
2. #include<linux/export.h>
3. #include<linux/interrupt.h>
4. #include<linux/percpu.h>
5. #include<linux/init.h>
6. #include<linux/mm.h>
7. #include<linux/swap.h>
8. #include<linux/pid_namespace.h>
9. #include<linux/notifier.h>
10. #include<linux/thread_info.h>
11. #include<linux/time.h>
12. #include<linux/jiffies.h>
13. #include<linux/posix-timers.h>
14. #include<linux/cpu.h>
15. #include<linux/syscalls.h>
16. #include<linux/delay.h>
17. #include<linux/tick.h>
18. #include<linux/kallsyms.h>
19. #include<linux/irq_work.h>
20. #include<linux/sched.h>
21. #include<linux/sched/sysctl.h>
22. #include<linux/slab.h>
24. #include<asm/uaccess.h>
25. #include<asm/unistd.h>
26. #include<asm/div64.h>
27. #include<asm/timex.h>
28. #include<asm/io.h>
30. #define CREATE_TRACE_POINTS
31. #include<trace/events/timer.h>
32. #include"mypcb.h"
33. /*
34. * Called by timer interrupt.
35. */
36. volatileint time_counter=0;
37. externint my_need_schedule;
38. externPCB_t* my_current;
39. externPCB_t task[MAX_TASK_NUM];
41. /*这是时钟中断程序，用来更新进程的时间片*/
42. void my_timer_handler(void)
43. {
44. if((time_counter%1000==0)&&(my_need_schedule==0)){
45. my_need_schedule=1;
47. printk(">>>>time_hander here<<<<<\n");
48. }
49. time_counter++;
50. }
51. 

52. /*这是进程调度程序*/
53. void my_schedule(void)
54. {
55. PCB_t* next;
56. PCB_t* prev;
57. if(my_current==NULL|| my_current->next==NULL){
58. return;
59. }
60. printk(">>>here my_schedule<<<\n");
61. next= my_current->next;
62. prev= my_current;
63. if(next->state==0){ //如果进程不是首次调度的
64. asmvolatile(
65. "pushl %%ebp\n\t" //保存当前进程的内核栈
66. "movl %%esp,%1\n\t" //保存当前进程内核栈
67. "movl $1f,%0\n\t" //保存当前进程执行位置
68. "movl %3,%%esp\n\t" //恢复即将调度进程的内核栈
69. "pushl %2\n\t" //把即将调度进程的eip压栈
70. "ret\n\t" //把刚才压入的eip弹出到eip寄存器
71. "1:"
72. "popl %%ebp\n\t" //每次调度进程时都从这里开始执行
73. :"=m"(prev->thread.eip),"=m"(prev->thread.esp)
74. :"m"(next->thread.eip),"m"(next->thread.esp)
75. :
76. );
77. my_current= next;
78. printk("switch %ld to %ld\n",prev->pid,next->pid);
79. }
80. else //进程不是首次调度
81. {
82. next->state=0;
83. printk("switch %ld to %ld\n",prev->pid,next->pid);
84. asmvolatile(
85. "pushl %%ebp\n\t" //保存一下ebp
86. "movl %%esp,%1\n\t"//保存当前进程的内核栈
87. "movl $1f,%0\n\t"//保存当前进程执行位置
88. "movl %3,%%esp\n\t"//恢复即将调度进程的内核栈
89. "movl %3,%%ebp\n\t"
90. "pushl %2\n\t" //恢复执行环境
91. "ret\n\t"
92. "1:"
93. "popl %%ebp\n\t"
94. :"=m"(prev->thread.eip),"=m"(prev->thread.esp)
95. :"m"(next->thread.eip),"m"(next->thread.esp)
96. :
97. );
98. }
99. }
100. 总结：这段程序是对linux进程切换的模拟，进程切换总结起来就那么一句话,保存当前进程的上下文，恢复被调度进程的上下文，
101. 这里只是简单的用一个链表来连接各个进程，并没有涉及到调度算法。
102.