diff options
| -rw-r--r-- | bootmain.c | 10 | ||||
| -rw-r--r-- | defs.h | 2 | ||||
| -rw-r--r-- | elf.h | 54 | ||||
| -rw-r--r-- | main.c | 30 | ||||
| -rw-r--r-- | mmu.h | 164 | ||||
| -rw-r--r-- | proc.c | 22 | ||||
| -rw-r--r-- | proc.h | 18 | ||||
| -rw-r--r-- | syscall.c | 9 | ||||
| -rw-r--r-- | trap.c | 8 | ||||
| -rw-r--r-- | x86.h | 44 |
10 files changed, 181 insertions, 180 deletions
@@ -45,18 +45,18 @@ cmain(void) readseg((uint32_t) ELFHDR, SECTSIZE*8, 0); // is this a valid ELF? - if (ELFHDR->e_magic != ELF_MAGIC) + if (ELFHDR->magic != ELF_MAGIC) goto bad; // load each program segment (ignores ph flags) - ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->e_phoff); - eph = ph + ELFHDR->e_phnum; + ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->phoff); + eph = ph + ELFHDR->phnum; for (; ph < eph; ph++) - readseg(ph->p_va, ph->p_memsz, ph->p_offset); + readseg(ph->va, ph->memsz, ph->offset); // call the entry point from the ELF header // note: does not return! - ((void (*)(void)) (ELFHDR->e_entry & 0xFFFFFF))(); + ((void (*)(void)) (ELFHDR->entry & 0xFFFFFF))(); bad: outw(0x8A00, 0x8A00); @@ -64,6 +64,8 @@ int cpu(void); struct spinlock; void acquire(struct spinlock * lock); void release(struct spinlock * lock); +void acquire1(struct spinlock * lock, struct proc *); +void release1(struct spinlock * lock, struct proc *); // main.c void load_icode(struct proc *p, uint8_t *binary, unsigned size); @@ -1,43 +1,39 @@ -#ifndef JOS_INC_ELF_H -#define JOS_INC_ELF_H - #define ELF_MAGIC 0x464C457FU /* "\x7FELF" in little endian */ struct Elf { - uint32_t e_magic; // must equal ELF_MAGIC - uint8_t e_elf[12]; - uint16_t e_type; - uint16_t e_machine; - uint32_t e_version; - uint32_t e_entry; - uint32_t e_phoff; - uint32_t e_shoff; - uint32_t e_flags; - uint16_t e_ehsize; - uint16_t e_phentsize; - uint16_t e_phnum; - uint16_t e_shentsize; - uint16_t e_shnum; - uint16_t e_shstrndx; + uint32_t magic; // must equal ELF_MAGIC + uint8_t elf[12]; + uint16_t type; + uint16_t machine; + uint32_t version; + uint32_t entry; + uint32_t phoff; + uint32_t shoff; + uint32_t flags; + uint16_t ehsize; + uint16_t phentsize; + uint16_t phnum; + uint16_t shentsize; + uint16_t shnum; + uint16_t shstrndx; }; struct Proghdr { - uint32_t p_type; - uint32_t p_offset; - uint32_t p_va; - uint32_t p_pa; - uint32_t p_filesz; - uint32_t p_memsz; - uint32_t p_flags; - uint32_t p_align; + uint32_t type; + uint32_t offset; + uint32_t va; + uint32_t pa; + uint32_t filesz; + uint32_t memsz; + uint32_t flags; + uint32_t align; }; -// Values for Proghdr::p_type +// Values for Proghdr type #define ELF_PROG_LOAD 1 -// Flag bits for Proghdr::p_flags +// Flag bits for Proghdr flags #define ELF_PROG_FLAG_EXEC 1 #define ELF_PROG_FLAG_WRITE 2 #define ELF_PROG_FLAG_READ 4 -#endif /* !JOS_INC_ELF_H */ @@ -62,9 +62,9 @@ main() p->kstack = kalloc(KSTACKSIZE); p->tf = (struct Trapframe *) (p->kstack + KSTACKSIZE - sizeof(struct Trapframe)); memset(p->tf, 0, sizeof(struct Trapframe)); - p->tf->tf_es = p->tf->tf_ds = p->tf->tf_ss = (SEG_UDATA << 3) | 3; - p->tf->tf_cs = (SEG_UCODE << 3) | 3; - p->tf->tf_eflags = FL_IF; + p->tf->es = p->tf->ds = p->tf->ss = (SEG_UDATA << 3) | 3; + p->tf->cs = (SEG_UCODE << 3) | 3; + p->tf->eflags = FL_IF; p->pid = 0; p->ppid = 0; setupsegs(p); @@ -103,26 +103,26 @@ load_icode(struct proc *p, uint8_t *binary, unsigned size) // Check magic number on binary elf = (struct Elf*) binary; - cprintf("elf %x magic %x\n", elf, elf->e_magic); - if (elf->e_magic != ELF_MAGIC) + cprintf("elf %x magic %x\n", elf, elf->magic); + if (elf->magic != ELF_MAGIC) panic("load_icode: not an ELF binary"); - p->tf->tf_eip = elf->e_entry; - p->tf->tf_esp = p->sz; + p->tf->eip = elf->entry; + p->tf->esp = p->sz; // Map and load segments as directed. - ph = (struct Proghdr*) (binary + elf->e_phoff); - for (i = 0; i < elf->e_phnum; i++, ph++) { - if (ph->p_type != ELF_PROG_LOAD) + ph = (struct Proghdr*) (binary + elf->phoff); + for (i = 0; i < elf->phnum; i++, ph++) { + if (ph->type != ELF_PROG_LOAD) continue; - cprintf("va %x memsz %d\n", ph->p_va, ph->p_memsz); - if (ph->p_va + ph->p_memsz < ph->p_va) + cprintf("va %x memsz %d\n", ph->va, ph->memsz); + if (ph->va + ph->memsz < ph->va) panic("load_icode: overflow in elf header segment"); - if (ph->p_va + ph->p_memsz >= p->sz) + if (ph->va + ph->memsz >= p->sz) panic("load_icode: icode wants to be above UTOP"); // Load/clear the segment - memmove(p->mem + ph->p_va, binary + ph->p_offset, ph->p_filesz); - memset(p->mem + ph->p_va + ph->p_filesz, 0, ph->p_memsz - ph->p_filesz); + memmove(p->mem + ph->va, binary + ph->offset, ph->filesz); + memset(p->mem + ph->va + ph->filesz, 0, ph->memsz - ph->filesz); } } @@ -147,19 +147,19 @@ // Segment Descriptors struct Segdesc { - unsigned sd_lim_15_0 : 16; // Low bits of segment limit - unsigned sd_base_15_0 : 16; // Low bits of segment base address - unsigned sd_base_23_16 : 8; // Middle bits of segment base address - unsigned sd_type : 4; // Segment type (see STS_ constants) - unsigned sd_s : 1; // 0 = system, 1 = application - unsigned sd_dpl : 2; // Descriptor Privilege Level - unsigned sd_p : 1; // Present - unsigned sd_lim_19_16 : 4; // High bits of segment limit - unsigned sd_avl : 1; // Unused (available for software use) - unsigned sd_rsv1 : 1; // Reserved - unsigned sd_db : 1; // 0 = 16-bit segment, 1 = 32-bit segment - unsigned sd_g : 1; // Granularity: limit scaled by 4K when set - unsigned sd_base_31_24 : 8; // High bits of segment base address + unsigned lim_15_0 : 16; // Low bits of segment limit + unsigned base_15_0 : 16; // Low bits of segment base address + unsigned base_23_16 : 8; // Middle bits of segment base address + unsigned type : 4; // Segment type (see STS_ constants) + unsigned s : 1; // 0 = system, 1 = application + unsigned dpl : 2; // Descriptor Privilege Level + unsigned p : 1; // Present + unsigned lim_19_16 : 4; // High bits of segment limit + unsigned avl : 1; // Unused (available for software use) + unsigned rsv1 : 1; // Reserved + unsigned db : 1; // 0 = 16-bit segment, 1 = 32-bit segment + unsigned g : 1; // Granularity: limit scaled by 4K when set + unsigned base_31_24 : 8; // High bits of segment base address }; // Null segment #define SEG_NULL (struct Segdesc){ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 } @@ -210,56 +210,56 @@ struct Segdesc { // Task state segment format (as described by the Pentium architecture book) struct Taskstate { - uint32_t ts_link; // Old ts selector - uintptr_t ts_esp0; // Stack pointers and segment selectors - uint16_t ts_ss0; // after an increase in privilege level - uint16_t ts_padding1; - uintptr_t ts_esp1; - uint16_t ts_ss1; - uint16_t ts_padding2; - uintptr_t ts_esp2; - uint16_t ts_ss2; - uint16_t ts_padding3; - physaddr_t ts_cr3; // Page directory base - uintptr_t ts_eip; // Saved state from last task switch - uint32_t ts_eflags; - uint32_t ts_eax; // More saved state (registers) - uint32_t ts_ecx; - uint32_t ts_edx; - uint32_t ts_ebx; - uintptr_t ts_esp; - uintptr_t ts_ebp; - uint32_t ts_esi; - uint32_t ts_edi; - uint16_t ts_es; // Even more saved state (segment selectors) - uint16_t ts_padding4; - uint16_t ts_cs; - uint16_t ts_padding5; - uint16_t ts_ss; - uint16_t ts_padding6; - uint16_t ts_ds; - uint16_t ts_padding7; - uint16_t ts_fs; - uint16_t ts_padding8; - uint16_t ts_gs; - uint16_t ts_padding9; - uint16_t ts_ldt; - uint16_t ts_padding10; - uint16_t ts_t; // Trap on task switch - uint16_t ts_iomb; // I/O map base address + uint32_t link; // Old ts selector + uintptr_t esp0; // Stack pointers and segment selectors + uint16_t ss0; // after an increase in privilege level + uint16_t padding1; + uintptr_t esp1; + uint16_t ss1; + uint16_t padding2; + uintptr_t esp2; + uint16_t ss2; + uint16_t padding3; + physaddr_t cr3; // Page directory base + uintptr_t eip; // Saved state from last task switch + uint32_t eflags; + uint32_t eax; // More saved state (registers) + uint32_t ecx; + uint32_t edx; + uint32_t ebx; + uintptr_t esp; + uintptr_t ebp; + uint32_t esi; + uint32_t edi; + uint16_t es; // Even more saved state (segment selectors) + uint16_t padding4; + uint16_t cs; + uint16_t padding5; + uint16_t ss; + uint16_t padding6; + uint16_t ds; + uint16_t padding7; + uint16_t fs; + uint16_t padding8; + uint16_t gs; + uint16_t padding9; + uint16_t ldt; + uint16_t padding10; + uint16_t t; // Trap on task switch + uint16_t iomb; // I/O map base address }; // Gate descriptors for interrupts and traps struct Gatedesc { - unsigned gd_off_15_0 : 16; // low 16 bits of offset in segment - unsigned gd_ss : 16; // segment selector - unsigned gd_args : 5; // # args, 0 for interrupt/trap gates - unsigned gd_rsv1 : 3; // reserved(should be zero I guess) - unsigned gd_type : 4; // type(STS_{TG,IG32,TG32}) - unsigned gd_s : 1; // must be 0 (system) - unsigned gd_dpl : 2; // descriptor(meaning new) privilege level - unsigned gd_p : 1; // Present - unsigned gd_off_31_16 : 16; // high bits of offset in segment + unsigned off_15_0 : 16; // low 16 bits of offset in segment + unsigned ss : 16; // segment selector + unsigned args : 5; // # args, 0 for interrupt/trap gates + unsigned rsv1 : 3; // reserved(should be zero I guess) + unsigned type : 4; // type(STS_{TG,IG32,TG32}) + unsigned s : 1; // must be 0 (system) + unsigned dpl : 2; // descriptor(meaning new) privilege level + unsigned p : 1; // Present + unsigned off_31_16 : 16; // high bits of offset in segment }; // Set up a normal interrupt/trap gate descriptor. @@ -269,38 +269,38 @@ struct Gatedesc { // - dpl: Descriptor Privilege Level - // the privilege level required for software to invoke // this interrupt/trap gate explicitly using an int instruction. -#define SETGATE(gate, istrap, sel, off, dpl) \ +#define SETGATE(gate, istrap, sel, off, d) \ { \ - (gate).gd_off_15_0 = (uint32_t) (off) & 0xffff; \ - (gate).gd_ss = (sel); \ - (gate).gd_args = 0; \ - (gate).gd_rsv1 = 0; \ - (gate).gd_type = (istrap) ? STS_TG32 : STS_IG32; \ - (gate).gd_s = 0; \ - (gate).gd_dpl = (dpl); \ - (gate).gd_p = 1; \ - (gate).gd_off_31_16 = (uint32_t) (off) >> 16; \ + (gate).off_15_0 = (uint32_t) (off) & 0xffff; \ + (gate).ss = (sel); \ + (gate).args = 0; \ + (gate).rsv1 = 0; \ + (gate).type = (istrap) ? STS_TG32 : STS_IG32; \ + (gate).s = 0; \ + (gate).dpl = (d); \ + (gate).p = 1; \ + (gate).off_31_16 = (uint32_t) (off) >> 16; \ } // Set up a call gate descriptor. -#define SETCALLGATE(gate, ss, off, dpl) \ +#define SETCALLGATE(gate, ss, off, d) \ { \ - (gate).gd_off_15_0 = (uint32_t) (off) & 0xffff; \ - (gate).gd_ss = (ss); \ - (gate).gd_args = 0; \ - (gate).gd_rsv1 = 0; \ - (gate).gd_type = STS_CG32; \ - (gate).gd_s = 0; \ - (gate).gd_dpl = (dpl); \ - (gate).gd_p = 1; \ - (gate).gd_off_31_16 = (uint32_t) (off) >> 16; \ + (gate).off_15_0 = (uint32_t) (off) & 0xffff; \ + (gate).ss = (ss); \ + (gate).args = 0; \ + (gate).rsv1 = 0; \ + (gate).type = STS_CG32; \ + (gate).s = 0; \ + (gate).dpl = (d); \ + (gate).p = 1; \ + (gate).off_31_16 = (uint32_t) (off) >> 16; \ } // Pseudo-descriptors used for LGDT, LLDT and LIDT instructions. struct Pseudodesc { - uint16_t pd__garbage; // LGDT supposed to be from address 4N+2 - uint16_t pd_lim; // Limit - uint32_t pd_base __attribute__ ((packed)); // Base address + uint16_t _garbage; // LGDT supposed to be from address 4N+2 + uint16_t lim; // Limit + uint32_t base __attribute__ ((packed)); // Base address }; #define PD_ADDR(desc) (&(desc).pd_lim) @@ -25,8 +25,8 @@ void setupsegs(struct proc *p) { memset(&p->ts, 0, sizeof(struct Taskstate)); - p->ts.ts_ss0 = SEG_KDATA << 3; - p->ts.ts_esp0 = (unsigned)(p->kstack + KSTACKSIZE); + p->ts.ss0 = SEG_KDATA << 3; + p->ts.esp0 = (unsigned)(p->kstack + KSTACKSIZE); // XXX it may be wrong to modify the current segment table! @@ -35,12 +35,12 @@ setupsegs(struct proc *p) p->gdt[SEG_KDATA] = SEG(STA_W, 0, 0xffffffff, 0); p->gdt[SEG_TSS] = SEG16(STS_T32A, (unsigned) &p->ts, sizeof(p->ts), 0); - p->gdt[SEG_TSS].sd_s = 0; + p->gdt[SEG_TSS].s = 0; p->gdt[SEG_UCODE] = SEG(STA_X|STA_R, (unsigned)p->mem, p->sz, 3); p->gdt[SEG_UDATA] = SEG(STA_W, (unsigned)p->mem, p->sz, 3); - p->gdt_pd.pd__garbage = 0; - p->gdt_pd.pd_lim = sizeof(p->gdt) - 1; - p->gdt_pd.pd_base = (unsigned) p->gdt; + p->gdt_pd._garbage = 0; + p->gdt_pd.lim = sizeof(p->gdt) - 1; + p->gdt_pd.base = (unsigned) p->gdt; } // Look in the process table for an UNUSED proc. @@ -107,12 +107,12 @@ copyproc(struct proc* p) *np->tf = *p->tf; // Clear %eax so that fork system call returns 0 in child. - np->tf->tf_regs.reg_eax = 0; + np->tf->regs.eax = 0; // Set up new jmpbuf to start executing at forkret (see below). memset(&np->jmpbuf, 0, sizeof np->jmpbuf); - np->jmpbuf.jb_eip = (unsigned)forkret; - np->jmpbuf.jb_esp = (unsigned)np->tf; + np->jmpbuf.eip = (unsigned)forkret; + np->jmpbuf.esp = (unsigned)np->tf; // Copy file descriptors for(i = 0; i < NOFILE; i++){ @@ -153,13 +153,13 @@ scheduler(void) // It can run on the other stack. // h/w sets busy bit in TSS descriptor sometimes, and faults // if it's set in LTR. so clear tss descriptor busy bit. - p->gdt[SEG_TSS].sd_type = STS_T32A; + p->gdt[SEG_TSS].type = STS_T32A; // XXX should probably have an lgdt() function in x86.h // to confine all the inline assembly. // XXX probably ought to lgdt on trap return too, in case // a system call has moved a program or changed its size. - asm volatile("lgdt %0" : : "g" (p->gdt_pd.pd_lim)); + asm volatile("lgdt %0" : : "g" (p->gdt_pd.lim)); ltr(SEG_TSS << 3); // Switch to chosen process. It is the process's job @@ -22,15 +22,15 @@ struct jmpbuf { // they are constant across kernel contexts // save all the regular registers so we don't care which are caller save // don't save eax because that's the return register - // layout known to swtch.S - int jb_ebx; - int jb_ecx; - int jb_edx; - int jb_esi; - int jb_edi; - int jb_esp; - int jb_ebp; - int jb_eip; + // layout known to setjmp.S + int ebx; + int ecx; + int edx; + int esi; + int edi; + int esp; + int ebp; + int eip; }; enum proc_state { UNUSED, EMBRYO, SLEEPING, RUNNABLE, RUNNING, ZOMBIE }; @@ -51,7 +51,7 @@ fetcharg(int argno, void *ip) { unsigned esp; - esp = (unsigned) curproc[cpu()]->tf->tf_esp; + esp = (unsigned) curproc[cpu()]->tf->esp; return fetchint(curproc[cpu()], esp + 4 + 4*argno, ip); } @@ -263,7 +263,7 @@ void syscall(void) { struct proc *cp = curproc[cpu()]; - int num = cp->tf->tf_regs.reg_eax; + int num = cp->tf->regs.eax; int ret = -1; //cprintf("%x sys %d\n", cp, num); @@ -301,10 +301,13 @@ syscall(void) case SYS_panic: ret = sys_panic(); break; + case SYS_cons_puts: + ret = sys_cons_puts(); + break; default: cprintf("unknown sys call %d\n", num); // XXX fault break; } - cp->tf->tf_regs.reg_eax = ret; + cp->tf->regs.eax = ret; } @@ -28,17 +28,17 @@ tvinit() void idtinit() { - asm volatile("lidt %0" : : "g" (idt_pd.pd_lim)); + asm volatile("lidt %0" : : "g" (idt_pd.lim)); } void trap(struct Trapframe *tf) { - int v = tf->tf_trapno; + int v = tf->trapno; if(v == T_SYSCALL){ struct proc *cp = curproc[cpu()]; - int num = cp->tf->tf_regs.reg_eax; + int num = cp->tf->regs.eax; if(cp == 0) panic("syscall with no proc"); if(cp->killed) @@ -78,7 +78,7 @@ trap(struct Trapframe *tf) // (If the kernel was executing at time of interrupt, // don't kill the process. Let the process get back // out to its regular system call return.) - if((tf->tf_cs&3) == 3 && cp->killed) + if((tf->cs&3) == 3 && cp->killed) proc_exit(); // Force process to give up CPU and let others run. @@ -320,33 +320,33 @@ sti(void) struct PushRegs { /* registers as pushed by pusha */ - uint32_t reg_edi; - uint32_t reg_esi; - uint32_t reg_ebp; - uint32_t reg_oesp; /* Useless */ - uint32_t reg_ebx; - uint32_t reg_edx; - uint32_t reg_ecx; - uint32_t reg_eax; + uint32_t edi; + uint32_t esi; + uint32_t ebp; + uint32_t oesp; /* Useless */ + uint32_t ebx; + uint32_t edx; + uint32_t ecx; + uint32_t eax; }; struct Trapframe { - struct PushRegs tf_regs; - uint16_t tf_es; - uint16_t tf_padding1; - uint16_t tf_ds; - uint16_t tf_padding2; - uint32_t tf_trapno; + struct PushRegs regs; + uint16_t es; + uint16_t padding1; + uint16_t ds; + uint16_t padding2; + uint32_t trapno; /* below here defined by x86 hardware */ - uint32_t tf_err; - uintptr_t tf_eip; - uint16_t tf_cs; - uint16_t tf_padding3; - uint32_t tf_eflags; + uint32_t err; + uintptr_t eip; + uint16_t cs; + uint16_t padding3; + uint32_t eflags; /* below here only when crossing rings, such as from user to kernel */ - uintptr_t tf_esp; - uint16_t tf_ss; - uint16_t tf_padding4; + uintptr_t esp; + uint16_t ss; + uint16_t padding4; }; #define MAX_IRQS 16 // Number of IRQs |