Keep refactoring headers
authorJack Miller <jack@codezen.org>
Fri, 25 Mar 2016 06:13:54 +0000 (01:13 -0500)
committerJack Miller <jack@codezen.org>
Fri, 25 Mar 2016 21:59:18 +0000 (16:59 -0500)
include/kernel.h
include/memmap.h
include/paging.h [new file with mode: 0644]
include/vsalloc.h
mm/vsalloc.c

index 2d4c2c6..cc66711 100644 (file)
@@ -1,7 +1,8 @@
 /* vim: set ts=4 sw=4 sts=4 noet : */
 #pragma once
 
-#include <memmap.h>
 #include <types.h>
-
-void printk(char *format, ...);
+#include <memmap.h>
+#include <console.h>
+#include <page_alloc.h>
+#include <errno.h>
index a9f3ad2..fb7c824 100644 (file)
@@ -1,106 +1,7 @@
 /* vim: set ts=4 sw=4 sts=4 noet : */
 #pragma once
 
-/* 4k page size */
-#define PAGE_SHIFT      12
-#define PAGE_SIZE       (1 << PAGE_SHIFT)
-#define PAGE_MASK      (PAGE_SIZE - 1)
-
-#define PAGE_ALIGN(x)          ((x) & ~PAGE_MASK)
-#define PAGE_ALIGN_OFF(x)      ((x) & PAGE_MASK)
-#define PAGE_ALIGNED(x)                (PAGE_ALIGN_OFF(x) == 0)
-#define PAGE_ALIGN_UP(x)       (PAGE_ALIGN((x) + PAGE_MASK))
-
-#define PTE_SHIFT      (PAGE_SHIFT + 9*0)
-#define PDE_SHIFT      (PAGE_SHIFT + 9*1)
-#define PDPE_SHIFT     (PAGE_SHIFT + 9*2)
-#define PML4E_SHIFT    (PAGE_SHIFT + 9*3)
-
-/* Find index based on virtual address */
-#define PTE(x)         (((x) >> PTE_SHIFT) & 0x1FF)
-#define PDE(x)         (((x) >> PDE_SHIFT) & 0x1FF)
-#define PDPE(x)                (((x) >> PDPE_SHIFT) & 0x1FF)
-#define PML4E(x)       (((x) >> PML4E_SHIFT) & 0x1FF)
-
-/* Find page structure based on virtual address */
-
-/* Because we mapped the PML4 page into itself as the second to last entry, and
- * the structure of the PML4/PDP/PD/PTs are all compatible, we can then use the
- * bits in the virtual address to locate its relevant page structures.
- *
- * With the standard 4-level page tables, the "leaves" are data pages.
- *
- * With the PML4 mapped into itself at 0x1fe, if you have an address with PML4E
- * = 0x1fe, then the PML4 becomes the PDP, the PDP becomes the PD, the PD
- * becomes the PT and PTs are now the leaves and accessible.
- *
- * If you create an address with PML4E = 0x1fe and PDP = 0x1fe, then the PDs
- * are the leaves and accessible.
- *
- * So if we want to access, for example, the page directory for a certain
- * address, we can set PML4E = 0x1fe and PDP = 0x1fe... but what are the rest
- * of the bits? The look ups that the MMU already does! The PML4E in the
- * address becomes the PDE index and the PDPE in the address becomes the PTE
- * index.
- */
-
-/* The BASE definitions are merely handling setting the entries we know need to
- * be 0x1FE for each form of lookup. P_VIRT_BASE is just the sign extension we
- * know must be present for a valid address.
- *
- * As we layed out above, to get the PTs to be the leaf nodes (accessible
- * data), just the PML4E has to be 0x1fe, and so on
- */
-
-#define P_VIRT_BASE    (0xFFFF000000000000)
-#define MAX_VIRT_ADDRESS (0x0000FFFFFFFFFFFF)
-#define PT_VIRT_BASE   (P_VIRT_BASE | ((long) 0x1FE << PML4E_SHIFT))
-#define PD_VIRT_BASE   (PT_VIRT_BASE | ((long) 0x1FE << PDPE_SHIFT))
-#define PDP_VIRT_BASE  (PD_VIRT_BASE | ((long) 0x1FE << PDE_SHIFT))
-#define PML4_VIRT_BASE (PDP_VIRT_BASE | ((long) 0x1FE << PTE_SHIFT))
-
-/*
- * Derive addresses of these entries. This macro is complicated so let's break
- * it down.
- *
- * Let's say I'm trying to find PTE address for 0x12345678, which in binary is:
- *
- * 00 | 01 0010 001 | 1 0100 0101 | 0110 0111 1000
- *    | PDE         | PTE         | PAGE OFFSET
- *
- * There's no sign extension, but nonetheless (x & ~P_VIRT_BASE) doesn't hurt.
- * Then we shift it down by 9, we get
- *
- * 0000 0 | 000 0000 00 | 01 0010 001 | 1 0100 0101 011
- *        | PDE         | PTE         | PAGE OFFSET
- *
- * As you can see, the new PTE is the old PDE, the new PDE is the old PDP (all
- * zeroes) and so forth, but the top three bits of the original page offset are
- * now the bottom three bits of it, and are irrelevant, so we zero them with an
- * (& ~7).
- *
- * 0000 0 | 000 0000 00 | 01 0010 001 | 1 0100 0101 000
- *        | PDE         | PTE         | PAGE OFFSET
- *
- * Now that we've properly shifted all of our lookups, and discarded the
- * unnecessary page offset and sign extension bits, we can and in the BASE,
- * which as explained above is a constructed value where all of the unset
- * lookups are set to 0x1fe. In this case, our PML4E which is now 0 thanks to
- * shifting, needs to be set to 0x1fe, which is exactly what PT_VIRT_BASE
- * includes, along with the sign extension required due to the top bit of the
- * PML4E being 1
- */
-
-#define PTE_ADDR(x)      (PT_VIRT_BASE  | (((x & ~P_VIRT_BASE) >> 9)  & ~7))
-#define PDE_ADDR(x)      (PD_VIRT_BASE  | (((x & ~P_VIRT_BASE) >> 18) & ~7))
-#define PDPE_ADDR(x)     (PDP_VIRT_BASE  | (((x & ~P_VIRT_BASE) >> 27) & ~7))
-#define PML4E_ADDR(x)    (PML4_VIRT_BASE | (((x & ~P_VIRT_BASE) >> 36) & ~7))
-
-#define PF_P                (1 << 0)
-#define PF_RW               (1 << 1)
-#define PF_USER             (1 << 2)
-#define PF_WRITETHRU        (1 << 3)
-#define PF_DISABLE_CACHE    (1 << 4)
+#include <paging.h>
 
 /* Early physical addresses */
 #define KERNEL_START 0x100000
