Replaces instances of kern_paddr_t with paddr_t

include/kernel/domain/alloc/page_alloc.h

@@ -34,17 +34,17 @@
 
 #include <kernel/types.h>
 
-#define PFNULL ((kern_paddr_t)-1)
+#define PFNULL ((paddr_t)-1)
 
 void *page_alloc(void);
 
 void page_free(void *page);
 
 unsigned int get_page_count(void);
 
-bool add_page_frame(kern_paddr_t paddr);
+bool add_page_frame(paddr_t paddr);
 
-kern_paddr_t remove_page_frame(void);
+paddr_t remove_page_frame(void);
 
 void clear_page(void *page);
 

include/kernel/domain/services/mman.h

@@ -35,7 +35,7 @@
 #include <kernel/machine/types.h>
 #include <stddef.h>
 
-void *map_in_kernel(kern_paddr_t paddr, size_t size, int prot);
+void *map_in_kernel(paddr_t paddr, size_t size, int prot);
 
 void resize_map_in_kernel(size_t size);
 

include/kernel/infrastructure/acpi/acpi.h

@@ -35,14 +35,15 @@
 #include <kernel/machine/types.h>
 #include <kernel/infrastructure/acpi/tables.h>
 #include <kernel/infrastructure/acpi/types.h>
+#include <kernel/machine/types.h>
 #include <stdbool.h>
 #include <stddef.h>
 
 bool verify_acpi_checksum(const void *buffer, size_t buflen);
 
 bool validate_acpi_rsdp(const acpi_rsdp_t *rsdp);
 
-void map_acpi_tables(kern_paddr_t rsdp_paddr, const acpi_table_def_t *table_defs);
+void map_acpi_tables(paddr_t rsdp_paddr, const acpi_table_def_t *table_defs);
 
 void report_acpi_tables(const acpi_table_def_t *table_defs);
 

include/kernel/infrastructure/i686/exports/types.h

@@ -37,15 +37,10 @@
 /* This file contains the machine-specific definitions that need to be visible
  * outside the machine-specific parts of the code. */
 
-/** Physical memory address for use by the kernel */
-typedef uint32_t kern_paddr_t;
-
 /** Physical memory address */
 typedef uint64_t paddr_t;
 
-#define PRIxKPADDR PRIx32
-
-#define PRIxUPADDR PRIx64
+#define PRIxPADDR PRIx64
 
 /** incomplete structure declaration for a page table entry
  *

include/kernel/infrastructure/i686/firmware/acpi.h

@@ -41,6 +41,6 @@ void init_acpi(void);
 
 void report_acpi(void);
 
-kern_paddr_t acpi_get_rsdp_paddr(void);
+uint32_t acpi_get_rsdp_paddr(void);
 
 #endif

include/kernel/infrastructure/i686/pmap/pmap.h

@@ -49,16 +49,16 @@
 #define VIRT_TO_PHYS_AT_1MB(x)      (((uintptr_t)(x)) - BOOT_OFFSET_FROM_1MB)
 
 /** convert pointer to physical address for kernel loaded at 0x100000 (1MB) */
-#define PTR_TO_PHYS_ADDR_AT_1MB(x)  ((kern_paddr_t)VIRT_TO_PHYS_AT_1MB(x))
+#define PTR_TO_PHYS_ADDR_AT_1MB(x)  ((paddr_t)VIRT_TO_PHYS_AT_1MB(x))
 
 /** convert physical to virtual address for kernel loaded at 0x1000000 (16MB) */
-#define PHYS_TO_VIRT_AT_16MB(x)      (((uintptr_t)(x)) + BOOT_OFFSET_FROM_16MB)
+#define PHYS_TO_VIRT_AT_16MB(x)     (((uintptr_t)(x)) + BOOT_OFFSET_FROM_16MB)
 
 /** convert virtual to physical address for kernel loaded at 0x1000000 (16MB) */
-#define VIRT_TO_PHYS_AT_16MB(x)      (((uintptr_t)(x)) - BOOT_OFFSET_FROM_16MB)
+#define VIRT_TO_PHYS_AT_16MB(x)     (((uintptr_t)(x)) - BOOT_OFFSET_FROM_16MB)
 
 /** convert pointer to physical address for kernel loaded at 0x1000000 (16MB) */
-#define PTR_TO_PHYS_ADDR_AT_16MB(x)  ((kern_paddr_t)VIRT_TO_PHYS_AT_16MB(x))
+#define PTR_TO_PHYS_ADDR_AT_16MB(x)  ((paddr_t)VIRT_TO_PHYS_AT_16MB(x))
 
 #define ADDR_4GB    UINT64_C(0x100000000)
 
@@ -77,19 +77,4 @@ void pmap_destroy_addr_space(addr_space_t *addr_space);
 
 void pmap_switch_addr_space(addr_space_t *addr_space);
 
-void pmap_map_kernel_page(void *vaddr, kern_paddr_t paddr, int flags);
-
-void pmap_unmap_kernel_page(void *addr);
-
-void pmap_unmap_userspace(addr_space_t *addr_space, void *addr);
-
-bool pmap_clone_range(
-        addr_space_t    *dest_addr_space,
-        addr_space_t    *src_addr_space,
-        addr_t           dest_addr,
-        addr_t           src_addr,
-        size_t           length,
-        int              prot);
-
 #endif
