《Linux内核分析》之操作系统是如何工作的 实验总结

1
#define MAX_TASK_NUM 4
2
#define KERNEL_STACK_SIZE 1024*8
3
/*
4
*Thread用于存储eip和esp
5
*/
6
struct Thread{
7
        unsigned long ip;
8
        unsigned long sp;
9
};
10
typedef struct PCB{
11
        int pid;/*进程id*/
12
        volatile long state;/*进程状态 -1 unrunable,0 runable*/
13
        char stack[KERNEL_STACK_SIZE];/*进程的堆栈*/
14
        /*CPU -specific state of this task*/
15
        struct Thread thread;
16
        unsigned long task_entry;/*程序入口*/
17
        struct PCB *next;/*下一个进程*/
18

19
}tPCB;
20

21
void my_schedule(void);/*调度器*/

1
tPCB task[MAX_TASK_NUM];/*task数组*/
2
tPCB *my_current_task = NULL;/*当前task的指针*/
3
volatile int my_need_sched = 0;/*是否需要调度*/
4

5
void my_process(void);
6

7
void __init my_start_kernel(void)
8
{
9
        int pid =0;
10
        int i;
11
        /*Initialize process 0(初始化0号进程的数据结构)*/
12
        task[pid].pid = pid;
13
        task[pid].state = 0;/* -1 unrunable,0 runable，>0 stopped*/
14
        task[pid].task_entry = task[pid].thread.ip=(unsigned long)my_process;
15
        task[pid].thread.sp = (unsigned long)&task[pid].stack[KERNEL_STACK_SIZE-1];
16
        task[pid].next  = %task[pid];
17
        /*fork more process */
18
        for(i=1;i<MAX_TASK_NUM;i++)
19
        {
20
                memcpy(&task[i],&task[0],sizeof(tPCB));
21
                task[i].pid=i;
22
                task[i].state = -1;
23
                task[i].thread.sp = (unsigned long)&task[i].stack[KERNEL_STACK_SIZE-1];
24
                //将新创建的进程加入到之前进程列表的尾部
25
                task[i].next = task[i-1].next;
26
                task[i-1].next = &task[i];
27
        }
28
        /*start process 0 by task[0]*/
29
        pid = 0;
30
        my_current_task = &task[pid];
31
        asm volatile(
32
                "movl %1,%%espnt" /*set task[pid].thread.sp to esp */
33
                "pushl %1nt"      /*push ebp*/
34
                "pushl %0nt"      /*push task[pid].thread.ip*/
35
                "retnt"           /*pop task[pid].thread.ip to eip*/
36
                "popl %%ebpnt"
37
                :
38
                :"c"(task[pid].thread.ip),"d"(task[pid].thread.sp) /*input %ecx/%edx*/
39
        );
40

41
}
42
void my_process(void)
43
{
44
        int i = 0;
45
        while(1)
46
        {
47
                i++;
48
                if(i%10000000 ==0)
49
                {
50
                        printk(KERN_NOTICE "This is process %d -n",my_current_task->pid);
51
      if(my_need_sched == 1)
52
                        {
53
                                my_need_sched = 0;
54
                                my_schedule();
55
                         }
56
                        printk(KERN_NOTICE "This is process %d + n",my_current_task->pid);
57
                }
58
        }
59
}

1
{
2
        int i = 0;
3
        while(1)
4
        {
5
                i++;
6
                if(i%10000000 ==0)
7
                {
8
                        // 该进程停止运行
9
                        printk(KERN_NOTICE "This is process %d -n",my_current_task->pid);
10
      if(my_need_sched == 1)
11
                        {
12
                                my_need_sched = 0;
13
                                my_schedule();//进行调度
14
                         }
15
                        // 该进程继续运行
16
                        printk(KERN_NOTICE "This is process %d + n",my_current_task->pid);
17
                }
18
        }
19
}

1
extern tPCB task[MAX_TASK_NUM]/**/
2
extern tPCB *my_current_task;/**/
3
extern volatile int my_need_sched;/**/
4
volatile int time_count = 0;/*时间计数*/
5