diff --git a/include/paging.h b/include/paging.h
new file mode 100644 (file)
index 0000000..4b1aaea
--- /dev/null
@@ -0,0 +1,103 @@
+/* vim: set ts=4 sw=4 sts=4 noet : */
+#pragma once
+
+/* 4k page size */
+#define PAGE_SHIFT      12
+#define PAGE_SIZE       (1 << PAGE_SHIFT)
+#define PAGE_MASK      (PAGE_SIZE - 1)
+
+#define PAGE_ALIGN(x)          ((x) & ~PAGE_MASK)
+#define PAGE_ALIGN_OFF(x)      ((x) & PAGE_MASK)
+#define PAGE_ALIGNED(x)                (PAGE_ALIGN_OFF(x) == 0)
+#define PAGE_ALIGN_UP(x)       (PAGE_ALIGN((x) + PAGE_MASK))
+
+#define PTE_SHIFT      (PAGE_SHIFT + 9*0)
+#define PDE_SHIFT      (PAGE_SHIFT + 9*1)
+#define PDPE_SHIFT     (PAGE_SHIFT + 9*2)
+#define PML4E_SHIFT    (PAGE_SHIFT + 9*3)
+
+/* Find index based on virtual address */
+#define PTE(x)         (((x) >> PTE_SHIFT) & 0x1FF)
+#define PDE(x)         (((x) >> PDE_SHIFT) & 0x1FF)
+#define PDPE(x)                (((x) >> PDPE_SHIFT) & 0x1FF)
+#define PML4E(x)       (((x) >> PML4E_SHIFT) & 0x1FF)
+
+/* Find page structure based on virtual address */
+
+/* Because we mapped the PML4 page into itself as the second to last entry, and
+ * the structure of the PML4/PDP/PD/PTs are all compatible, we can then use the
+ * bits in the virtual address to locate its relevant page structures.
+ *
+ * With the standard 4-level page tables, the "leaves" are data pages.
+ *
+ * With the PML4 mapped into itself at 0x1fe, if you have an address with PML4E
+ * = 0x1fe, then the PML4 becomes the PDP, the PDP becomes the PD, the PD
+ * becomes the PT and PTs are now the leaves and accessible.
+ *
+ * If you create an address with PML4E = 0x1fe and PDP = 0x1fe, then the PDs
+ * are the leaves and accessible.
+ *
+ * So if we want to access, for example, the page directory for a certain
+ * address, we can set PML4E = 0x1fe and PDP = 0x1fe... but what are the rest
+ * of the bits? The look ups that the MMU already does! The PML4E in the
+ * address becomes the PDE index and the PDPE in the address becomes the PTE
+ * index.
+ */
+
+/* The BASE definitions are merely handling setting the entries we know need to
+ * be 0x1FE for each form of lookup. P_VIRT_BASE is just the sign extension we
+ * know must be present for a valid address.
+ *
+ * As we layed out above, to get the PTs to be the leaf nodes (accessible
+ * data), just the PML4E has to be 0x1fe, and so on
+ */
+
+#define P_VIRT_BASE    (0xFFFF000000000000)
+#define MAX_VIRT_ADDRESS (0x0000FFFFFFFFFFFF)
+#define PT_VIRT_BASE   (P_VIRT_BASE | ((long) 0x1FE << PML4E_SHIFT))
+#define PD_VIRT_BASE   (PT_VIRT_BASE | ((long) 0x1FE << PDPE_SHIFT))
+#define PDP_VIRT_BASE  (PD_VIRT_BASE | ((long) 0x1FE << PDE_SHIFT))
+#define PML4_VIRT_BASE (PDP_VIRT_BASE | ((long) 0x1FE << PTE_SHIFT))
+
+/*
+ * Derive addresses of these entries. This macro is complicated so let's break
+ * it down.
+ *
+ * Let's say I'm trying to find PTE address for 0x12345678, which in binary is:
+ *
+ * 00 | 01 0010 001 | 1 0100 0101 | 0110 0111 1000
+ *    | PDE         | PTE         | PAGE OFFSET
+ *
+ * There's no sign extension, but nonetheless (x & ~P_VIRT_BASE) doesn't hurt.
+ * Then we shift it down by 9, we get
+ *
+ * 0000 0 | 000 0000 00 | 01 0010 001 | 1 0100 0101 011
+ *        | PDE         | PTE         | PAGE OFFSET
+ *
+ * As you can see, the new PTE is the old PDE, the new PDE is the old PDP (all
+ * zeroes) and so forth, but the top three bits of the original page offset are
+ * now the bottom three bits of it, and are irrelevant, so we zero them with an
+ * (& ~7).
+ *
+ * 0000 0 | 000 0000 00 | 01 0010 001 | 1 0100 0101 000
+ *        | PDE         | PTE         | PAGE OFFSET
+ *
+ * Now that we've properly shifted all of our lookups, and discarded the
+ * unnecessary page offset and sign extension bits, we can and in the BASE,
+ * which as explained above is a constructed value where all of the unset
+ * lookups are set to 0x1fe. In this case, our PML4E which is now 0 thanks to
+ * shifting, needs to be set to 0x1fe, which is exactly what PT_VIRT_BASE
+ * includes, along with the sign extension required due to the top bit of the
+ * PML4E being 1
+ */
+
+#define PTE_ADDR(x)      (PT_VIRT_BASE  | (((x & ~P_VIRT_BASE) >> 9)  & ~7))
+#define PDE_ADDR(x)      (PD_VIRT_BASE  | (((x & ~P_VIRT_BASE) >> 18) & ~7))
+#define PDPE_ADDR(x)     (PDP_VIRT_BASE  | (((x & ~P_VIRT_BASE) >> 27) & ~7))
+#define PML4E_ADDR(x)    (PML4_VIRT_BASE | (((x & ~P_VIRT_BASE) >> 36) & ~7))
+
+#define PF_P                (1 << 0)
+#define PF_RW               (1 << 1)
+#define PF_USER             (1 << 2)
+#define PF_WRITETHRU        (1 << 3)
+#define PF_DISABLE_CACHE    (1 << 4)
index 7837239..aa57b54 100644 (file)
@@ -1,5 +1,4 @@
-#ifndef VSALLOC_H
-#define VSALLOC_H
+#pragma once
 
 #include <types.h>
 
