Declare memory pools from linker symbols

Defines static memory pools for boot-time PMP initialization using
linker symbols to identify kernel memory regions.

Linker symbol declarations are updated to include text segment
boundaries and match actual linker script definitions for stack
regions. Five kernel memory pools protect text as read-execute, data
and bss as read-write, heap and stack as read-write without execute
to prevent code injection.

Macro helpers reduce initialization boilerplate while maintaining
debuggability through struct arrays. Priority-based management handles
the 16-region hardware constraint.

Author: HeatCrab

arch/riscv/hal.h

@@ -3,13 +3,14 @@
 #include <types.h>
 
 /* Symbols from the linker script, defining memory boundaries */
-extern uint32_t _stack_start, _stack_end; /* Start/end of the STACK memory */
-extern uint32_t _heap_start, _heap_end;   /* Start/end of the HEAP memory */
-extern uint32_t _heap_size;               /* Size of HEAP memory */
+extern uint32_t _stext, _etext; /* Start/end of the .text section */
 extern uint32_t _sidata;        /* Start address for .data initialization */
 extern uint32_t _sdata, _edata; /* Start/end address for .data section */
 extern uint32_t _sbss, _ebss;   /* Start/end address for .bss section */
 extern uint32_t _end;           /* End of kernel image */
+extern uint32_t _heap_start, _heap_end;     /* Start/end of the HEAP memory */
+extern uint32_t _heap_size;                 /* Size of HEAP memory */
+extern uint32_t _stack_bottom, _stack_top;  /* Bottom/top of the STACK memory */
 
 /* Read a RISC-V Control and Status Register (CSR).
  * @reg : The symbolic name of the CSR (e.g., mstatus).

arch/riscv/pmp.c

@@ -0,0 +1,91 @@
+/* RISC-V Physical Memory Protection (PMP) Implementation
+ *
+ * Provides hardware-enforced memory isolation using PMP in TOR mode.
+ */
+
+#include <hal.h>
+#include <sys/memprot.h>
+#include "csr.h"
+#include "pmp.h"
+
+/* Static Memory Pools for Boot-time PMP Initialization
+ *
+ * Defines kernel memory regions protected at boot. Each pool specifies
+ * a memory range and access permissions.
+ */
+static const mempool_t kernel_mempools[] = {
+    DECLARE_MEMPOOL("kernel_text", &_stext, &_etext, PMPCFG_PERM_RX,
+                    PMP_PRIORITY_KERNEL),
+    DECLARE_MEMPOOL("kernel_data", &_sdata, &_edata, PMPCFG_PERM_RW,
+                    PMP_PRIORITY_KERNEL),
+    DECLARE_MEMPOOL("kernel_bss", &_sbss, &_ebss, PMPCFG_PERM_RW,
+                    PMP_PRIORITY_KERNEL),
+    DECLARE_MEMPOOL("kernel_heap", &_heap_start, &_heap_end, PMPCFG_PERM_RW,
+                    PMP_PRIORITY_KERNEL),
+    DECLARE_MEMPOOL("kernel_stack", &_stack_bottom, &_stack_top, PMPCFG_PERM_RW,
+                    PMP_PRIORITY_KERNEL),
+};
+
+#define KERNEL_MEMPOOL_COUNT \
+    (sizeof(kernel_mempools) / sizeof(kernel_mempools[0]))
+
+/* Initialize PMP from Memory Pools
+ *
+ * Configures PMP regions based on static memory pool definitions.
+ * Should be called during early boot before task scheduling begins.
+ *
+ * @config : Pointer to PMP configuration state
+ * @pools : Array of memory pool descriptors
+ * @count : Number of pools in the array
+ * Returns 0 on success, or negative error code on failure.
+ */
+int32_t pmp_init_pools(pmp_config_t *config, const mempool_t *pools,
+                       size_t count)
+{
+    if (!config || !pools || count == 0)
+        return ERR_PMP_INVALID_REGION;
+
+    /* Initialize PMP hardware and state */
+    int32_t ret = pmp_init(config);
+    if (ret < 0)
+        return ret;
+
+    /* Configure each memory pool as a PMP region */
+    for (size_t i = 0; i < count; i++) {
+        const mempool_t *pool = &pools[i];
+
+        /* Validate pool boundaries */
+        if (pool->start >= pool->end)
+            return ERR_PMP_ADDR_RANGE;
+
+        /* Prepare PMP region configuration */
+        pmp_region_t region = {
+            .addr_start = pool->start,
+            .addr_end = pool->end,
+            .permissions = pool->flags & (PMPCFG_R | PMPCFG_W | PMPCFG_X),
+            .priority = pool->tag,
+            .region_id = i,
+            .locked = 0,
+        };
+
+        /* Configure the PMP region */
+        ret = pmp_set_region(config, &region);
+        if (ret < 0)
+            return ret;
+    }
+
+    return ERR_OK;
+}
+
+/* Initialize Kernel Memory Protection
+ *
+ * Convenience function that initializes PMP with default kernel memory
+ * pools. Should be called during kernel initialization.
+ *
+ * @config : Pointer to PMP configuration state
+ * Returns 0 on success, or negative error code on failure.
+ */
+int32_t pmp_init_kernel(pmp_config_t *config)
+{
+    return pmp_init_pools(config, kernel_mempools, KERNEL_MEMPOOL_COUNT);
+}

arch/riscv/pmp.h

@@ -8,6 +8,9 @@
 
 #include <types.h>
 
+/* Forward declaration */
+typedef struct mempool mempool_t;
+
 /* PMP Region Priority Levels (lower value = higher priority)
  *
  * Used for eviction decisions when hardware PMP regions are exhausted.
@@ -86,3 +89,20 @@ int32_t pmp_lock_region(pmp_config_t *config, uint8_t region_idx);
  */
 int32_t pmp_check_access(const pmp_config_t *config, uint32_t addr,
                          uint32_t size, uint8_t is_write, uint8_t is_execute);
+
+/* Memory Pool Management Functions */
+
+/* Initializes PMP regions from an array of memory pool descriptors.
+ * @config : Pointer to PMP configuration state
+ * @pools : Array of memory pool descriptors
+ * @count : Number of pools in the array
+ * Returns 0 on success, or negative error code on failure.
+ */
+int32_t pmp_init_pools(pmp_config_t *config, const mempool_t *pools,
+                       size_t count);
+
+/* Initializes PMP with default kernel memory pools.
+ * @config : Pointer to PMP configuration state
+ * Returns 0 on success, or negative error code on failure.
+ */
+int32_t pmp_init_kernel(pmp_config_t *config);