memory/kmalloc: allow allocating larger pages

It is now possible to allocate buffers larger than the maximum
cache size using the kmalloc API.

These buffers are allocated using the VM api directly. Their pages
flagged as PAGE_LARGE_ALLOC so that we can identify such buffers
inside kfree().

Author: d4ilyrun

include/kernel/kmalloc.h

@@ -59,7 +59,7 @@
  */
 typedef enum kmalloc_flags {
     KMALLOC_KERNEL = 0, /* Default allocation flags. */
-} kmalloc_flags;
+} kmalloc_flags_t;
 
 #define KMALLOC_CACHE_MIN_SIZE 16
 #define KMALLOC_CACHE_MAX_SIZE 16384
@@ -97,6 +97,9 @@ static ALWAYS_INLINE __attribute__((const)) int kmalloc_cache_index(size_t size)
  */
 void *kmalloc_from_cache(int cache_index, int flags);
 
+/** Allocate a memory buffer too large to fit inside the default caches. */
+void *kmalloc_large(size_t size, int flags);
+
 /*
  *
  */
@@ -106,7 +109,7 @@ static ALWAYS_INLINE void *kmalloc(size_t size, int flags)
 
     cache_index = kmalloc_cache_index(size);
     if (cache_index < 0)
-        return NULL;
+        return kmalloc_large(size, flags);
 
     return kmalloc_from_cache(cache_index, flags);
 }
@@ -117,7 +120,7 @@ static ALWAYS_INLINE void *kmalloc(size_t size, int flags)
  *
  * @param nmemb The number of members to allocate
  * @param size The size of each members
- * @param flags Feature flags, must be a combination of @ref kmalloc_flags
+ * @param flags Feature flags, must be a combination of @ref kmalloc_flags_t
  *
  * @return The starting address of the newly allocated area
  */

include/kernel/pmm.h

@@ -61,9 +61,10 @@
  *  @enum page_flags
  */
 enum page_flags {
-    PAGE_AVAILABLE = BIT(0), ///< This page has not been allocated
-    PAGE_COW = BIT(1),       ///< Currently used in a CoW mapping
-    PAGE_SLAB = BIT(2),      ///< Page allocated by the slab allocator
+    PAGE_AVAILABLE = BIT(0),   ///< This page has not been allocated
+    PAGE_COW = BIT(1),         ///< Currently used in a CoW mapping
+    PAGE_SLAB = BIT(2),        ///< Page allocated by the slab allocator
+    PAGE_LARGE_ALLOC = BIT(3), ///< Page allocated by kmalloc_large()
 };
 
 /** Represents a physical pageframe

kernel/memory/kmalloc.c

@@ -18,23 +18,58 @@ static const char *kmalloc_cache_names[] = {
     "size-4096", "size-8192", "size-16384",
 };
 
+/*
+ *
+ */
+static inline vm_flags_t kmalloc_flags_to_vm_flags(kmalloc_flags_t flags)
+{
+    vm_flags_t vm_flags = VM_KERNEL_RW;
+
+    UNUSED(flags);
+
+    return vm_flags;
+}
+
 void *kmalloc_from_cache(int cache_index, int flags)
 {
     return kmem_cache_alloc(kmalloc_size_caches[cache_index], flags);
 }
 
-void *kcalloc(size_t nmemb, size_t size, int flags)
+/** Allocate a memory buffer too large to fit inside the default caches. */
+void *kmalloc_large(size_t size, int flags)
 {
-    if (__builtin_mul_overflow(nmemb, size, &size))
+    struct vm_segment *vm_segment;
+    paddr_t paddr;
+
+    size = align_up(size, PAGE_SIZE);
+    flags = kmalloc_flags_to_vm_flags(flags);
+
+    if (WARN_ON_MSG(size <= KMALLOC_CACHE_MAX_SIZE, "use kmalloc_from_cache()"))
         return NULL;
 
-    void *ptr = kmalloc(size, flags);
-    if (ptr == NULL)
+    vm_segment = vm_alloc(&kernel_address_space, size, flags);
+    if (!vm_segment)
         return NULL;
 
-    return memset(ptr, 0, size);
+    /* Mark all pages so we know how it was allocated when freeing. */
+    paddr = mmu_find_physical(vm_segment->start);
+    for (size_t off = 0; off < size; off += PAGE_SIZE)
+        address_to_page(paddr)->flags |= PAGE_LARGE_ALLOC;
+
+    return (void *)vm_segment->start;
 }
 
+/*
+ * Free a memory buffer that was allocated using kmalloc_large().
+ */
+static inline void kfree_large_alloc(void *ptr)
+{
+    vm_free(&kernel_address_space, PAGE_ALIGN_DOWN(ptr));
+}
+
+/*
+ *
+ */
 void kfree(void *ptr)
 {
     struct page *page;
@@ -46,9 +81,24 @@ void kfree(void *ptr)
     paddr = mmu_find_physical((vaddr_t)ptr);
     page = address_to_page(paddr);
 
+    if (page->flags & PAGE_LARGE_ALLOC)
+        return kfree_large_alloc(ptr);
+
     kmem_cache_free(page->slab.cache, ptr);
 }
 
+void *kcalloc(size_t nmemb, size_t size, int flags)
+{
+    if (__builtin_mul_overflow(nmemb, size, &size))
+        return NULL;
+
+    void *ptr = kmalloc(size, flags);
+    if (ptr == NULL)
+        return NULL;
+
+    return memset(ptr, 0, size);
+}
+
 void *krealloc(void *ptr, size_t size, int flags)
 {
     struct page *page;