@@ -9,4 +8,12 @@ void *vsalloc(char *name, u64 address_hint, u64 size);
 void vfree(u64 address, u64 size);
 void vsalloc_vspace(char *name, u64 address, u64 size);
 
+#define TEST_VSALLOC
+
+#ifdef TEST_VSALLOC
+void test_alloc_vspace(void);
+void test_vsalloc(void);
+#else
+#define test_alloc_vspace(...)
+#define test_vsalloc(...)
 #endif
index 7039d52..e5d6c8a 100644 (file)
@@ -2,13 +2,8 @@
 
 /* Virtual address space allocator */
 
-#include <memmap.h>
-#include <page_alloc.h>
+#include <kernel.h>
 #include <vsalloc.h>
-#include <types.h>
-#include <errno.h>
-
-#define TEST_VSALLOC
 
 /* NOTE: The names are included here, but as we have no string functions, or
  * even display capability, these are unused for the moment */
@@ -201,8 +196,32 @@ void *vsalloc(char *name, u64 address_hint, u64 size)
 }
 
 
-#ifdef TEST_VSALLOC
+void vsalloc_vspace(char *name, u64 address, u64 size)
+{
+       __alloc_vspace(&kernel_virtual_space, name, address, size);
+}
+
+void vfree(u64 address, u64 size)
+{
+       __free_vspace(&kernel_virtual_space, address, size);
+}
+
+extern struct early_reserve early_reserves_start;
+extern struct early_reserve early_reserves_end;
 
