ilo-pona/xv6-65oo2
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Activity

standardize on not using foo_ prefix in struct foo

Browse source
This commit is contained in:
rsc 2006-07-16 15:41:47 +00:00
parent 6b765c480f
commit ef2bd07ae4
10 changed files with 181 additions and 180 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
bootmain.c
View file

@ -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);

2
defs.h
View file

@ -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);

54
elf.h
View file

@ -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 */

30
main.c
View file

@ -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);
}
}

164
mmu.h
View file

@ -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)

22
proc.c
View file

@ -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

18
proc.h
View file

@ -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 };

9
syscall.c
View file

@ -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;
}

8
trap.c
View file

@ -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.

44
x86.h
View file

@ -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