#ifndef __KERN_PROCESS_PROC_H__ #define __KERN_PROCESS_PROC_H__ #include <defs.h> #include <list.h> #include <trap.h> #include <memlayout.h> #include <skew_heap.h> // process's state in his life cycle enum proc_state { PROC_UNINIT = 0, // uninitialized PROC_SLEEPING, // sleeping PROC_RUNNABLE, // runnable(maybe running) PROC_ZOMBIE, // almost dead, and wait parent proc to reclaim his resource }; // Saved registers for kernel context switches. // Don't need to save all the %fs etc. segment registers, // because they are constant across kernel contexts. // Save all the regular registers so we don't need to care // which are caller save, but not the return register %eax. // (Not saving %eax just simplifies the switching code.) // The layout of context must match code in switch.S. struct context { uint32_t eip; uint32_t esp; uint32_t ebx; uint32_t ecx; uint32_t edx; uint32_t esi; uint32_t edi; uint32_t ebp; }; #define PROC_NAME_LEN 50 #define MAX_PROCESS 4096 #define MAX_PID (MAX_PROCESS * 2) extern list_entry_t proc_list; struct inode; struct fs_struct; struct proc_struct { enum proc_state state; // Process state int pid; // Process ID int runs; // the running times of Proces uintptr_t kstack; // Process kernel stack volatile bool need_resched; // bool value: need to be rescheduled to release CPU? struct proc_struct *parent; // the parent process struct mm_struct *mm; // Process's memory management field struct context context; // Switch here to run process struct trapframe *tf; // Trap frame for current interrupt uintptr_t cr3; // CR3 register: the base addr of Page Directroy Table(PDT) uint32_t flags; // Process flag char name[PROC_NAME_LEN + 1]; // Process name list_entry_t list_link; // Process link list list_entry_t hash_link; // Process hash list int exit_code; // exit code (be sent to parent proc) uint32_t wait_state; // waiting state struct proc_struct *cptr, *yptr, *optr; // relations between processes struct run_queue *rq; // running queue contains Process list_entry_t run_link; // the entry linked in run queue int time_slice; // time slice for occupying the CPU skew_heap_entry_t lab6_run_pool; // FOR LAB6 ONLY: the entry in the run pool uint32_t lab6_stride; // FOR LAB6 ONLY: the current stride of the process uint32_t lab6_priority; // FOR LAB6 ONLY: the priority of process, set by lab6_set_priority(uint32_t) struct files_struct *filesp; // the file related info(pwd, files_count, files_array, fs_semaphore) of process }; #define PF_EXITING 0x00000001 // getting shutdown #define WT_INTERRUPTED 0x80000000 // the wait state could be interrupted #define WT_CHILD (0x00000001 | WT_INTERRUPTED) // wait child process #define WT_KSEM 0x00000100 // wait kernel semaphore #define WT_TIMER (0x00000002 | WT_INTERRUPTED) // wait timer #define WT_KBD (0x00000004 | WT_INTERRUPTED) // wait the input of keyboard #define le2proc(le, member) \ to_struct((le), struct proc_struct, member) extern struct proc_struct *idleproc, *initproc, *current; void proc_init(void); void proc_run(struct proc_struct *proc); int kernel_thread(int (*fn)(void *), void *arg, uint32_t clone_flags); char *set_proc_name(struct proc_struct *proc, const char *name); char *get_proc_name(struct proc_struct *proc); void cpu_idle(void) __attribute__((noreturn)); struct proc_struct *find_proc(int pid); int do_fork(uint32_t clone_flags, uintptr_t stack, struct trapframe *tf); int do_exit(int error_code); int do_yield(void); int do_execve(const char *name, int argc, const char **argv); int do_wait(int pid, int *code_store); int do_kill(int pid); //FOR LAB6, set the process's priority (bigger value will get more CPU time) void lab6_set_priority(uint32_t priority); int do_sleep(unsigned int time); #endif /* !__KERN_PROCESS_PROC_H__ */