+void vsalloc_init(void)
+{
+       /* Grab a page to work with */
+
+       virtual_alloc = page_alloc_to_virtual(VSALLOC_HEAP_VIRTUAL, alloc_order);
+
+       test_alloc_vspace();
+       test_vsalloc();
+
+       __alloc_vspace(&kernel_virtual_space, "vsalloc", VSALLOC_HEAP_VIRTUAL, (1 << (alloc_order + PAGE_SHIFT)));
+}
+
+#ifdef TEST_VSALLOC
 struct virtual_block *test_virtual_space = NULL;
 
 static inline void __vblock_assert(u32 index, u64 address, u64 size, int next_null)
@@ -313,32 +332,4 @@ void test_vsalloc(void)
        used_vblocks = 0;
        kernel_virtual_space = NULL;
 }
-
 #endif
-
-void vsalloc_vspace(char *name, u64 address, u64 size)
-{
-       __alloc_vspace(&kernel_virtual_space, name, address, size);
-}
-
-void vfree(u64 address, u64 size)
-{
-       __free_vspace(&kernel_virtual_space, address, size);
-}
-
-extern struct early_reserve early_reserves_start;
-extern struct early_reserve early_reserves_end;
-
-void vsalloc_init(void)
-{
-       /* Grab a page to work with */
-
-       virtual_alloc = page_alloc_to_virtual(VSALLOC_HEAP_VIRTUAL, alloc_order);
-
-#ifdef TEST_VSALLOC
-       test_alloc_vspace();
-       test_vsalloc();
-#endif
-
-       __alloc_vspace(&kernel_virtual_space, "vsalloc", VSALLOC_HEAP_VIRTUAL, (1 << (alloc_order + PAGE_SHIFT)));
-}