include/proc.h

Code:

1. /*  
2.     By Marcus Xing  
3.     include/proc.h  
4.     与进程有关的头文件  
5. */  
6.   
7. /*  
8.     forward include:  
9.     type.h  
10.     protect.h  
11.     ipc.h  
12. */  
13.   
14. #ifndef _PROC_H_   
15. #define _PROC_H_   
16.   
17.     #define MAX_PROC            50          /* 进程的最大个数         */   
18.     #define STACK_A             1024        /* 进程A的堆栈大小        */   
19.     #define STACK_B             1024        /* 进程B的堆栈大小        */   
20.     #define STACK_C             1024        /* 进程C的堆栈大小        */   
21.     #define STACK_PROC_TTY      1024        /* 终端进程的堆栈大小     */   
22.     #define STACK_PROC_SR       1024        /* 收发消息进程的堆栈大小 */   
23.        
24.     /* 所有进程的堆栈大小 */  
25.     #define ALL_PROC_STACK_SPACE    (             /   
26.                                         STACK_A + /   
27.                                         STACK_B + /   
28.                                         STACK_C + /   
29.                                         STACK_PROC_TTY + /   
30.                                         STACK_PROC_SR /   
31.                                     )   
32.        
33.     /* PCB中的栈结构 */  
34.     typedef struct s_stack_frame   
35.     {   
36.         u32 fs;   
37.         u32 gs;   
38.         u32 es;   
39.         u32 ds;   
40.         u32 edi;   
41.         u32 esi;   
42.         u32 ebp;   
43.         u32 dummy_esp;   
44.         u32 ebx;   
45.         u32 edx;   
46.         u32 ecx;   
47.         u32 eax;   
48.         u32 save_ret_addr;                  /* 中断程序中的SAVE函数的返回地址 */  
49.         u32 eip;   
50.         u32 cs;   
51.         u32 eflags;   
52.         u32 esp;   
53.         u32 ss;   
54.     }Stack_Frame;   
55.        
56.     /* PCB结构 */  
57.     typedef struct s_pcb   
58.     {   
59.         Stack_Frame stack_frame;            /* 栈结构 */  
60.         u16 LDT_Selector;                   /* 此进程在GDT的LDT选择子 */  
61.         Descriptor  LDT[2];                 /* 此进程的LDT，有2个成员 */  
62.         u32 proc_id;                        /* 此进程的进程号 */  
63.         char    proc_name[16];              /* 此进程的名字，容纳15个字符 */  
64.            
65.         /* 以下两项用于进程调度 */  
66.         int ticks;                          /* 每个进程当前的ticks值，初始化为priority */  
67.         int priority;                       /* 每个进程的初始ticks值 */  
68.            
69.         int bind_tty;                       /* 每个进程绑定的TTY */  
70.            
71.         /* 以下与IPC有关 */  
72.         int ipc_status;                     /* 此进程是否被阻塞，阻塞中的进程不能被调度 */  
73.         struct Message *p_message;          /* MSG指针，如果进程发送或接受时没进程响应，则此指针被赋值 */  
74.         int send_to;                        /* 如果发送了消息却没进程接收，则对此位赋值*/  
75.         int receive_from;                   /* 如果接受了消息却没进程发送，则对此位赋值 */  
76.            
77.         /* 如果发送了消息却没进程接收，则把发送消息的进程的PCB指针赋给接收进程的此字段上 */  
78.         struct PCB *sending_queue_first;                       
79.         /*   
80.             此字段是发送队列的链表的next指针，如果按时间顺序A,B,C进程先后给D进程发送了消息  
81.             则D进程的sending_queue_first字段是A进程的PCB指针，而A进程的PCB的sending_queue_next  
82.             字段是进程B的PCB指针，以此类推，最后一个进程也就是C进程的sending_queue_next字段为0  
83.         */  
84.         struct PCB *sending_queue_next;   
85.     }PCB;   
86.   
87.     /* TSS的结构 */  
88.     typedef struct s_tss   
89.     {   
90.         u32 backlink;   
91.         u32 esp0;   
92.         u32 ss0;   
93.         u32 esp1;   
94.         u32 ss1;   
95.         u32 esp2;   
96.         u32 ss2;   
97.         u32 cr3;   
98.         u32 eip;   
99.         u32 flags;   
100.         u32 eax;   
101.         u32 ecx;   
102.         u32 edx;   
103.         u32 ebx;   
104.         u32 esp;   
105.         u32 ebp;   
106.         u32 esi;   
107.         u32 edi;   
108.         u32 es;   
109.         u32 cs;   
110.         u32 ss;   
111.         u32 ds;   
112.         u32 fs;   
113.         u32 gs;   
114.         u32 ldt;   
115.         u16 trap;   
116.         u16 iobase;     /* I/O位图基址大于或等于TSS段界限，就表示没有I/O许可位图 */  
117.     }TSS;   
118.        
119.     /* 各进程的与众不同的部分结构，便于添加一个新的进程 */  
120.     typedef struct s_proc_unique   
121.     {   
122.         u32 proc_exec_addr;     /* 进程执行体的地址 */  
123.         u32 proc_stack_size;    /* 进程的私有堆栈的字节大小 */  
124.         char    proc_name[16];  /* 进程的名字 */  
125.     }Proc_Unique;   
126.   
127. #endif