josh/hos
1
0 Fork 0
Code Issues 1 Pull Requests Projects Releases Wiki Activity

Import backup from 2005-08-25

Browse Source
This commit is contained in:
josh committed 2017-07-25 22:23:50 -04:00
1 parent 345ef6c9f3
commit 83a5b032f8
15 files changed
+244 -92
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

kernel/proc/proc.c
+67 -24
View File
@@ -11,52 +11,77 @@ extern int mm_freepages;
#include "mm/vmm.h"
#include "lang/lang.h"
#include "kernel.h"
#include "functions.h" //halt()
extern u32_t idle_loop;
u32_t cur_task = 0;
u32_t n_processes = 0;
process_t *processes[3];
tss_t tss0;
u32_t proc_new_esp;
u32_t proc_new_ss;
int proc_init()
{
/* initialize tss0 */
memset(&tss0, 0, sizeof(tss_t));
tss0.ss0 = SEG_KERNEL_DATA;
tss0.esp0 = VIRT_STACK_TOP;
/* tss0.pdbr = read_cr3();
tss0.eip = &idle_loop;
tss0.eflags = 0x0202;
tss0.esp = VIRT_STACK_TOP-32; // idle_loop won't use -- a good thing
tss0.es = tss0.ds = tss0.fs = tss0.gs = tss0.ss = SEG_KERNEL_DATA;
tss0.cs = SEG_KERNEL_CODE; */
processes[0] = New(process_t);
processes[0]->p_page_dir = read_cr3();
processes[0]->page_dir = (void *)0xFFFFF000;
return 0;
}
void proc_sched(int_stack_t *stack_frame)
void proc_sched(int_stack_t *int_stack)
{
cur_task = (cur_task + 1) & 1;
write_cr3(processes[cur_task]
processes[cur_task]->esp = (u32_t) int_stack;
processes[cur_task]->ss = read_ss();
cur_task = (cur_task + 1) % 3;
proc_new_esp = processes[cur_task]->esp;
proc_new_ss = processes[cur_task]->ss;
write_cr3(processes[cur_task]->p_page_dir);
}
u32_t create_task(void *base, u32_t image_size, u32_t bss_size, void *entry);
u32_t create_task(void *base, u32_t image_size, u32_t bss_size, void *entry)
{
process_t *proc = create_process(vase, image_size, bss_size, entry);
processes[n_processes] = proc;
return n_processes++;
processes[++n_processes] = create_process(base, image_size, bss_size, entry);
return n_processes;
}
process_t *create_process(void *base, u32_t image_size, u32_t bss_size, void *entry);
/* Create process_t struct for a new process
* image_size should be a multiple of 4096
*/
process_t *create_process(void *base, u32_t image_size, u32_t bss_size, void *entry)
{
if (mm_freepages < pages + bsspages + 25)
if (mm_freepages < ((image_size + bss_size) >> 12) + 25)
return 0;
process_t *process = New(process_t); /* Allocate process_t struct */
create_address_space(process);
create_process_stack(process);
create_process_stack(process, entry);
int i;
u32_t *ptr32 = process->v_page_dir = vmm_palloc();
for (i = 0; i < 1024; i++)
*ptr32++ = 0;
u32_t code_data_pages = (image_size >> 12) +
((image_size & 0x3FF) ? 1 : 0);
u32_t bss_pages = (bss_size >> 12) + ((bss_size & 0x3FF) ? 1 : 0);
u32_t code_data_pages = (image_size + 4095) >> 12;
u32_t bss_pages = (bss_size + 4095) >> 12;
/* Load program at address 0 */
copy_into_address_space(0, base, code_data_pages, process);
zero_address_space(code_data_pages << 12, bss_pages, process);
ptr32 = process->v_page_dir;
for (i = 0; i < 1024; i++)
if (*ptr32)
vmm_unmapp(*ptr32);
vmm_unmapp((void *)*ptr32);
vmm_unmapp(process->v_page_dir);
process->v_page_dir = 0;
process->size = image_size + bss_size;
return process;
}
@@ -68,23 +93,41 @@ void create_address_space(process_t *p)
u32_t *ptr32 = p->page_dir;
for (i = 0; i < 768; i++) /* zero 3 gigs */
*ptr32++ = 0;
memcpyd(ptr32, (void *)0xFFFFF000, 256); /* 1 gig kernel mem */
memcpyd(ptr32, (void *)0xFFFFFC00, 256); /* 1 gig kernel mem */
}
void create_process_stack(process_t *p)
void create_process_stack(process_t *p, void *entry)
{
u32_t p_stack_table, p_stack;
u32_t *v_stack_table = vmm_palloc_addr(&p_stack_table);
void *v_stack = vmm_palloc_addr(&p_stack);
u32_t *v_stack = vmm_palloc_addr(&p_stack);
int i;
u32_t *ptr32 = v_stack_table;
for (int i = 0; i < 1023; i++)
for (i = 0; i < 1023; i++)
*ptr32++ = 0;
v_stack_table[1032] = p_stack | 0x7; /* user permissions */
p->page_dir[511] = p_stack_table | 0x7;
p->page_dir[511] = p_stack_table | 0x7; /* stack at 2GB */
i = 1023; /* top of stack */
v_stack[i--] = 0x20000000;
v_stack[i--] = SEG_USER_DATA | 0x3;
v_stack[i--] = 0x0202;
v_stack[i--] = SEG_USER_CODE | 0x3;
v_stack[i--] = (u32_t) entry;
v_stack[i--] = 0;
v_stack[i--] = 0;
v_stack[i--] = 0;
v_stack[i--] = 0;
v_stack[i--] = 0;
v_stack[i--] = 0;
v_stack[i--] = 0;
v_stack[i--] = SEG_USER_DATA | 0x3;
v_stack[i--] = SEG_USER_DATA | 0x3;
v_stack[i--] = SEG_USER_DATA | 0x3;
v_stack[i--] = SEG_USER_DATA | 0x3;
vmm_unmapp(v_stack_table);
vmm_unmapp(v_stack);
p->esp = 0x80000000; /* Stack at 2GB */
p->ss = SEG_USER_DATA | 0x3;
p->esp = 0x20000000 - sizeof(int_stack_t);
}
/* Copy pages into new address space (v_page_dir must be set up) */
@@ -103,9 +146,9 @@ void copy_into_address_space(u32_t dest_addr,
if (!p->v_page_dir[pde])
{
/* Time for a new page table & page directory entry! */
p->v_page_dir[pde] = vmm_palloc_addr(&p_page_addr);
p->v_page_dir[pde] = (u32_t)vmm_palloc_addr(&p_page_addr);
p->page_dir[pde] = p_page_addr | 0x7;
vmm_unmapp(p->v_page_dir[pde]);
vmm_unmapp((void *)p->v_page_dir[pde]);
}
page = vmm_palloc_addr(&p_page_addr);
((u32_t *)(p->v_page_dir[pde]))[pte] = p_page_addr | 0x7;
@@ -130,9 +173,9 @@ void zero_address_space(u32_t dest_addr, u32_t pages, process_t *p)
if (!p->v_page_dir[pde])
{
/* Time for a new page table & page directory entry! */
p->v_page_dir[pde] = vmm_palloc_addr(&p_page_addr);
p->v_page_dir[pde] = (u32_t)vmm_palloc_addr(&p_page_addr);
p->page_dir[pde] = p_page_addr | 0x7;
vmm_unmapp(p->v_page_dir[pde]);
vmm_unmapp((void *)p->v_page_dir[pde]);
}
page = vmm_palloc_addr(&p_page_addr);
((u32_t *)(p->v_page_dir[pde]))[pte] = p_page_addr | 0x7;
kernel/proc/proc.h
+47 -5
View File
@@ -15,16 +15,58 @@ typedef struct
u32_t *v_page_dir; /* Virtual page table addresses for init */
u32_t p_page_dir; /* Physical address of page directory */
u32_t size; /* Process size, bytes from 0 through bss */
u32_t esp; /* Process stack pointer */
int_stack_frame_t stack_frame;
u32_t ss;
u32_t esp;
} process_t;
int proc_init(int_stack_t *stack_frame);
void proc_sched();
typedef struct
{
u16_t backlink;
u16_t reserved0;
u32_t esp0;
u16_t ss0;
u16_t _ss0;
u32_t esp1;
u16_t ss1;
u16_t _ss1;
u32_t esp2;
u16_t ss2;
u16_t _ss2;
u32_t pdbr;
u32_t eip;
u32_t eflags;
u32_t eax;
u32_t ecx;
u32_t edx;
u32_t ebx;
u32_t esp;
u32_t ebp;
u32_t esi;
u32_t edi;
u16_t es;
u16_t _es;
u16_t cs;
u16_t _cs;
u16_t ss;
u16_t _ss;
u16_t ds;
u16_t _ds;
u16_t fs;
u16_t _fs;
u16_t gs;
u16_t _gs;
u16_t ldt;
u16_t _ldt;
u16_t trap;
u16_t iomap;
} __attribute__((packed)) tss_t;
int proc_init();
void proc_sched(int_stack_t *int_stack);
u32_t create_task(void *base, u32_t image_size, u32_t bss_size, void *entry);
process_t *create_process(void *base, u32_t image_size, u32_t bss_size, void *entry);
void create_address_space(process_t *p);
void create_process_stack(process_t *p);
void create_process_stack(process_t *p, void *entry);
void copy_into_address_space(u32_t dest_addr,
void *src_addr,
u32_t pages,