6
/*
7
* Called by timer interrupy
8
* it runs in the name of current running process
9
* so it use kernel stack of current running process
10
*/
11
/*设置时间片的大小，时间片用完时设置一下调度标志*/
12
void my_timer_handler(void)
13
{
14
#if 1
15
        if(time_count%1000 == 0 && my_need_sched !=1)
16
        {
17
                printk(KERN_NOTICE ">>> my_timer_handler here <<<n");
18
                my_need_sched = 1;
19
        }
20
        time_count ++;
21
#endif
22
        return;
23
}
24

25
void my_schedule(void)
26
{
27
        tPCB *next;
28
        tPCB *prev;
29

30
        if(my_current_task == NULL || my_current_task->next == NULL)
31
        {
32
              return;
33
        }
34
        printk(KERN_NOTICE ">>> my_schedule here <<<n");
35
        /*schedule*/
36
        next = my_current_task->next;
37
        prev = my_current_task;
38

39
        if(next->state == 0)/* -1 unrunable,0 runable，>0 stopped*/
40
        {
41
                /*switch to next process */
42
                asm volatile(
43
                        "pushl %%ebpnt"      /*save ebp*/
44
                        "movl %%esp,%0nt"   /*save esp*/
45
                        "movl %2,%%espnt"   /*restore esp*/
46
                        "movl $1f,%1nt"     /*save eip*/  /*$1f是指接下来的标号1：的位置*/
47
                        "pushl %3nt"
48
                        "retnt"           /*restore eip*/
49
                        "1:t"             /*next process start here*/
50
                        "popl %%ebpnt"
51
                        : "=m"(prev->thread.sp),"=m"(prev->thread.ip)
52
                        : "m"(next->thread.sp),"m"(next->thread.ip)
53
                );
54
                my_current_task = next;
55
                printk(KERN_NOTICE ">>>switch %d to %d <<<n",prev->pid,next->pid);
56
        }
57
        else{
58
                next->state = 0;
59
                my_current_task = next;
60
                printk(KERN_NOTICE ">>>switch %d to %d <<<n",prev->pid,next->pid)
61
                /*switch to new process */
62
                asm volatile(
63
                        "pushl %%ebpnt"        /*save ebp*/
64
                        "movl %%esp,%0nt"     /*save esp*/
65
                        "movl %2,%%espnt"    /*restore esp*/
66
                        "movl %2,%%ebpnt"   /*restore ebp*/
67
                        "movl $1f,%1nt"    /*save eip*/
68
                        "pushl %3nt"
69
                        "retnt"           /*restore eip*/
70
                        : "=m"(prev->thread.sp),"=m"(prev->thread.ip)
71
                        : "m"(next->thread.sp),"m"(next->thread.ip)
72
                );
73
        }
74
        return;
75
}

1
if(next->state == 0)/* -1 unrunable,0 runable，>0 stopped*/
2
        {
3
                /*switch to next process */
4
                asm volatile(
5
                        "pushl %%ebpnt"      /*save ebp*/
6
                        "movl %%esp,%0nt"   /*save esp*/
7
                        "movl %2,%%espnt"   /*restore esp*/
8
                        "movl $1f,%1nt"     /*save eip*/  /*$1f是指接下来的标号1：的位置*/
9
                        "pushl %3nt"
10
                        "retnt"           /*restore eip*/
11
                        "1:t"             /*next process start here*/
12
                        "popl %%ebpnt"
13
                        : "=m"(prev->thread.sp),"=m"(prev->thread.ip)
14
                        : "m"(next->thread.sp),"m"(next->thread.ip)
15
                );
16
                my_current_task = next;
17
                printk(KERN_NOTICE ">>>switch %d to %d <<<n",prev->pid,next->pid);
18
        }

1
else{
2
                next->state = 0;
3
                my_current_task = next;
4
                printk(KERN_NOTICE ">>>switch %d to %d <<<n",prev->pid,next->pid)
5
                /*switch to new process */
6
                asm volatile(
7
                        "pushl %%ebpnt"        /*save ebp*/
8
                        "movl %%esp,%0nt"     /*save esp*/
9
                        "movl %2,%%espnt"    /*restore esp*/
10
                        "movl %2,%%ebpnt"   /*restore ebp*/
11
                        "movl $1f,%1nt"    /*save eip*/
12
                        "pushl %3nt"
13
                        "retnt"           /*restore eip*/
14
                        : "=m"(prev->thread.sp),"=m"(prev->thread.ip)
15
                        : "m"(next->thread.sp),"m"(next->thread.ip)
16
                );
17
        }