-

include/kernel/interface/i686/types.h

@@ -50,7 +50,7 @@ typedef struct {
     size_t                   loader_size;
     void                    *image_start;
     void                    *image_top;
-    kern_paddr_t             ramdisk_start;
+    uint32_t                 ramdisk_start;
     size_t	                 ramdisk_size;
     const acpi_addr_range_t *acpi_addr_map;
     uint32_t                 addr_map_entries;

include/kernel/machine/pmap.h

@@ -34,7 +34,7 @@
 
 #include <kernel/types.h>
 
-void machine_map_kernel_page(void *vaddr, kern_paddr_t paddr, int prot);
+void machine_map_kernel_page(void *vaddr, paddr_t paddr, int prot);
 
 void machine_unmap_kernel_page(void *addr);
 
@@ -53,6 +53,6 @@ bool machine_clone_userspace_mapping(
         size_t       length,
         int          prot) ;
 
-kern_paddr_t machine_lookup_kernel_paddr(const void *addr);
+paddr_t machine_lookup_kernel_paddr(const void *addr);
 
 #endif

include/kernel/types.h

@@ -146,8 +146,8 @@ typedef struct {
 } exec_file_t;
 
 typedef struct {
-    kern_paddr_t    start;
-    size_t          size;
+    paddr_t start;
+    size_t  size;
 } kern_mem_block_t;
 
 typedef struct {

kernel/application/kmain.c

@@ -75,7 +75,7 @@ void kmain(const char *cmdline) {
     machine_get_ramdisk(&ramdisk);
 
     info(
-        "Found RAM disk with size %zu bytes at address %#" PRIxKPADDR ".",
+        "Found RAM disk with size %zu bytes at address %#" PRIxPADDR ".",
         ramdisk.size,
         ramdisk.start
     );

kernel/domain/alloc/page_alloc.c

@@ -118,7 +118,7 @@ unsigned int get_page_count(void) {
  * @return true if the function succeeded
  *
  * */
-bool add_page_frame(kern_paddr_t paddr) {
+bool add_page_frame(paddr_t paddr) {
     void *page = vmalloc();
 
     if(page == NULL) {
@@ -149,7 +149,7 @@ bool add_page_frame(kern_paddr_t paddr) {
  * @return physical address of the freed page frame, or PFNULL if none is available
  *
  * */
-kern_paddr_t remove_page_frame(void) {
+paddr_t remove_page_frame(void) {
     void *page = page_alloc();
 
     if(page == NULL) {
@@ -161,7 +161,7 @@ kern_paddr_t remove_page_frame(void) {
      * for exploiting vulnerabilities. */
     clear_page(page);
 
-    kern_paddr_t paddr = machine_lookup_kernel_paddr(page);
+    paddr_t paddr = machine_lookup_kernel_paddr(page);
 
     machine_unmap_kernel_page(page);
 

kernel/domain/services/mman.c

@@ -61,7 +61,7 @@ static struct {
  * @param size size of memory to map
  * @param prot mapping protection flags
  */
-void *map_in_kernel(kern_paddr_t paddr, size_t size, int prot) {
+void *map_in_kernel(paddr_t paddr, size_t size, int prot) {
     size_t offset = paddr % PAGE_SIZE;
 
     size += offset;
@@ -76,7 +76,7 @@ void *map_in_kernel(kern_paddr_t paddr, size_t size, int prot) {
     alloc_state.latest_prot     = prot;
 
     addr_t map_addr = start;
-    kern_paddr_t map_paddr = paddr - offset;
+    paddr_t map_paddr = paddr - offset;
 
     while(true) {
         machine_map_kernel_page(map_addr, map_paddr, prot);
@@ -114,10 +114,11 @@ void resize_map_in_kernel(size_t size) {
 
     /* Map additional pages if the mapping is grown. */
 
-    kern_paddr_t paddr = machine_lookup_kernel_paddr(start) + (new_end - old_end);
+    paddr_t paddr = machine_lookup_kernel_paddr(start) + (new_end - old_end);
 
     for(addr_t page_addr = old_end; page_addr < (addr_t)new_end; page_addr += PAGE_SIZE) {
         machine_map_kernel_page(page_addr, paddr, prot);
+        /* TODO recheck this */
         ++paddr;
     }
 

kernel/infrastructure/acpi/acpi.c

@@ -106,7 +106,7 @@ static bool verify_table_signature(const acpi_table_header_t *header, const char
  * @return pointer to mapped RSDP on success, NULL on error
  *
  * */
-static const acpi_rsdp_t *map_rsdp(uint64_t paddr) {
+static const acpi_rsdp_t *map_rsdp(paddr_t paddr) {
     return map_in_kernel(paddr, sizeof(acpi_rsdp_t), JINUE_PROT_READ);
 }
 
@@ -142,7 +142,7 @@ static const void *map_table(const acpi_table_header_t *header) {
  * @return pointer to mapped header on success, NULL on error
  *
  * */
-static const acpi_table_header_t *map_header(kern_paddr_t paddr) {
+static const acpi_table_header_t *map_header(paddr_t paddr) {
     return map_in_kernel(paddr, sizeof(acpi_table_header_t), JINUE_PROT_READ);
 }
 
@@ -225,6 +225,7 @@ static void process_rsdt(const acpi_rsdt_t *rsdt, bool is_xsdt, const acpi_table
 
     for(int idx = 0; idx < entries; ++idx) {
         /* x86 is little endian */
+        /* TODO this part is not portable across architectures */
         uint64_t paddr = rsdt->entries[idx];
 
         if(is_xsdt) {
@@ -247,7 +248,7 @@ static void process_rsdt(const acpi_rsdt_t *rsdt, bool is_xsdt, const acpi_table
  * @param rsdp_paddr physical memory address of the RSDP
  * @param table_defs table definitions array terminated by a NULL signature
  */
-void map_acpi_tables(kern_paddr_t rsdp_paddr, const acpi_table_def_t *table_defs) {
+void map_acpi_tables(paddr_t rsdp_paddr, const acpi_table_def_t *table_defs) {
     const acpi_rsdp_t *rsdp = map_rsdp(rsdp_paddr);
 
     uint64_t rsdt_paddr;

kernel/infrastructure/i686/boot_alloc.c

@@ -47,7 +47,7 @@
  * This function sets up the allocator to allocate pages after the kernel loaded
  * at 0x100000 (1MB). Once the kernel has been moved to 0x1000000 (16MB), the
  * boot_alloc_reinit_at_16mb() function has to be called to start allocating pages
- * there.
+ * there instead.
  *
  * @param boot_alloc the allocator state initialized by this function
  * @param bootinfo boot information structure
@@ -58,7 +58,7 @@ void boot_alloc_init(boot_alloc_t *boot_alloc, const bootinfo_t *bootinfo) {
     boot_alloc->heap_ptr = bootinfo->boot_heap;
     /* TODO handle heap limit. */
 
-    boot_alloc->current_page        = (void *)PTR_TO_PHYS_ADDR_AT_1MB(bootinfo->boot_end);
+    boot_alloc->current_page        = (void *)VIRT_TO_PHYS_AT_1MB(bootinfo->boot_end);
     boot_alloc->page_limit          = (char *)MEMORY_ADDR_1MB + BOOT_SIZE_AT_1MB;
     boot_alloc->first_page_at_16mb  = (char *)bootinfo->page_table_1mb + 15 * MB;
 }

kernel/infrastructure/i686/firmware/acpi.c

@@ -161,6 +161,6 @@ void report_acpi(void) {
  *
  * @return physical address of RSDP if found, zero otherwise
  */
-kern_paddr_t acpi_get_rsdp_paddr(void) {
+uint32_t acpi_get_rsdp_paddr(void) {
     return rsdp_paddr;
 }

kernel/infrastructure/i686/pmap/pae.c

@@ -375,10 +375,10 @@ bool pae_create_addr_space(addr_space_t *addr_space, pte_t *first_page_directory
     }
 
     /* Lookup the physical address of the page where the PDPT resides. */
-    kern_paddr_t pdpt_page_paddr = machine_lookup_kernel_paddr((addr_t)page_address_of(pdpt));
+    paddr_t pdpt_page_paddr = machine_lookup_kernel_paddr((addr_t)page_address_of(pdpt));
 
     /* physical address of PDPT */
-    kern_paddr_t pdpt_paddr = pdpt_page_paddr | page_offset_of(pdpt);
+    paddr_t pdpt_paddr = pdpt_page_paddr | page_offset_of(pdpt);
 
     addr_space->top_level.pdpt  = pdpt;
     addr_space->cr3             = pdpt_paddr;

kernel/infrastructure/i686/pmap/pmap.c

@@ -778,8 +778,7 @@ static bool map_page(
  * @param paddr address of page frame
  * @param prot protections flags
  */
-void machine_map_kernel_page(void *vaddr, kern_paddr_t paddr, int prot) {
-    /* TODO the kern_paddr_t type prevents this function from supporting addresses above 4GB. */
+void machine_map_kernel_page(void *vaddr, paddr_t paddr, int prot) {
     assert(is_kernel_pointer(vaddr));
     map_page(NULL, vaddr, paddr, map_page_access_flags(prot) | X86_PTE_GLOBAL);
 }
@@ -937,12 +936,12 @@ bool machine_clone_userspace_mapping(
  * @param addr virtual address of kernel page
  * @return physical address of page frame
  */
-kern_paddr_t machine_lookup_kernel_paddr(const void *addr) {
+paddr_t machine_lookup_kernel_paddr(const void *addr) {
     assert( is_kernel_pointer(addr) );
 
     pte_t *pte = lookup_page_table_entry(NULL, addr, false, NULL);
 
     assert(pte != NULL && pte_is_present(pte));
 
-    return (kern_paddr_t)get_pte_paddr(pte);
+    return get_pte_paddr(pte);
 }