From b5f17007f41770fee97fa850635976ceb7aa7492 Mon Sep 17 00:00:00 2001
From: rsc <rsc>
Date: Mon, 17 Jul 2006 01:58:13 +0000
Subject: [PATCH] standarize on unix-like lowercase struct names

---
 bootmain.c |  6 +++---
 elf.h      |  4 ++--
 main.c     | 12 ++++++------
 mmu.h      | 14 +++++++-------
 mp.c       | 40 ++++++++++++++++++++--------------------
 mp.h       | 12 ++++++------
 proc.c     |  6 +++---
 proc.h     |  6 +++---
 trap.c     |  4 ++--
 x86.h      | 14 +++++++-------
 10 files changed, 59 insertions(+), 59 deletions(-)

diff --git a/bootmain.c b/bootmain.c
index a98ca82..a97271f 100644
--- a/bootmain.c
+++ b/bootmain.c
@@ -31,7 +31,7 @@
  **********************************************************************/
 
 #define SECTSIZE	512
-#define ELFHDR		((struct Elf *) 0x10000) // scratch space
+#define ELFHDR		((struct elfhdr *) 0x10000) // scratch space
 
 void readsect(void*, uint32_t);
 void readseg(uint32_t, uint32_t, uint32_t);
@@ -39,7 +39,7 @@ void readseg(uint32_t, uint32_t, uint32_t);
 void
 cmain(void)
 {
-	struct Proghdr *ph, *eph;
+	struct proghdr *ph, *eph;
 
 	// read 1st page off disk
 	readseg((uint32_t) ELFHDR, SECTSIZE*8, 0);
@@ -49,7 +49,7 @@ cmain(void)
 		goto bad;
 
 	// load each program segment (ignores ph flags)
-	ph = (struct Proghdr *) ((uint8_t *) ELFHDR + ELFHDR->phoff);
+	ph = (struct proghdr *) ((uint8_t *) ELFHDR + ELFHDR->phoff);
 	eph = ph + ELFHDR->phnum;
 	for (; ph < eph; ph++)
 		readseg(ph->va, ph->memsz, ph->offset);
diff --git a/elf.h b/elf.h
index cbcf38e..807c151 100644
--- a/elf.h
+++ b/elf.h
@@ -1,6 +1,6 @@
 #define ELF_MAGIC 0x464C457FU	/* "\x7FELF" in little endian */
 
-struct Elf {
+struct elfhdr {
 	uint32_t magic;	// must equal ELF_MAGIC
 	uint8_t elf[12];
 	uint16_t type;
@@ -18,7 +18,7 @@ struct Elf {
 	uint16_t shstrndx;
 };
 
-struct Proghdr {
+struct proghdr {
 	uint32_t type;
 	uint32_t offset;
 	uint32_t va;
diff --git a/main.c b/main.c
index 694a0f7..0cde11e 100644
--- a/main.c
+++ b/main.c
@@ -57,8 +57,8 @@ main0(void)
   p->mem = kalloc(p->sz);
   memset(p->mem, 0, p->sz);
   p->kstack = kalloc(KSTACKSIZE);
-  p->tf = (struct Trapframe *) (p->kstack + KSTACKSIZE - sizeof(struct Trapframe));
-  memset(p->tf, 0, sizeof(struct Trapframe));
+  p->tf = (struct trapframe *) (p->kstack + KSTACKSIZE - sizeof(struct trapframe));
+  memset(p->tf, 0, sizeof(struct trapframe));
   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;
@@ -110,11 +110,11 @@ void
 load_icode(struct proc *p, uint8_t *binary, uint size)
 {
   int i;
-  struct Elf *elf;
-  struct Proghdr *ph;
+  struct elfhdr *elf;
+  struct proghdr *ph;
 
   // Check magic number on binary
-  elf = (struct Elf*) binary;
+  elf = (struct elfhdr*) binary;
   cprintf("elf %x magic %x\n", elf, elf->magic);
   if (elf->magic != ELF_MAGIC)
     panic("load_icode: not an ELF binary");
@@ -123,7 +123,7 @@ load_icode(struct proc *p, uint8_t *binary, uint size)
   p->tf->esp = p->sz;
 
   // Map and load segments as directed.
-  ph = (struct Proghdr*) (binary + elf->phoff);
+  ph = (struct proghdr*) (binary + elf->phoff);
   for (i = 0; i < elf->phnum; i++, ph++) {
     if (ph->type != ELF_PROG_LOAD)
       continue;
diff --git a/mmu.h b/mmu.h
index 20dc3a3..9dd3aa1 100644
--- a/mmu.h
+++ b/mmu.h
@@ -60,7 +60,7 @@
 #else	// not __ASSEMBLER__
 
 // Segment Descriptors
-struct Segdesc {
+struct segdesc {
 	uint lim_15_0 : 16;  // Low bits of segment limit
 	uint base_15_0 : 16; // Low bits of segment base address
 	uint base_23_16 : 8; // Middle bits of segment base address
@@ -76,15 +76,15 @@ struct Segdesc {
 	uint 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 }
+#define SEG_NULL	(struct segdesc){ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 // Segment that is loadable but faults when used
-#define SEG_FAULT	(struct Segdesc){ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
+#define SEG_FAULT	(struct segdesc){ 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0 }
 // Normal segment
-#define SEG(type, base, lim, dpl) (struct Segdesc)			\
+#define SEG(type, base, lim, dpl) (struct segdesc)			\
 { ((lim) >> 12) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,	\
     type, 1, dpl, 1, (uint) (lim) >> 28, 0, 0, 1, 1,		\
     (uint) (base) >> 24 }
-#define SEG16(type, base, lim, dpl) (struct Segdesc)			\
+#define SEG16(type, base, lim, dpl) (struct segdesc)			\
 { (lim) & 0xffff, (base) & 0xffff, ((base) >> 16) & 0xff,		\
     type, 1, dpl, 1, (uint) (lim) >> 16, 0, 0, 1, 0,		\
     (uint) (base) >> 24 }
@@ -123,7 +123,7 @@ struct Segdesc {
 #ifndef __ASSEMBLER__
 
 // Task state segment format (as described by the Pentium architecture book)
-struct Taskstate {
+struct taskstate {
 	uint32_t link;	// Old ts selector
 	uintptr_t esp0;	// Stack pointers and segment selectors
 	uint16_t ss0;	//   after an increase in privilege level
@@ -164,7 +164,7 @@ struct Taskstate {
 };
 
 // Gate descriptors for interrupts and traps
-struct Gatedesc {
+struct gatedesc {
 	uint off_15_0 : 16;   // low 16 bits of offset in segment
 	uint ss : 16;         // segment selector
 	uint args : 5;        // # args, 0 for interrupt/trap gates
diff --git a/mp.c b/mp.c
index bce35cb..b41cdf3 100644
--- a/mp.c
+++ b/mp.c
@@ -31,12 +31,12 @@ static char* buses[] = {
 
 #define APBOOTCODE 0x7000 // XXX hack
 
-static struct MP* mp;  // The MP floating point structure
+static struct mp* mp;  // The MP floating point structure
 struct cpu cpus[NCPU];
 int ncpu;
 static struct cpu *bcpu;
 
-static struct MP*
+static struct mp*
 mp_scan(uint8_t *addr, int len)
 {
   uint8_t *e, *p, sum;
@@ -44,24 +44,24 @@ mp_scan(uint8_t *addr, int len)
 
   cprintf("scanning: 0x%x\n", (uint32_t)addr);
   e = addr+len;
-  for(p = addr; p < e; p += sizeof(struct MP)){
+  for(p = addr; p < e; p += sizeof(struct mp)){
     if(memcmp(p, "_MP_", 4))
       continue;
     sum = 0;
-    for(i = 0; i < sizeof(struct MP); i++)
+    for(i = 0; i < sizeof(struct mp); i++)
       sum += p[i];
     if(sum == 0)
-      return (struct MP *)p;
+      return (struct mp *)p;
   }
   return 0;
 }
 
-static struct MP*
+static struct mp*
 mp_search(void)
 {
   uint8_t *bda;
   uint32_t p;
-  struct MP *mp;
+  struct mp *mp;
 
   /*
    * Search for the MP Floating Pointer Structure, which according to the
@@ -86,7 +86,7 @@ mp_search(void)
 static int 
 mp_detect(void)
 {
-  struct MPCTB *pcmp;
+  struct mpctb *pcmp;
   uint8_t *p, sum;
   uint32_t length;
 
@@ -100,7 +100,7 @@ mp_detect(void)
   if((mp = mp_search()) == 0 || mp->physaddr == 0)
     return 1;
 
-  pcmp = (struct MPCTB *) mp->physaddr;
+  pcmp = (struct mpctb *) mp->physaddr;
   if(memcmp(pcmp, "PCMP", 4))
     return 2;
 
@@ -121,9 +121,9 @@ mp_init(void)
 { 
   int r;
   uint8_t *p, *e;
-  struct MPCTB *mpctb;
-  struct MPPE *proc;
-  struct MPBE *bus;
+  struct mpctb *mpctb;
+  struct mppe *proc;
+  struct mpbe *bus;
   int i;
 
   ncpu = 0;
@@ -136,40 +136,40 @@ mp_init(void)
    * application processors and initialising any I/O APICs. The table
    * is guaranteed to be in order such that only one pass is necessary.
    */
-  mpctb = (struct MPCTB *) mp->physaddr;
+  mpctb = (struct mpctb *) mp->physaddr;
   lapicaddr = (uint32_t *) mpctb->lapicaddr;
   cprintf("apicaddr: %x\n", lapicaddr);
-  p = ((uint8_t*)mpctb)+sizeof(struct MPCTB);
+  p = ((uint8_t*)mpctb)+sizeof(struct mpctb);
   e = ((uint8_t*)mpctb)+mpctb->length;
 
   while(p < e) {
     switch(*p){
     case MPPROCESSOR:
-      proc = (struct MPPE *) p;
+      proc = (struct mppe *) p;
       cpus[ncpu].apicid = proc->apicid;
       cprintf("a processor %x\n", cpus[ncpu].apicid);
       if (proc->flags & MPBP) {
 	bcpu = &cpus[ncpu];
       }
       ncpu++;
-      p += sizeof(struct MPPE);
+      p += sizeof(struct mppe);
       continue;
     case MPBUS:
-      bus = (struct MPBE *) p;
+      bus = (struct mpbe *) p;
       for(i = 0; buses[i]; i++){
 	if(strncmp(buses[i], bus->string, sizeof(bus->string)) == 0)
 	  break;
       }
       cprintf("a bus %d\n", i);
-      p += sizeof(struct MPBE);
+      p += sizeof(struct mpbe);
       continue;
     case MPIOAPIC:
       cprintf("an I/O APIC\n");
-      p += sizeof(struct MPIOAPIC);
+      p += sizeof(struct mpioapic);
       continue;
     case MPIOINTR:
       cprintf("an I/O intr\n");
-      p += sizeof(struct MPIE);
+      p += sizeof(struct mpie);
       continue;
     default:
       cprintf("mpinit: unknown PCMP type 0x%x (e-p 0x%x)\n", *p, e-p);
diff --git a/mp.h b/mp.h
index f5f4cea..b24aa94 100644
--- a/mp.h
+++ b/mp.h
@@ -4,7 +4,7 @@
  * Credit: Plan 9 sources
  */
 
-struct MP {			/* floating pointer */
+struct mp {			/* floating pointer */
   uint8_t signature[4];		/* "_MP_" */
   physaddr_t physaddr;	        /* physical address of MP configuration table */
   uint8_t length;		/* 1 */
@@ -15,7 +15,7 @@ struct MP {			/* floating pointer */
   uint8_t reserved[3];
 };
 
-struct MPCTB {			/* configuration table header */
+struct mpctb {			/* configuration table header */
   uint8_t signature[4];		/* "PCMP" */
   uint16_t length;		/* total table length */
   uint8_t version;		/* [14] */
@@ -30,7 +30,7 @@ struct MPCTB {			/* configuration table header */
   uint8_t reserved;
 };
 
-struct MPPE {		/* processor table entry */
+struct mppe {		/* processor table entry */
   uint8_t type;			/* entry type (0) */
   uint8_t apicid;		/* local APIC id */
   uint8_t version;		/* local APIC verison */
@@ -40,13 +40,13 @@ struct MPPE {		/* processor table entry */
   uint8_t reserved[8];
 };
 
-struct MPBE {		/* bus table entry */
+struct mpbe {		/* bus table entry */
   uint8_t type;			/* entry type (1) */
   uint8_t busno;		/* bus id */
   char string[6];		/* bus type string */
 };
 
-struct MPIOAPIC {	/* I/O APIC table entry */
+struct mpioapic {	/* I/O APIC table entry */
   uint8_t type;			/* entry type (2) */
   uint8_t apicno;		/* I/O APIC id */
   uint8_t version;		/* I/O APIC version */
@@ -54,7 +54,7 @@ struct MPIOAPIC {	/* I/O APIC table entry */
   uintptr_t addr;		/* I/O APIC address */
 };
 
-struct MPIE {		/* interrupt table entry */
+struct mpie {		/* interrupt table entry */
   uint8_t type;			/* entry type ([34]) */
   uint8_t intr;			/* interrupt type */
   uint16_t flags;		/* interrupt flag */
diff --git a/proc.c b/proc.c
index ba6905b..4a05098 100644
--- a/proc.c
+++ b/proc.c
@@ -13,7 +13,7 @@ struct proc proc[NPROC];
 struct proc *curproc[NCPU];
 int next_pid = 1;
 extern void forkret(void);
-extern void forkret1(struct Trapframe*);
+extern void forkret1(struct trapframe*);
 
 /*
  * set up a process's task state and segment descriptors
@@ -24,7 +24,7 @@ extern void forkret1(struct Trapframe*);
 void
 setupsegs(struct proc *p)
 {
-  memset(&p->ts, 0, sizeof(struct Taskstate));
+  memset(&p->ts, 0, sizeof(struct taskstate));
   p->ts.ss0 = SEG_KDATA << 3;
   p->ts.esp0 = (uint)(p->kstack + KSTACKSIZE);
 
@@ -100,7 +100,7 @@ copyproc(struct proc* p)
   setupsegs(np);
 
   // Copy trapframe registers from parent.
-  np->tf = (struct Trapframe*)(np->kstack + KSTACKSIZE) - 1;
+  np->tf = (struct trapframe*)(np->kstack + KSTACKSIZE) - 1;
   *np->tf = *p->tf;
   
   // Clear %eax so that fork system call returns 0 in child.
diff --git a/proc.h b/proc.h
index 256fa7c..8fb935c 100644
--- a/proc.h
+++ b/proc.h
@@ -48,14 +48,14 @@ struct proc{
   int killed;
   struct fd *fds[NOFILE];
 
-  struct Taskstate ts;  // only to give cpu address of kernel stack
-  struct Segdesc gdt[NSEGS];
+  struct taskstate ts;  // only to give cpu address of kernel stack
+  struct segdesc gdt[NSEGS];
   uint esp; // kernel stack pointer
   uint ebp; // kernel frame pointer
 
   struct jmpbuf jmpbuf;
 
-  struct Trapframe *tf; // points into kstack, used to find user regs
+  struct trapframe *tf; // points into kstack, used to find user regs
 };
 
 extern struct proc proc[];
diff --git a/trap.c b/trap.c
index 38baee0..ccbc754 100644
--- a/trap.c
+++ b/trap.c
@@ -7,7 +7,7 @@
 #include "traps.h"
 #include "syscall.h"
 
-struct Gatedesc idt[256];
+struct gatedesc idt[256];
 extern uint vectors[]; /* vectors.S, array of 256 entry point addresses */
 
 extern void trapenter(void);
@@ -31,7 +31,7 @@ idtinit(void)
 }
 
 void
-trap(struct Trapframe *tf)
+trap(struct trapframe *tf)
 {
   int v = tf->trapno;
 
diff --git a/x86.h b/x86.h
index 267c2da..444c6df 100644
--- a/x86.h
+++ b/x86.h
@@ -12,10 +12,10 @@ static __inline void outsw(int port, const void *addr, int cnt) __attribute__((a
 static __inline void outsl(int port, const void *addr, int cnt) __attribute__((always_inline));
 static __inline void outl(int port, uint32_t data) __attribute__((always_inline));
 static __inline void invlpg(void *addr) __attribute__((always_inline));
-struct Segdesc;
-static __inline void lgdt(struct Segdesc *p, int) __attribute__((always_inline));
-struct Gatedesc;
-static __inline void lidt(struct Gatedesc *p, int) __attribute__((always_inline));
+struct segdesc;
+static __inline void lgdt(struct segdesc *p, int) __attribute__((always_inline));
+struct gatedesc;
+static __inline void lidt(struct gatedesc *p, int) __attribute__((always_inline));
 static __inline void lldt(uint16_t sel) __attribute__((always_inline));
 static __inline void ltr(uint16_t sel) __attribute__((always_inline));
 static __inline void lcr0(uint32_t val) __attribute__((always_inline));
@@ -144,7 +144,7 @@ invlpg(void *addr)
 }  
 
 static __inline void
-lgdt(struct Segdesc *p, int size)
+lgdt(struct segdesc *p, int size)
 {
 	volatile uint16_t pd[3];
   
@@ -156,7 +156,7 @@ lgdt(struct Segdesc *p, int size)
 }
 
 static __inline void
-lidt(struct Gatedesc *p, int size)
+lidt(struct gatedesc *p, int size)
 {
 	volatile uint16_t pd[3];
   
@@ -339,7 +339,7 @@ sti(void)
 	__asm__ volatile("sti");
 }
 
-struct Trapframe {
+struct trapframe {
     /* registers as pushed by pusha */
     uint32_t edi;
     uint32_t esi;