nearly-complete c++ conversion

f336c8cd · Nickolai Zeldovich · b2705655 · f336c8cd · f336c8cd · f336c8cd
--- a/bio.cc
+++ b/bio.cc
@@ -21,12 +21,10 @@
 // * B_DIRTY: the buffer data has been modified
 //     and needs to be written to disk.

-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
-#include "condvar.h"
-}
+#include "condvar.hh"

 #include "buf.hh"
 #include "cpputil.hh"

--- a/bootdata.c
+++ b/bootdata.c
@@ -3,7 +3,7 @@
 #include "spinlock.h"
 #include "kalloc.h"
 #include "syscall.h"
-#include "kernel.h"
+#include "kern_c.h"

 /*
 * Data structures that use C99 designated initializers,

--- a/cga.cc
+++ b/cga.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "amd64.h"
-}

 #define BACKSPACE 0x100
 #define CRTPORT 0x3d4

--- a/condvar.cc
+++ b/condvar.cc
-extern "C" {
 #include "types.h"
 #include "amd64.h"
 #include "mmu.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
-#include "kernel.h"
-#include "cpu.h"
-}
+#include "proc.hh"
+#include "kernel.hh"
+#include "cpu.hh"

 struct spinlock tickslock __mpalign__;
 struct condvar cv_ticks __mpalign__;

--- a/condvar.h
+++ b/condvar.h
--- a/console.cc
+++ b/console.cc
@@ -2,27 +2,21 @@
 // Input is from the keyboard or serial port.
 // Output is written to the screen and serial port.

-extern "C" {
 #include "types.h"
-#include "cpu.h"
-#include "kernel.h"
+#include "cpu.hh"
+#include "kernel.hh"
 #include "spinlock.h"
 #include "fs.h"
-#include "condvar.h"
-}
-
+#include "condvar.hh"
 #include "file.hh"
-
-extern "C" {
 #include "amd64.h"
 #include "queue.h"
-#include "proc.h"
+#include "proc.hh"
 #include "traps.h"
 #include "lib.h"
 #include <stdarg.h>
-#include "fmt.h"
+#include "fmt.hh"
 #include <stddef.h>
-}

 #define BACKSPACE 0x100


--- a/cpprt.cc
+++ b/cpprt.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
-}
-
+#include "kernel.hh"
 #include "cpputil.hh"

 void *

--- a/cpu.h
+++ b/cpu.h
--- a/crange.cc
+++ b/crange.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "mmu.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
-#include "cpu.h"
-}
+#include "proc.hh"
+#include "cpu.hh"
 #include "gc.hh"
 #include "crange.hh"
 #include "cpputil.hh"
@@ -110,7 +108,7 @@ void range::dec_ref(void)
  }
 }

-range::range(crange *crarg, u64 k, u64 sz, void *v, markptr<range> n, int nl)
+range::range(crange *crarg, u64 k, u64 sz, void *v, range *n, int nl)
  : rcu_freed("range_delayed")
 {
  dprintf("range:range:: %lu %lu %d\n", k, sz, nl);
@@ -227,10 +225,12 @@ static range *replace(u64 k, u64 sz, void *v, range *f, range *l, range *s)
 	r = left;
      } else if (k <= f->key) { // cut front?
 	assert(k+sz <= f->key + f->size);
-	r = new range(f->cr, k+sz, f->key + f->size - k - sz, v, f->next[0]);
+        assert(!f->next[0].mark());
+	r = new range(f->cr, k+sz, f->key + f->size - k - sz, v, f->next[0].ptr());
      } else {  // cut end
 	assert(k > f->key);
-	r = new range(f->cr, f->key, k - f->key, v, f->next[0]);
+        assert(!f->next[0].mark());
+	r = new range(f->cr, f->key, k - f->key, v, f->next[0].ptr());
      }
    }
  } else if (k <= f->key && k + sz >= l->key + l->size) {  // delete complete range?
@@ -383,7 +383,7 @@ void crange::add_index(int l, range *e, range *p1, markptr<range> s1)
  if (cmpxch(&e->curlevel, l, l+1)) {
    assert(e->curlevel < e->nlevel);
    // this is the core inserting at level l+1, but some core may be deleting
-    struct range *s = s1.ptr();
+    struct range *s = s1.ptr(); // XXX losing the mark bit ???
    do {
      markptr<range> n = e->next[l+1];   // Null and perhaps marked
      if (n.mark()) {

--- a/crange.hh
+++ b/crange.hh
@@ -93,7 +93,7 @@ struct range : public rcu_freed {
  markptr<range>* next;  // one next pointer per level
  spinlock *lock;        // on separate cache line?

-  range(crange *cr, u64 k, u64 sz, void *v, markptr<range> n, int nlevel = 0);
+  range(crange *cr, u64 k, u64 sz, void *v, range *n, int nlevel = 0);
  ~range();
  virtual void do_gc() {
    delete this;

--- a/e1000.cc
+++ b/e1000.cc
-extern "C" {
 #include "types.h"
 #include "amd64.h"
-#include "kernel.h"
-#include "pci.h"
+#include "kernel.hh"
+#include "pci.hh"
 #include "spinlock.h"
-#include "e1000reg.h"
-}
+#include "e1000reg.hh"

 #define TX_RING_SIZE 64
 #define RX_RING_SIZE 64

--- a/e1000reg.h
+++ b/e1000reg.h
--- a/exec.cc
+++ b/exec.cc
-extern "C" {
 #include "types.h"
 #include "mmu.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
-#include "kernel.h"
+#include "proc.hh"
+#include "kernel.hh"
 #include "amd64.h"
 #include "stat.h"
 #include "fs.h"
-}
-
 #include "file.hh"
 #include "vm.hh"
-
-extern "C" {
 #include "elf.h"
-#include "cpu.h"
-#include "prof.h"
+#include "cpu.hh"
+#include "prof.hh"
 #include <stddef.h>
-}

 #define USTACKPAGES 2
 #define BRK (USERTOP >> 1)

--- a/file.cc
+++ b/file.cc
-extern "C" {
 #include "types.h"
 #include "spinlock.h"
-#include "condvar.h"
-#include "kernel.h"
+#include "condvar.hh"
+#include "kernel.hh"
 #include "fs.h"
-}
-
 #include "file.hh"
-
-extern "C" {
 #include "stat.h"
-#include "net.h"
-}
+#include "net.hh"

 struct devsw __mpalign__ devsw[NDEV];


--- a/fmt.cc
+++ b/fmt.cc
-extern "C" {
 #include "types.h"
 #include <stddef.h>
 #include <stdarg.h>
-#include "fmt.h"
+#include "fmt.hh"
 #include "lib.h"
-unsigned int strlen(const char*);
-}
+
+extern "C" unsigned int strlen(const char*);

 //
 // Print a number (base <= 16) in reverse order,

--- a/fmt.h
+++ b/fmt.h
--- a/fs.cc
+++ b/fs.cc
@@ -10,24 +10,18 @@
 // routines.  The (higher-level) system call implementations
 // are in sysfile.c.

-extern "C" {
 #include "types.h"
 #include "stat.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
+#include "proc.hh"
 #include "fs.h"
-}
-
 #include "buf.hh"
 #include "file.hh"
-
-extern "C" {
-#include "cpu.h"
-}
+#include "cpu.hh"

 #define min(a, b) ((a) < (b) ? (a) : (b))
 static void itrunc(struct inode*);

--- a/gc.cc
+++ b/gc.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "mmu.h"
 #include "amd64.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
-#include "cpu.h"
-}
-
+#include "proc.hh"
+#include "cpu.hh"
 #include "ns.hh"
 #include "atomic.hh"


--- a/hwvm.cc
+++ b/hwvm.cc
-extern "C" {
 #include "types.h"
 #include "amd64.h"
 #include "mmu.h"
-#include "cpu.h"
-#include "kernel.h"
+#include "cpu.hh"
+#include "kernel.hh"
 #include "bits.h"
 #include "spinlock.h"
 #include "kalloc.h"
 #include "queue.h"
-#include "condvar.h"
-#include "proc.h"
-#include <stddef.h>
-}
-
+#include "condvar.hh"
+#include "proc.hh"
 #include "vm.hh"
+#include <stddef.h>

 extern pml4e_t kpml4[];


--- a/hz.cc
+++ b/hz.cc
 // Intel 8253/8254/82C54 Programmable Interval Timer (PIT).
 // http://en.wikipedia.org/wiki/Intel_8253

-extern "C" {
 #include "types.h"
 #include "amd64.h"
-#include "kernel.h"
-}
+#include "kernel.hh"

 #define IO_TIMER1       0x040           // 8253 Timer #1
 #define TIMER_FREQ      1193182

--- a/ioapic.cc
+++ b/ioapic.cc
@@ -2,11 +2,9 @@
 // http://www.intel.com/design/chipsets/datashts/29056601.pdf
 // See also picirq.c.

-extern "C" {
 #include "types.h"
 #include "traps.h"
-#include "kernel.h"
-}
+#include "kernel.hh"

 #define IOAPIC  (KBASE + 0xFEC00000)   // Default physical address of IO APIC


--- a/ipc.h
+++ b/ipc.h
--- a/kalloc.cc
+++ b/kalloc.cc
@@ -3,16 +3,14 @@
 // Slab allocator, for chunks larger than one page.
 //

-extern "C" {
 #include "types.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
 #include "kalloc.h"
 #include "mtrace.h"
-#include "cpu.h"
+#include "cpu.hh"
 #include "multiboot.h"
-}

 static struct Mbmem mem[128];
 static u64 nmem;

--- a/kbd.c
+++ b/kbd.c
 #include "types.h"
 #include "amd64.h"
-#include "kernel.h"
+#include "kern_c.h"
 #include "kbd.h"

 int

--- a/kern_c.h
+++ b/kern_c.h
+#include "mmu.h"
+#include "lib.h"
+
+// console.c
+void            consoleintr(int(*)(void));
+
+// kbd.c
+void            kbdintr(void);
+
+// swtch.S
+struct context;
+void            swtch(struct context**, struct context*);
+
+// trap.c
+extern struct segdesc bootgdt[NSEGS];
+
+// syscalls
+long sys_chdir(void);
+long sys_close(void);
+long sys_dup(void);
+long sys_exec(void);
+long sys_exit(void);
+long sys_fork(void);
+long sys_fstat(void);
+long sys_getpid(void);
+long sys_kill(void);
+long sys_link(void);
+long sys_mkdir(void);
+long sys_mknod(void);
+long sys_open(void);
+long sys_pipe(void);
+long sys_read(void);
+long sys_sbrk(void);
+long sys_sleep(void);
+long sys_unlink(void);
+long sys_wait(void);
+long sys_write(void);
+long sys_uptime(void);
+long sys_map(void);
+long sys_unmap(void);
+long sys_halt(void);
+long sys_socket(int, int, int);
+long sys_bind(int, void*, int);
+long sys_listen(int, int);
+long sys_accept(int, void*, void*);
+long sys_pread(int fd, void *ubuf, size_t count, off_t offset);
+long sys_kernlet(int, size_t, off_t);
+extern long (*syscalls[])(u64, u64, u64, u64, u64, u64);
+
+// other exported/imported functions
+void cmain(u64 mbmagic, u64 mbaddr);
+void mpboot(void);
+void trapret(void);
+void threadstub(void);
+void threadhelper(void (*fn)(void *), void *arg);
+
+struct trapframe;
+void trap(struct trapframe *tf);
+
--- a/kernel.h
+++ b/kernel.h
-#include "mmu.h"
-#include "lib.h"
+extern "C" {
+#include "kern_c.h"
+}

 #define KBASE   0xFFFFFF0000000000ull
 #define KSHARED 0xFFFFF00000000000ull
@@ -51,7 +52,6 @@ void            panic(const char*, ...)
                  __noret__ __attribute__((format(printf, 1, 2)));
 void            kerneltrap(struct trapframe *tf) __noret__;
 void            snprintf(char *buf, u32 n, const char *fmt, ...);
-void            consoleintr(int(*)(void));

 #define assert(c)   if (!(c)) { cprintf("%s:%d: ", __FILE__, __LINE__); panic("assertion failure"); }

@@ -224,7 +224,7 @@ void*           memmove(void*, const void*, u32);
 void*           memset(void*, int, u32);
 void*           memcpy(void*, const void *, u32);
 char*           safestrcpy(char*, const char*, u32);
-unsigned int    strlen(const char*);
+extern "C" unsigned int    strlen(const char*);
 int             strncmp(const char*, const char*, u32);
 char*           strncpy(char*, const char*, u32);
 int             strcmp(const char *p, const char *q);

--- a/kernlet.cc
+++ b/kernlet.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
-#include "condvar.h"
-#include "cpu.h"
-#include "proc.h"
+#include "condvar.hh"
+#include "cpu.hh"
+#include "proc.hh"
 #include "fs.h"
-#include "wq.h"
-#include "ipc.h"
-}
-
+#include "wq.hh"
+#include "ipc.hh"
 #include "vm.hh"
 #include "file.hh"


--- a/kmalloc.cc
+++ b/kmalloc.cc
@@ -2,15 +2,13 @@
 // Allocate objects smaller than a page.
 //

-extern "C" {
 #include "types.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
 #include "kalloc.h"
 #include "mtrace.h"
-#include "cpu.h"
-}
+#include "cpu.hh"

 // allocate in power-of-two sizes up to 2^KMMAX
 // must be < 12

--- a/lapic.cc
+++ b/lapic.cc
 // The local APIC manages internal (non-I/O) interrupts.
 // See Chapter 8 & Appendix C of Intel processor manual volume 3.

-extern "C" {
 #include "types.h"
 #include "amd64.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "traps.h"
 #include "bits.h"
-}

 // Local APIC registers, divided by 4 for use as uint[] indices.
 #define ID      (0x0020/4)   // ID

--- a/main.cc
+++ b/main.cc
-extern "C" {
 #include "types.h"
 #include "multiboot.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
 #include "kalloc.h"
-#include "cpu.h"
+#include "cpu.hh"
 #include "amd64.h"
-}

 static volatile int bstate;


--- a/memide.cc
+++ b/memide.cc
 // Fake IDE disk; stores blocks in memory.
 // Useful for running kernel without scratch disk.

-extern "C" {
 #include "types.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
 #include "queue.h"
-#include "condvar.h"
-#include "proc.h"
+#include "condvar.hh"
+#include "proc.hh"
 #include "amd64.h"
 #include "traps.h"
-}

 #include "buf.hh"


--- a/mp.cc
+++ b/mp.cc
@@ -2,13 +2,11 @@
 // Search memory for MP description structures.
 // http://developer.intel.com/design/pentium/datashts/24201606.pdf

-extern "C" {
 #include "types.h"
 #include "amd64.h"
 #include "mp.h"
-#include "kernel.h"
-#include "cpu.h"
-}
+#include "kernel.hh"
+#include "cpu.hh"

 struct cpu cpus[NCPU];
 static struct cpu *bcpu __mpalign__;

--- a/net.cc
+++ b/net.cc
@@ -10,28 +10,24 @@ extern "C" {
 }
 #endif

-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "queue.h"
 #ifndef LWIP
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #endif
-#include "proc.h"
+#include "proc.hh"
 #include "fs.h"
-}
-
 #include "file.hh"
-
-extern "C" {
-#include "net.h"
+#include "net.hh"

 #ifdef LWIP
+extern "C" {
 err_t if_init(struct netif *netif);
 void if_input(struct netif *netif, void *buf, u16 len);
-#endif
 }
+#endif

 void
 netfree(void *va)

--- a/net.h
+++ b/net.h
--- a/pci.cc
+++ b/pci.cc
-extern "C" {
 #include "types.h"
 #include "amd64.h"
-#include "kernel.h"
-#include "pci.h"
-#include "pcireg.h"
-}
+#include "kernel.hh"
+#include "pci.hh"
+#include "pcireg.hh"

 extern int e1000attach(struct pci_func *pcif);
 extern int e1000eattach(struct pci_func *pcif);

--- a/pci.h
+++ b/pci.h
--- a/pcireg.h
+++ b/pcireg.h
--- a/picirq.cc
+++ b/picirq.cc
 // Intel 8259A programmable interrupt controllers.

-extern "C" {
 #include "types.h"
 #include "amd64.h"
 #include "traps.h"
-#include "kernel.h"
-}
+#include "kernel.hh"

 // I/O Addresses of the two programmable interrupt controllers
 #define IO_PIC1         0x20    // Master (IRQs 0-7)

--- a/pipe.cc
+++ b/pipe.cc
-extern "C" {
 #include "types.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
+#include "proc.hh"
 #include "fs.h"
-}
-
 #include "file.hh"
-
-extern "C" {
-#include "cpu.h"
-}
+#include "cpu.hh"

 #define PIPESIZE 512


--- a/preadtest.cc
+++ b/preadtest.cc
@@ -4,7 +4,7 @@
 #include "user.h"
 #include "lib.h"
 #include "amd64.h"
-#include "ipc.h"
+#include "ipc.hh"

 // XXX(sbw) add a memlayout.h?
 #define KSHARED 0xFFFFF00000000000ull

--- a/printf.cc
+++ b/printf.cc
 #include "types.h"
 #include "stat.h"
 #include "user.h"
-extern "C" {
 #include <stdarg.h>
-#include "fmt.h"
-}
+#include "fmt.hh"

 // Print to the given fd.
 static void

--- a/proc.cc
+++ b/proc.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "mmu.h"
 #include "amd64.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
-#include "cpu.h"
+#include "proc.hh"
+#include "cpu.hh"
 #include "bits.h"
 #include "kmtrace.h"
-#include "sched.h"
+#include "sched.hh"
 #include "kalloc.h"
-}
-
 #include "vm.hh"
 #include "ns.hh"


--- a/proc.h
+++ b/proc.h
--- a/prof.cc
+++ b/prof.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "fs.h"
-}
-
 #include "file.hh"
-
-extern "C" {
-#include "prof.h"
+#include "prof.hh"
 #include "bits.h"
 #include "amd64.h"
-}

 extern profctr_t sprof[];
 extern profctr_t eprof[];

--- a/prof.h
+++ b/prof.h
--- a/rnd.cc
+++ b/rnd.cc
-extern "C" {
 #include "param.h"
 #include "types.h"
-#include "kernel.h"
-#include "cpu.h"
-}
+#include "kernel.hh"
+#include "cpu.hh"

 struct seed {
  u64 v;

--- a/sampler.cc
+++ b/sampler.cc
-extern "C" {
 #include "types.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "fs.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "stat.h"
 #include "kalloc.h"
-}
-
 #include "file.hh"
-
-extern "C" {
 #include "bits.h"
 #include "amd64.h"
-#include "cpu.h"
+#include "cpu.hh"
 #include "sampler.h"
-}

 #define LOGHEADER_SZ (sizeof(struct logheader) + \
                      sizeof(((struct logheader*)0)->cpu[0])*NCPU)

--- a/sched.cc
+++ b/sched.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "mmu.h"
 #include "amd64.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
-#include "cpu.h"
+#include "proc.hh"
+#include "cpu.hh"
 #include "bits.h"
 #include "kmtrace.h"
 #include "sched.h"
-#include <stddef.h>
-}
-
 #include "vm.hh"
+#include <stddef.h>

 enum { sched_debug = 0 };


--- a/sched.h
+++ b/sched.h
--- a/spinlock.cc
+++ b/spinlock.cc
 // Mutual exclusion spin locks.

-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "amd64.h"
-#include "cpu.h"
+#include "cpu.hh"
 #include "bits.h"
 #include "spinlock.h"
 #include "mtrace.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "fs.h"
-}
-
 #include "file.hh"

 #if LOCKSTAT

--- a/string.cc
+++ b/string.cc
-extern "C" {
 #include "types.h"
 #include "amd64.h"
-#include "kernel.h"
-}
+#include "kernel.hh"

 void*
 memset(void *dst, int c, u32 n)

--- a/syscall.cc
+++ b/syscall.cc
-extern "C" {
 #include "types.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
+#include "proc.hh"
 #include "amd64.h"
 #include "syscall.h"
-#include "cpu.h"
+#include "cpu.hh"
 #include "kmtrace.h"
-}

 // User code makes a system call with INT T_SYSCALL.
 // System call number in %eax.

--- a/sysfile.cc
+++ b/sysfile.cc
-extern "C" {
 #include "types.h"
 #include "stat.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
+#include "proc.hh"
 #include "fs.h"
-}
-
 #include "file.hh"
-
-extern "C" {
 #include "fcntl.h"
-#include "cpu.h"
-#include "net.h"
-}
+#include "cpu.hh"
+#include "net.hh"

 // Fetch the nth word-sized system call argument as a file descriptor
 // and return both the descriptor and the corresponding struct file.

--- a/sysproc.cc
+++ b/sysproc.cc
-extern "C" {
 #include "types.h"
 #include "amd64.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "mmu.h"
 #include "spinlock.h"
-#include "condvar.h"
+#include "condvar.hh"
 #include "queue.h"
-#include "proc.h"
-#include "cpu.h"
-}
-
+#include "proc.hh"
+#include "cpu.hh"
 #include "vm.hh"

 long

--- a/trap.cc
+++ b/trap.cc
-extern "C" {
 #include "types.h"
 #include "mmu.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "amd64.h"
-#include "cpu.h"
+#include "cpu.hh"
 #include "traps.h"
 #include "queue.h"
 #include "spinlock.h"
-#include "condvar.h"
-#include "proc.h"
+#include "condvar.hh"
+#include "proc.hh"
 #include "kmtrace.h"
 #include "bits.h"
-}

 struct intdesc idt[256] __attribute__((aligned(16)));


--- a/uart.cc
+++ b/uart.cc
 // Intel 8250 serial port (UART).
 // http://en.wikibooks.org/wiki/Serial_Programming/8250_UART_Programming

-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "amd64.h"
 #include "traps.h"
-}

 #define COM2    0x2f8
 #define COM1    0x3f8

--- a/vm.cc
+++ b/vm.cc
-extern "C" {
 #include "types.h"
 #include "amd64.h"
 #include "mmu.h"
-#include "cpu.h"
-#include "kernel.h"
+#include "cpu.hh"
+#include "kernel.hh"
 #include "bits.h"
 #include "spinlock.h"
 #include "kalloc.h"
 #include "queue.h"
-#include "condvar.h"
-#include "proc.h"
-}
-
+#include "condvar.hh"
+#include "proc.hh"
 #include "vm.hh"
 #include "gc.hh"
 #include "crange.hh"

--- a/wq.cc
+++ b/wq.cc
-extern "C" {
 #include "types.h"
-#include "kernel.h"
+#include "kernel.hh"
 #include "spinlock.h"
 #include "amd64.h"
-#include "cpu.h"
-#include "wq.h"
-}
+#include "cpu.hh"
+#include "wq.hh"

 #define NSLOTS (1 << WQSHIFT)


--- a/wq.h
+++ b/wq.h