more progress

makefile

@@ -1,5 +1,8 @@
-floppy: kernel
+cd: kernel fs
-	#TODO
+	mkdir -p out/fs/boot/grub
+	mv out/kernel.elf out/fs/boot/
+	cp src/grub.cfg out/fs/boot/grub/
+	grub2-mkrescue out/fs -o out/cd.iso --product-name=portland --product-version=0.0.9
 
 kernel: obj out
 	nasm src/kernel/stub.asm -o obj/kstub.o -f elf32

src/grub.cfg

@@ -0,0 +1,3 @@
+menuentry "portland" {
+  multiboot2 /boot/kernel.elf
+}

src/kernel/main.c

@@ -68,6 +68,12 @@ enum mem_type {
   DEFECTIVE = 5
 };
 
+struct mmap_tag_entry {
+  uint64_t base;
+  uint64_t length;
+  uint32_t type;
+} __attribute__ ((__packed__));
+
 struct boot_device_tag boot_device;
 bool have_boot_device = false;
 bool have_mmap = false;
@@ -102,50 +108,49 @@ uint32_t main(void) {
       break;
 
     case MEMORY_MAP:
-      mmap_start = (struct mmap_entry *)((uint32_t)&tag_pointer->rest + 8);
+    {
+      struct mmap_tag_entry *tag = (struct mmap_tag_entry *)((uint32_t)&tag_pointer->rest + 8);
       uint32_t size = *(uint32_t *)&tag_pointer->rest;
-      struct mmap_entry *next = mmap_start;
+      struct mmap_entry *entry = (struct mmap_entry *)tag;
-      struct mmap_entry **fill_last = &mmap_start;
+      struct mmap_entry **last_next = &mmap_start;
       uint32_t usable = 0;
-      while (next) {
+      while (tag) {
-        if (!(next->base & 0xffffffff00000000)) {
+        if (!(tag->base & 0xffffffff00000000)) {
-          *fill_last = next;
+          entry->base = (uint32_t)tag->base;
-          fill_last = &next->next;
+          entry->length = (tag->base + tag->length - 1) & 0xffffffff00000000 ?
-          if ((next->base + next->length - 1) & 0xffffffff00000000)
+            1 + ~(uint32_t)tag->base : (uint32_t)tag->length;
-            next->length = 1 + ~(next->base);
           put_sz("Memory: 0x");
-          put_32_hex((uint32_t)(next->base >> 32));
+          put_32_hex(entry->base);
-          put_char('_');
+          put_sz(" - 0x");
-          put_32_hex((uint32_t)next->base);
+          put_32_hex(entry->base + entry->length - 1);
-          put_sz(" - ");
+          switch (tag->type) {
-          put_32_hex((uint32_t)(next->length >> 32));
-          put_char('_');
-          put_32_hex((uint32_t)next->length);
-          switch (next->whose) {
           case AVAILABLE:
             put_sz(": usable\n");
-            next->whose = FREE;
+            entry->whose = FREE;
-            usable += next->length;
+            usable += entry->length;
             break;
           case ACPI:
             put_sz(": ACPI info\n");
-            next->whose = HARDWARE;
+            entry->whose = HARDWARE;
             break;
           case PRESERVE:
             put_sz(": hardware use\n");
-            next->whose = HARDWARE;
+            entry->whose = HARDWARE;
             break;
           case DEFECTIVE:
             put_sz(": defective\n");
-            next->whose = HARDWARE;
+            entry->whose = HARDWARE;
             break;
           default:
             put_sz(": unrecognized type, assuming hardware use\n");
-            next->whose = HARDWARE;
+            entry->whose = HARDWARE;
             break;
           }
+          *last_next = entry;
+          last_next = &entry->next;
+          ++entry;
         }
-        next = next->next = (struct mmap_entry *)((uint32_t)next + size);
+        tag = (struct mmap_tag_entry *)((uint32_t)tag + size);
       }
 
       put_sz("Total usable memory: 0x");
@@ -173,14 +178,14 @@ uint32_t main(void) {
 
       have_mmap = true;
       break;
-
+    }
     default:
       put_sz("Ignoring multiboot tag 0x");
       put_32_hex(tag_pointer->type);
       put_char('\n');
 
     }
-    tag_pointer = (struct tag_start *)((uint8_t *)tag_pointer + tag_pointer->size);
+    tag_pointer = (struct tag_start *)((uint32_t)tag_pointer + tag_pointer->size);
   };
 
   if (!have_boot_device)
@@ -193,7 +198,7 @@ uint32_t main(void) {
     return INSUFF_MEMORY;
   ;
 
-  put_sz("Welcome to Portland version 0.0.8!\n");
+  put_sz("Welcome to Portland version 0.0.9!\n");
   while (1)
     put_sz("|\b/\b-\b\\\b");
 }

src/kernel/mem.c

@@ -20,9 +20,53 @@ OF THIS SOFTWARE.
 #include "mem.h"
 
 void *allocate_block(uint32_t size, uint16_t proc_n) {
-  //TODO
+  struct mmap_entry *i = mmap_start;
+  while (i->whose || (i->length < size))
+    if (i->next)
+      i = i->next;
+    else
+      return (void *)0;
+  if (i->length == size) {
+    i->whose = proc_n;
+    return (void *)i->base;
+  }
+  uint32_t remaining = i->length - size;
+  i->whose = proc_n;
+  i->length = size;
+  struct mmap_entry *new;
+  //TODO: ALLOCATE NEW
+  new->base = i->base + size;
+  new->length = remaining;
+  new->whose = FREE;
+  new->next = i->next;
+  i->next = new;
+  return (void *)i->base;
 }
 
 void deallocate_block(void *start) {
-  //TODO
+  struct mmap_entry *find = mmap_start;
+  while (find->base != (uint32_t)start)
+    if (find->next)
+      find = find->next;
+    else
+      return;
+  find->whose = FREE;
+
+  for (struct mmap_entry *find_after = mmap_start; find_after; find_after = find_after->next)
+    if (find_after->base == find->base + find->length) {
+      if (!find_after->whose) {
+        find->length += find_after->length;
+        find->next = find_after->next;
+      }
+      break;
+    }
+
+  for (struct mmap_entry *find_before = mmap_start; find_before; find_before = find_before->next)
+    if (find->base == find_before->base + find_before->length) {
+      if (!find_before->whose) {
+        find_before->length += find->length;
+        find_before->next = find->next;
+      }
+      break;
+    }
 }

src/kernel/mem.h

@@ -29,11 +29,11 @@ enum special_mmap_codes {
 };
 
 struct mmap_entry {
-  uint64_t base;
+  uint32_t base;
-  uint64_t length;
+  uint32_t length;
-  uint32_t whose;
+  uint16_t whose;
   struct mmap_entry *next;
-} __attribute__ ((__packed__));
+};
 
 struct mmap_entry *mmap_start;
 void *allocate_block(uint32_t size, uint16_t proc_n);