GDT finally works

kernel/bitmap/bitmap.c

@@ -0,0 +1,117 @@
+#include <stdint.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include "bitmap.h"
+
+#define DIV_ROUNDUP(num, div) ((num + div - 1) / div)
+
+void *bitmap_toptr(BitMap *bm, size_t block) {
+  uint8_t *ptr = (uint8_t *)(bm->mem_start + (block * BITMAP_BLOCK_SIZE));
+  return (void *)ptr;
+}
+
+size_t bitmap_toblock(BitMap *bm, void *ptr) {
+  uint8_t *p = ptr;
+  return (size_t)(p - bm->mem_start) / BITMAP_BLOCK_SIZE;
+}
+
+size_t bitmap_toblock_roundup(BitMap *bm, void *ptr) {
+  uint8_t *p = ptr;
+  return (size_t)DIV_ROUNDUP((size_t)(p - bm->mem_start), BITMAP_BLOCK_SIZE);
+}
+
+size_t bitmap_calcsize(size_t total) {
+  size_t nblocks = DIV_ROUNDUP(total, BITMAP_BLOCK_SIZE);
+  size_t nbytes = DIV_ROUNDUP(nblocks, 8);
+  return nbytes;
+}
+
+bool bitmap_get(BitMap *bm, size_t block) {
+  size_t elem = block / BITMAP_BLOCKS_PER_BYTE;
+  size_t off = block % BITMAP_BLOCKS_PER_BYTE;
+  return (bm->map[elem] & (1 << off)) != 0;
+}
+
+void bitmap_set(BitMap *bm, size_t block, bool value) {
+  size_t elem = block / BITMAP_BLOCKS_PER_BYTE;
+  size_t off = block % BITMAP_BLOCKS_PER_BYTE;
+  if (value) {
+    bm->map[elem] |= (1 << off);
+  } else {
+    bm->map[elem] &= ~(1 << off);
+  }
+}
+
+void bitmap_markblocks(BitMap *bm, size_t start, size_t size, bool value) {
+  if (!value && start < bm->last_deep_frag) {
+    bm->last_deep_frag = start;
+  }
+
+  for (size_t i = start; i < start + size; i++) {
+    bitmap_set(bm, i, value);
+  }
+
+  bm->alloc_blocks += value ? size : -size;
+}
+
+void bitmap_markregion(BitMap *bm, void *baseptr, size_t size, bool is_used) {
+  size_t base, size1;
+
+  if (is_used) {
+    base = bitmap_toblock(bm, baseptr);
+    size1 = DIV_ROUNDUP(size, BITMAP_BLOCK_SIZE);
+  } else {
+    base = bitmap_toblock(bm, baseptr);
+    size1 = size / BITMAP_BLOCK_SIZE;
+  }
+  bitmap_markblocks(bm, base, size1, is_used);
+}
+
+size_t bitmap_freeregion(BitMap *bm, size_t blocks) {
+  size_t curregstart = bm->last_deep_frag;
+  size_t curregsize = 0;
+  for (size_t i = curregstart; i < bm->nblocks; i++) {
+    if (bitmap_get(bm, i)) {
+      curregsize = 0;
+      curregstart = i + 1;
+    } else {
+      if (blocks == 1) {
+        bm->last_deep_frag = curregstart + 1;
+      }
+
+      curregsize++;
+      if (curregsize >= blocks) {
+        return curregstart;
+      }
+    }
+  }
+  return BITMAP_INVALID_BLOCK;
+}
+
+void *bitmap_alloc(BitMap *bm, size_t blocks) {
+  if (!blocks) {
+    return NULL;
+  }
+
+  size_t pickedreg = bitmap_freeregion(bm, blocks);
+  if (pickedreg == BITMAP_INVALID_BLOCK) {
+    return NULL;
+  }
+
+  bitmap_markblocks(bm, pickedreg, blocks, 1);
+  return bitmap_toptr(bm, pickedreg);
+}
+
+void bitmap_free(BitMap *bm, void *base, size_t blocks) {
+  bitmap_markregion(bm, base, BITMAP_BLOCK_SIZE * blocks, 0);
+}
+
+size_t bitmap_allocpageframe(BitMap *bm) {
+  size_t pickedreg = bitmap_freeregion(bm, 1);
+  bitmap_markblocks(bm, pickedreg, 1, 1);
+  return (bm->mem_start + (pickedreg * BITMAP_BLOCK_SIZE));
+}
+
+void bitmap_freepageframe(BitMap *bm, void *addr) {
+  bitmap_markregion(bm, addr, BITMAP_BLOCK_SIZE * 1, 0);
+}