diff options
Diffstat (limited to 'kernel')
| -rw-r--r-- | kernel/interrupts.c | 5 | ||||
| -rw-r--r-- | kernel/kernel.c | 13 | ||||
| -rw-r--r-- | kernel/kernel.h | 2 | ||||
| -rw-r--r-- | kernel/scheduler.c | 182 | ||||
| -rw-r--r-- | kernel/scheduler.h | 15 | ||||
| -rw-r--r-- | kernel/syscalls.c | 73 | ||||
| -rw-r--r-- | kernel/syscalls.h | 1 | ||||
| -rw-r--r-- | kernel/vmem.c | 58 | ||||
| -rw-r--r-- | kernel/vmem.h | 1 |
9 files changed, 247 insertions, 103 deletions
diff --git a/kernel/interrupts.c b/kernel/interrupts.c index 5e67105..9e12555 100644 --- a/kernel/interrupts.c +++ b/kernel/interrupts.c @@ -56,7 +56,10 @@ uint32_t interrupt_handler(uint32_t esp, uint32_t irq) // mouse and kb if(irq==INTERRUPT_KEYBOARD || irq==INTERRUPT_MOUSE){ uint32_t in=x86_inb(0x60); - if(irq==INTERRUPT_KEYBOARD)keyboard_handle(in); // do this in separate thread! + if(irq==INTERRUPT_KEYBOARD){ + keyboard_handle(in); // do this in separate thread via syscalls? + task_wake_all(); + } // TODO: mouse // test ipi diff --git a/kernel/kernel.c b/kernel/kernel.c index cf9fef9..6f04454 100644 --- a/kernel/kernel.c +++ b/kernel/kernel.c @@ -12,6 +12,7 @@ #include "vmem.h" //-- clean below headers --// +#include "ext2.h" #include "apic.h" #include "kernel/scheduler.h" @@ -33,7 +34,6 @@ #include "driver/vesa.h" #include "asm_pit.h" - /* F00L 0S Entry point (called directly from asm/multiboot.asm */ void kernel_main(uint32_t eax,uint32_t ebx) { @@ -91,6 +91,10 @@ void kernel_main(uint32_t eax,uint32_t ebx) x86_set_page_directory(dir); x86_paging_enable(); + // -- EXT2 RAM IMAGE -- // + klog("Check ext2 ram image ... "); + ext2_dump_info(VMEM_EXT2_RAMIMAGE); + // -- APIC -- // klog("Advanced Programmable Interrupt Controller (APIC) config ..."); apic_init(&cfg_acpi); @@ -99,8 +103,11 @@ void kernel_main(uint32_t eax,uint32_t ebx) // -- VESA -- // fixme("tell terminal syscall somehow if we are vga or textmode"); klog("Video Electronics Standards Association (VESA) init ... "); // TODO check if text or fb? - uint32_t addr=kballoc(1); - fs_content("/binfont.bin",addr,0x100); // copy font (0x100 bytes) to memory. + + // binfont has to fit in ONE ext2 block // + fixme("support binfonts spanning multiple blocks?"); + uint32_t inode= ext2_filename_to_inode(VMEM_EXT2_RAMIMAGE,"/binfont.bin"); + uint32_t addr= ext2_inode_blockstart( VMEM_EXT2_RAMIMAGE,inode,0); vesa_init(cfg_multiboot->vbe_control_info,cfg_multiboot->vbe_mode_info,addr); // -- STDIN/STDOUT -- // diff --git a/kernel/kernel.h b/kernel/kernel.h index 3baef97..27798cf 100644 --- a/kernel/kernel.h +++ b/kernel/kernel.h @@ -54,6 +54,8 @@ REFERENCES #define VMEM_KERNEL_END 0x02000000 #define VMEM_USER_ENV 0x07000000 // ? pages / per user process + +#define VMEM_USER_PROG_PAGES 256 #define VMEM_USER_PROG 0x08048000 // ? pages / per user process (usual entry: 0x8048080) #define VMEM_USER_STACK_PAGES 4 // 4 pages / per thread diff --git a/kernel/scheduler.c b/kernel/scheduler.c index 541eb15..3b50259 100644 --- a/kernel/scheduler.c +++ b/kernel/scheduler.c @@ -19,13 +19,13 @@ #define NO_TASK 0xffffffff -static volatile uint32_t pid=1; +static volatile uint32_t pid=1000; -uint32_t nextPID() +static uint32_t nextPID() { spinlock_spin(SPINLOCK_PID); - uint32_t ret=pid; pid++; + uint32_t ret=pid; spinlock_release(SPINLOCK_PID); return ret; } @@ -37,7 +37,7 @@ static volatile uint32_t current_task[SMP_MAX_PROC]; static volatile struct task_list_struct { volatile bool active; // is this slot used (Y/N) - volatile uint32_t pid; // process id (TODO) + volatile uint32_t pid; // process id volatile uint32_t parent; // parent process id volatile uint32_t esp; // stack pointer of the task @@ -46,11 +46,14 @@ static volatile struct task_list_struct volatile uint32_t brk; // memory brk pos - volatile bool wait; // waiting for syscall to be processed. + volatile bool try; // waiting coz syscall not processed yet + volatile bool syscall; // syscall in progress volatile uint32_t eax; volatile uint32_t ebx; volatile uint32_t ecx; volatile uint32_t edx; + + volatile bool thread; // is this a light thread? }task_list[SMP_MAX_PROC][MAX_TASKS]; @@ -70,7 +73,8 @@ volatile void scheduler_init(uint32_t cpu, void *dir) task_list[cpu][0].parent=0; task_list[cpu][0].pid=nextPID(); task_list[cpu][0].active=true; - task_list[cpu][0].wait=false; + task_list[cpu][0].syscall=false; + task_list[cpu][0].thread=false; task_list[cpu][0].vmem=dir; task_list[cpu][0].esp = VMEM_CPU_STACK_TOP-0x200; task_list[cpu][0].esp0 = 0; // esp0 not needed by kernel space tasks @@ -81,7 +85,8 @@ volatile void scheduler_init(uint32_t cpu, void *dir) task_list[cpu][1].parent=0; task_list[cpu][1].pid=nextPID(); task_list[cpu][1].active=true; - task_list[cpu][1].wait=false; + task_list[cpu][0].thread=false; + task_list[cpu][1].syscall=false; task_list[cpu][1].vmem=dir; task_list[cpu][1].esp = kballoc(4)+4*4096-0x200; // 4 pages stack task_list[cpu][1].esp0 =kballoc(4)+4*4096; // esp0 not needed by kernel space tasks @@ -114,7 +119,7 @@ volatile uint32_t scheduler_run(uint32_t oldesp,uint32_t force_pid) { int idx=(current_task[cpu]+1+i)%MAX_TASKS; // schedule round robin style - if(task_list[cpu][idx].active && !task_list[cpu][idx].wait) // find active non-blocked task + if(task_list[cpu][idx].active && !task_list[cpu][idx].syscall) // find active non-blocked task { //TODO: do NOT do this! deadlock imminent! //if(cpu==0)klog("schedule %d->%d on cpu %d",current_task[cpu],idx,cpu ); @@ -136,13 +141,13 @@ void scheduler_func() uint32_t cpu=smp_get(SMP_APIC_ID); - if(task_get_current_pid()==0) + if(current_task[cpu]==0) while(1) { task_syscall_worker(); } - if(task_get_current_pid()==1) + if(current_task[cpu]==1) while(1) { @@ -150,38 +155,36 @@ void scheduler_func() { uint32_t alloc; uint32_t entry_global=load_elf(BIN_INIT,&alloc); - task_set_brk(alloc); + task_set_brk(task_get_current_pid(),alloc); asm_usermode(entry_global); while(1); } } } -volatile int task_reset(uint32_t pid, uint32_t entry, uint32_t stack) +volatile int add_task(uint32_t parent_pid,uint32_t vmem, bool thread) { + uint32_t parent=task_runs(parent_pid); uint32_t cpu=smp_get(SMP_APIC_ID); - uint32_t *stk=task_list[cpu][pid].esp; - stk[14]=entry; - stk[17]=stack; - return 1; -} -volatile int add_task(uint32_t parent,uint32_t vmem) -{ - uint32_t cpu=smp_get(SMP_APIC_ID); for(int i=0;i<MAX_TASKS;i++) { - if(task_list[cpu][i].active!=true) + if(task_list[cpu][i].active!=true) // find a free slot. { task_list[cpu][i].pid=nextPID(); + task_list[cpu][i].parent=parent_pid; + task_list[cpu][i].thread=thread; - task_list[cpu][i].parent=task_list[cpu][parent].pid; task_list[cpu][i].vmem=vmem; - task_list[cpu][i].esp = kballoc(4)+2*4096; // center + task_list[cpu][i].esp = kballoc(4)+2*4096; // center task_list[cpu][i].esp0 = kballoc(4)+4*4096; - task_list[cpu][i].wait=false; - task_list[cpu][i].brk=task_list[cpu][current_task[cpu]].brk; + + task_list[cpu][i].active=true; //TODO: LOCK! (also other similar) + task_list[cpu][i].syscall=false; + task_list[cpu][i].try=false; + + task_list[cpu][i].brk=task_list[cpu][parent].brk; uint32_t *source=(uint32_t *)task_list[cpu][parent].esp; uint32_t *dst=(uint32_t *)task_list[cpu][i].esp; @@ -197,13 +200,22 @@ volatile int add_task(uint32_t parent,uint32_t vmem) stack[12]=0x1; stack[13]=0; // this task returns pid=0 to the caller - task_list[cpu][i].active=true; //TODO: LOCK! (also other similar) - return i; + return task_list[cpu][i].pid; } } kpanic("out of task slots!"); } +void task_wake_all() +{ + uint32_t cpu=smp_get(SMP_APIC_ID); + // simple approach, any syscall might unblock any other syscall // TODO: better! TODO: all cpus! + for(int i=0;i<MAX_TASKS;i++) + { + task_list[cpu][i].try=true; + } +} + /** * kernel space worker thread @@ -211,40 +223,49 @@ volatile int add_task(uint32_t parent,uint32_t vmem) * we can get interrupted by an interrupt ANYTIME! * */ - void task_syscall_worker() { + /// TODO: cross check all cpus! uint32_t cpu=smp_get(SMP_APIC_ID); + while(1) { - bool nowork=true; for(int i=0;i<MAX_TASKS;i++) { - if(task_list[cpu][i].wait) + if(task_list[cpu][i].active,task_list[cpu][i].try&&task_list[cpu][i].syscall) { + uint32_t syscall=task_list[cpu][i].eax; - klog("task %d waiting on syscall %d/%s. processing...",i,syscall,syscall_get_name(syscall)); + klog("task pid=%d waiting on syscall %d/%s on cpu %d slot %d.",task_list[cpu][i].pid,syscall,syscall_get_name(syscall),cpu,i); + task_list[cpu][0].vmem=task_list[cpu][i].vmem; // switch syscall worker to pagedir of calling userprog x86_set_page_directory(task_list[cpu][0].vmem); - nowork=false; - - uint32_t ret = syscall_generic(task_list[cpu][i].eax, + uint32_t ok = syscall_generic_test(task_list[cpu][i].eax, task_list[cpu][i].edx, task_list[cpu][i].ecx, task_list[cpu][i].ebx, - i); + task_list[cpu][i].pid); - if(task_list[cpu][i].eax==SYSCALL_WAIT) + if(!ok) { + task_list[cpu][i].try=false; continue; } + uint32_t ret = syscall_generic(task_list[cpu][i].eax, + task_list[cpu][i].edx, + task_list[cpu][i].ecx, + task_list[cpu][i].ebx, + task_list[cpu][i].pid); + + task_wake_all(); + uint32_t *stack=task_list[cpu][i].esp; stack[12]=0x1; stack[13]=ret; - task_list[cpu][i].wait=false; + task_list[cpu][i].syscall=false; } } @@ -254,48 +275,109 @@ void task_syscall_worker() } } - volatile uint32_t task_syscall(uint32_t eax,uint32_t ebx, uint32_t ecx, uint32_t edx) { uint32_t cpu=smp_get(SMP_APIC_ID); - task_list[cpu][current_task[cpu]].wait=true; + task_list[cpu][current_task[cpu]].syscall=true; + task_list[cpu][current_task[cpu]].try=true; task_list[cpu][current_task[cpu]].eax=eax; task_list[cpu][current_task[cpu]].ebx=ebx; task_list[cpu][current_task[cpu]].ecx=ecx; task_list[cpu][current_task[cpu]].edx=edx; - task_list[cpu][0].wait=false; return 1; } volatile uint32_t task_fork(uint32_t pid) { + uint32_t idx=task_runs(pid); uint32_t cpu=smp_get(SMP_APIC_ID); - int ret=add_task(pid,vmem_new_space_dir(task_list[cpu][pid].vmem,false)); - klog("[%d] forked -> [%d] (free blocks remaining: %d )", pid, ret,0); + int ret=add_task(pid,vmem_new_space_dir(task_list[cpu][idx].vmem,false),false); + klog("[%d] forked -> [%d]", pid, ret); return ret; } + volatile uint32_t task_clone(uint32_t pid) { + uint32_t idx=task_runs(pid); uint32_t cpu=smp_get(SMP_APIC_ID); - int ret=add_task(pid,vmem_new_space_dir(task_list[cpu][pid].vmem,true)); - klog("[%d] cloned -> [%d] (free blocks remaining: %d )", pid, ret,0); + int ret=add_task(pid,vmem_new_space_dir(task_list[cpu][idx].vmem,true),true); + klog("[%d] cloned -> [%d]", pid, ret); return ret; } -volatile int task_get_current_pid() +volatile uint32_t task_get_brk(uint32_t pid) { uint32_t cpu=smp_get(SMP_APIC_ID); - return current_task[cpu]; + uint32_t idx=task_idx(pid); + return task_list[cpu][idx].brk; } -volatile uint32_t task_get_brk() +volatile void task_set_brk(uint32_t pid, uint32_t brk) { uint32_t cpu=smp_get(SMP_APIC_ID); - return task_list[cpu][current_task[cpu]].brk; + uint32_t idx=task_idx(pid); + task_list[cpu][idx].brk=brk; } -volatile void task_set_brk(uint32_t brk) +volatile uint32_t task_get_current_pid() { uint32_t cpu=smp_get(SMP_APIC_ID); - task_list[cpu][current_task[cpu]].brk=brk; + return task_list[cpu][current_task[cpu]].pid; +} + +volatile uint32_t task_get_parent(uint32_t pid) +{ + uint32_t idx=task_idx(pid); + uint32_t cpu=smp_get(SMP_APIC_ID); + return task_list[cpu][idx].parent; +} + +volatile int task_reset(uint32_t pid, uint32_t entry, uint32_t stack,uint32_t brk) +{ + uint32_t cpu=smp_get(SMP_APIC_ID); + uint32_t idx=task_idx(pid); + uint32_t *stk=task_list[cpu][idx].esp; + task_list[cpu][idx].brk=brk; + + stk[14]=entry; + stk[17]=stack; + return 1; +} + +uint32_t task_idx(uint32_t pid) +{ + uint32_t cpu=smp_get(SMP_APIC_ID); + + for(int i=0;i<MAX_TASKS;i++) + { + if(task_list[cpu][i].pid==pid)return i; + } + + return 0; +} + +uint32_t task_runs(uint32_t pid) +{ + uint32_t cpu=smp_get(SMP_APIC_ID); + + for(int i=0;i<MAX_TASKS;i++) + { + if(task_list[cpu][i].active==true&& task_list[cpu][i].pid==pid)return i; + } + + return 0; +} + +void task_exit(uint32_t pid) +{ + uint32_t cpu=smp_get(SMP_APIC_ID); + uint32_t idx=task_runs(pid); + + for(int i=0;i<MAX_TASKS;i++) + { + if(task_list[cpu][i].active==true&& task_list[cpu][i].pid==pid) + task_list[cpu][i].active=false; + } + + vmem_free_space_dir(task_list[cpu][idx].vmem,false); } diff --git a/kernel/scheduler.h b/kernel/scheduler.h index 18002da..f77912d 100644 --- a/kernel/scheduler.h +++ b/kernel/scheduler.h @@ -1,15 +1,20 @@ #include <stdint.h> +#include <stdbool.h> // http://hosted.cjmovie.net/TutMultitask.htm volatile uint32_t scheduler_run(uint32_t oldesp,uint32_t force_pid); -volatile int task_get_current_pid(); -volatile void task_set_brk(uint32_t brk); +void task_wake_all(); +volatile uint32_t task_get_current_pid(); +volatile uint32_t task_get_parent(uint32_t pid); +volatile void task_set_brk(uint32_t pid,uint32_t brk); void task_syscall_worker(); -volatile uint32_t task_get_brk(); -volatile uint32_t task_exit(uint32_t pid); +volatile uint32_t task_get_brk(uint32_t pid); volatile uint32_t task_fork(uint32_t pid); volatile uint32_t task_clone(uint32_t pid); volatile uint32_t task_wait(uint32_t pid); -volatile int task_reset(uint32_t pid, uint32_t entry, uint32_t stack); +volatile int task_reset(uint32_t pid, uint32_t entry, uint32_t stack, uint32_t brk); volatile uint32_t task_syscall(uint32_t eax,uint32_t ebx, uint32_t ecx, uint32_t edx); +uint32_t task_runs(uint32_t pid); +uint32_t task_idx(uint32_t pid); +void task_exit(uint32_t pid); diff --git a/kernel/syscalls.c b/kernel/syscalls.c index 6707ec3..3fb813e 100644 --- a/kernel/syscalls.c +++ b/kernel/syscalls.c @@ -17,7 +17,6 @@ #include "scheduler.h" #include "log.h" - // TODO: use includes!!! uint64_t timer_get_ms(); @@ -134,20 +133,19 @@ int syscall_write(int file, char *buf, int len) */ int syscall_read(int file, char *buf, int len) { - //file 0 = stdin , file 1 = stdout , file 2 = stderr - char c; - int l=0; - - c=fd_read(&fds[file]); - fifo_data_len[file]--; - *buf=c; - buf++; - l++; - - return l; - if(l==len)return l; - if(c=='\n')return l; - + //file 0 = stdin , file 1 = stdout , file 2 = stderr + char c; + int l=0; + + c=fd_read(&fds[file]); + fifo_data_len[file]--; + *buf=c; + buf++; + l++; + + return l; + if(l==len)return l; + if(c=='\n')return l; } //TODO: replace with dirent! @@ -217,7 +215,6 @@ int copy_args(char **in, char **out) int syscall_execve(char *name, char **argv, char **env,int pid) { - //TODO copy environment to target pages somehow// int arg_count=0; while(argv[arg_count]!=NULL)arg_count++; @@ -225,26 +222,23 @@ int syscall_execve(char *name, char **argv, char **env,int pid) char **argv1=VMEM_USER_ENV; if(argv!=NULL) { -// copy_args(argv,argv1); + copy_args(argv,argv1); } - else{ argv1=NULL; } - char **env1=VMEM_USER_ENV+1024; + char **env1=VMEM_USER_ENV+1024*2; if(env!=NULL) { -// copy_args(env,env1); + copy_args(env,env1); } - else{ env1=NULL; } uint32_t alloc; uint32_t entry_global=load_elf(name,&alloc); - task_set_brk(alloc); if(!entry_global) { @@ -255,7 +249,7 @@ int syscall_execve(char *name, char **argv, char **env,int pid) *++stack=argv1; *++stack=arg_count; *++stack=env1; - task_reset(pid,entry_global,stack); + task_reset(pid,entry_global,stack,alloc); return 0; /* try to move this to asm */ @@ -341,13 +335,13 @@ uint32_t syscall_clone(int pid) uint32_t syscall_wait(int pid) { - fixme("implement syscall_wait"); return 0; } uint32_t syscall_exit(int pid) { fixme("free allll mem"); + task_exit(pid); return 0; } @@ -368,20 +362,15 @@ int syscall_isatty(int file,int none1,int none2) return 1; } -uint32_t fuckalloc=0x8500000; // TODO: per process basis! -uint32_t syscall_sbrk(uint32_t incr, int none1, int none2) +uint32_t syscall_sbrk(uint32_t incr, int none1, int none2, uint32_t pid) { - fixme("fake syscall_sbrk! 0x%08X",incr); - uint32_t alloc=task_get_brk(); - - uint32_t oldalloc=fuckalloc; - fuckalloc+=incr; - - task_set_brk(alloc); - - + uint32_t alloc=task_get_brk(pid); + uint32_t oldalloc=alloc; + alloc+=incr; + task_set_brk(pid,alloc); + fixme("fake syscall_sbrk(0x%08X) return %08X",incr,oldalloc); return oldalloc; } @@ -394,6 +383,18 @@ int syscall_stat(const char *path, struct stat *st,int none) /// there also is task_fork, task_wait, task_exit.. which is in scheduler.c //////////////////////////////////////// +uint32_t syscall_generic_test(uint32_t nr,uint32_t p1, uint32_t p2, uint32_t p3, uint32_t pid) +{ + switch(nr){ + case SYSCALL_WAIT : + return !task_runs(p1); + case SYSCALL_READ : + return p3 <= fifo_data_len[p1]; + case SYSCALL_EXIT : + return 1; + } + return 1; +} uint32_t syscall_generic(uint32_t nr,uint32_t p1, uint32_t p2, uint32_t p3, uint32_t pid) { @@ -423,7 +424,7 @@ uint32_t syscall_generic(uint32_t nr,uint32_t p1, uint32_t p2, uint32_t p3, uint case SYSCALL_READ : return syscall_read(p1,p2,p3); case SYSCALL_SBRK : - return syscall_sbrk(p1,p2,p3); + return syscall_sbrk(p1,p2,p3,pid); case SYSCALL_STAT : return syscall_stat(p1,p2,p3); case SYSCALL_FSTAT : diff --git a/kernel/syscalls.h b/kernel/syscalls.h index b31d32c..b736519 100644 --- a/kernel/syscalls.h +++ b/kernel/syscalls.h @@ -27,6 +27,7 @@ char* syscall_get_name(uint32_t num); uint32_t syscall_generic(uint32_t nr,uint32_t p1, uint32_t p2, uint32_t p3, uint32_t pid); +uint32_t syscall_generic_test(uint32_t nr,uint32_t p1, uint32_t p2, uint32_t p3, uint32_t pid); int syscall_open(char *name, int flags, int mode); int syscall_write(int file, char *buf, int len); diff --git a/kernel/vmem.c b/kernel/vmem.c index 4faf93e..129ddb5 100644 --- a/kernel/vmem.c +++ b/kernel/vmem.c @@ -305,14 +305,46 @@ pdirectory* vmem_kernel_dir() vmem_add_alloc(dir,VMEM_CPU_PRIVATE,4,false); vmem_add_alloc(dir,VMEM_CPU_STACK_TOP-4096*VMEM_CPU_STACK_PAGES,VMEM_CPU_STACK_PAGES,false); - vmem_add_alloc(dir,VMEM_USER_PROG,1024*2,true); - vmem_add_alloc(dir,VMEM_USER_ENV,2,true); - vmem_add_alloc(dir,VMEM_USER_NEWLIB,2,true); + vmem_add_alloc(dir,VMEM_USER_PROG,VMEM_USER_PROG_PAGES,true); + vmem_add_alloc(dir,VMEM_USER_ENV,1,true); + vmem_add_alloc(dir,VMEM_USER_NEWLIB,1,true); vmem_add_alloc(dir,VMEM_USER_STACK_TOP-4096*VMEM_USER_STACK_PAGES,VMEM_USER_STACK_PAGES,true); return dir; } +void vmem_free_space_dir(pdirectory *dir,bool stack_only) +{ + fixme("free kmalloc too!"); + fixme("stack_only version too!"); + + //free user pages + uint32_t virt=0; + for(int i=0;i<1024;i++) + { + uint32_t src_pt=dir->m_entries [i]; + + if(pt_entry_is_user(src_pt)) + { + ptable *src_table=pt_entry_get_frame(&src_pt); + + for(int j=0;j<1024;j++) + { + uint32_t src_pd=src_table->m_entries[j]; + uint32_t src_phys=pd_entry_get_frame(&src_pd); + + if(src_pd) + { + mem_free_block(src_phys); + } + virt+=4096; + } + } + else virt+=4096*1024; + } + +} + pdirectory* vmem_new_space_dir(pdirectory *copy_dir,bool stack_only) { pdirectory* dir = vmem_clean_dir(); //let's start with a fresh page directory @@ -324,14 +356,25 @@ pdirectory* vmem_new_space_dir(pdirectory *copy_dir,bool stack_only) if(!pt_entry_is_user(src_pt))dir->m_entries [i]=src_pt; } - vmem_add_alloc(dir,VMEM_USER_PROG,1024*4,true); - vmem_add_alloc(dir,VMEM_USER_ENV,2,true); - vmem_add_alloc(dir,VMEM_USER_NEWLIB,2,true); + // threads share this // + if(stack_only) + { + // TODO + kpanic("not impl!"); + } + else + { + vmem_add_alloc(dir,VMEM_USER_PROG,VMEM_USER_PROG_PAGES,true); + vmem_add_alloc(dir,VMEM_USER_ENV,1,true); + } + + // threads need own // + vmem_add_alloc(dir,VMEM_USER_NEWLIB,1,true); vmem_add_alloc(dir,VMEM_USER_STACK_TOP-4096*VMEM_USER_STACK_PAGES,VMEM_USER_STACK_PAGES,true); pdirectory* mydir=x86_get_page_directory(); - //copy user pages (TODO: stack only version for cloning!) + //copy user pages uint32_t virt=0; for(int i=0;i<1024;i++) { @@ -383,6 +426,5 @@ void vmem_init(multiboot_information *cfg_multiboot, acpi_information *cfg_acpi) multiboot_mod *mod=(multiboot_mod *)cfg_multiboot->mods_addr; mod_start=mod->mod_start; mod_end=mod->mod_end; - } diff --git a/kernel/vmem.h b/kernel/vmem.h index 767d7c5..c85d36b 100644 --- a/kernel/vmem.h +++ b/kernel/vmem.h @@ -56,5 +56,6 @@ struct pdirectory_struct; void vmem_init(multiboot_information *cfg_multiboot, acpi_information *cfg_acpi); void vmem_free_dir(struct pdirectory_struct *dir); struct pdirectory_struct* vmem_new_space_dir(struct pdirectory_struct *copy_dir,bool stack_only); +void vmem_free_space_dir(struct pdirectory_struct *dir,bool stack_only); struct pdirectory_struct* vmem_kernel_dir(); |