Initial commit: Schunix as it stands before the SchOS rename

An x86-64 operating system built from xv6, now largely rewritten: SMP,
a copy-on-write root filesystem (SchFS), PCI/USB/virtio drivers, a TTF
rasteriser, and a Linux-numbered syscall ABI.

No history before this point -- the tree was never under version control.
This commit exists so the rename that follows has something to undo to.

kernel/core/kalloc.c

@@ -0,0 +1,124 @@
+// Physical memory allocator, intended to allocate
+// memory for user processes, kernel stacks, page table pages,
+// and pipe buffers. Allocates 4096-byte pages.
+
+#include "types.h"
+#include "defs.h"
+#include "param.h"
+#include "memlayout.h"
+#include "mmu.h"
+#include "spinlock.h"
+
+void freerange(void *vstart, void *vend);
+extern char end[]; // first address after kernel loaded from ELF file
+
+
+struct run {
+  struct run *next;
+};
+
+struct {
+  struct spinlock lock;
+  int use_lock;
+  struct run *freelist;
+} kmem;
+
+// Catch kmem.freelist corruption at the point it's touched, rather than
+// letting a bad pointer be silently returned by kalloc() and crash whatever
+// code dereferences it minutes later on an unrelated call stack.
+static void
+check_run(struct run *r, char *where)
+{
+  if(r == 0)
+    return;
+  if((addr_t)r % PGSIZE || (char*)r < end || V2P(r) >= PHYSTOP){
+    cprintf("kalloc: corrupt freelist entry %p at %s\n", r, where);
+    panic("kalloc: corrupt freelist");
+  }
+}
+
+void
+kinit1(void *vstart, void *vend)
+{
+  initlock(&kmem.lock, "kmem");
+  kmem.use_lock = 0;
+  kmem.freelist = 0; // empty
+  freerange(vstart, vend);
+}
+
+void
+kinit2()
+{
+  kmem.use_lock = 1;
+}
+
+void
+freerange(void *vstart, void *vend)
+{
+  char *p;
+  p = (char*)PGROUNDUP((addr_t)vstart);
+  for(; p + PGSIZE <= (char*)vend; p += PGSIZE)
+    kfree(p);
+}
+
+// Free the page of physical memory pointed at by v,
+// which normally should have been returned by a
+// call to kalloc().  (The exception is when
+// initializing the allocator; see kinit above.)
+void
+kfree(char *v)
+{
+  struct run *r;
+
+  if((addr_t)v % PGSIZE || v < end || V2P(v) >= PHYSTOP)
+    panic("kfree");
+
+  // Fill with junk to catch dangling refs.
+  memset(v, 1, PGSIZE);
+
+  if(kmem.use_lock)
+    acquire(&kmem.lock);
+  check_run(kmem.freelist, "kfree entry");
+  r = (struct run*)v;
+  r->next = kmem.freelist;
+  kmem.freelist = r;
+  if(kmem.use_lock)
+    release(&kmem.lock);
+}
+
+// Allocate one 4096-byte page of physical memory.
+// Returns a pointer that the kernel can use.
+// Returns 0 if the memory cannot be allocated.
+char*
+kalloc(void)
+{
+  struct run *r;
+
+  if(kmem.use_lock)
+    acquire(&kmem.lock);
+  check_run(kmem.freelist, "kalloc entry");
+  r = kmem.freelist;
+  if(r)
+    kmem.freelist = r->next;
+
+  if(kmem.use_lock)
+    release(&kmem.lock);
+  return (char*)r;
+}
+
+// Total free physical memory, in bytes. Walks the free list; only /proc
+// readers call it, so the O(n) scan is not on any hot path.
+uint64
+kalloc_free_bytes(void)
+{
+  struct run *r;
+  uint64 n = 0;
+
+  if(kmem.use_lock)
+    acquire(&kmem.lock);
+  for(r = kmem.freelist; r; r = r->next)
+    n += PGSIZE;
+  if(kmem.use_lock)
+    release(&kmem.lock);
+  return n;
+}