refactor: add a async read/write variant to device ops, with allow async io to be...

[lunaix-os.git] / lunaix-os / kernel / mm / valloc.c

diff --git a/lunaix-os/kernel/mm/valloc.c b/lunaix-os/kernel/mm/valloc.c
index 44295625f3adb8f6bfe239618e565219a0829657..6d6783449b7d9d52df27260fbd293fbc0515f274 100644 (file)
--- a/lunaix-os/kernel/mm/valloc.c
+++ b/lunaix-os/kernel/mm/valloc.c
@@ -1,46 +1,134 @@
+#include <klibc/string.h>

 #include <lunaix/mm/cake.h>
 #include <lunaix/mm/cake.h>

+#include <lunaix/mm/valloc.h>
+#include <lunaix/spike.h>

 
 

-#define MAX_CLASS 6
+#define CLASS_LEN(class) (sizeof(class) / sizeof(class[0]))

 
 

-static char piles_names[MAX_CLASS][PILE_NAME_MAXLEN] = {
-    "valloc_128", "valloc_256", "valloc_512",
-    "valloc_1k",  "valloc_2k",  "valloc_4k"
-};
+static char piles_names[][PILE_NAME_MAXLEN] = {"valloc_8",
+                                               "valloc_16",
+                                               "valloc_32",
+                                               "valloc_64",
+                                               "valloc_128",
+                                               "valloc_256",
+                                               "valloc_512",
+                                               "valloc_1k",
+                                               "valloc_2k",
+                                               "valloc_4k",
+                                               "valloc_8k"};

 
 

-static struct cake_pile* piles[MAX_CLASS];
+static char piles_names_dma[][PILE_NAME_MAXLEN] = {"valloc_dma_128",
+                                                   "valloc_dma_256",
+                                                   "valloc_dma_512",
+                                                   "valloc_dma_1k",
+                                                   "valloc_dma_2k",
+                                                   "valloc_dma_4k"};
+
+static struct cake_pile* piles[CLASS_LEN(piles_names)];
+static struct cake_pile* piles_dma[CLASS_LEN(piles_names_dma)];

 
 void
 valloc_init()
 {
 
 void
 valloc_init()
 {

-    for (size_t i = 0; i < MAX_CLASS; i++) {
+    for (size_t i = 0; i < CLASS_LEN(piles_names); i++) {
+        int size = 1 << (i + 3);
+        piles[i] = cake_new_pile(piles_names[i], size, size > 1024 ? 8 : 1, 0);
+    }
+
+    // DMA 内存保证128字节对齐
+    for (size_t i = 0; i < CLASS_LEN(piles_names_dma); i++) {

         int size = 1 << (i + 7);
         int size = 1 << (i + 7);

-        piles[i] = cake_new_pile(&piles_names[i], size, size > 1024 ? 8 : 1);
+        piles_dma[i] = cake_new_pile(
+            piles_names_dma[i], size, size > 1024 ? 4 : 1, PILE_ALIGN_CACHE);

     }
 }
 
 void*
     }
 }
 
 void*

-valloc(unsigned int size)
+__valloc(unsigned int size,
+         struct cake_pile** segregate_list,
+         size_t len,
+         size_t boffset)
+{
+    size_t i = ILOG2(size);
+    i += (size - (1 << i) != 0);
+    i -= boffset;
+
+    if (i >= len)
+        return NULL;
+
+    return cake_grab(segregate_list[i]);
+}
+
+void
+__vfree(void* ptr, struct cake_pile** segregate_list, size_t len)

 {
     size_t i = 0;
 {
     size_t i = 0;

-    for (; i < MAX_CLASS; i++) {
-        if (piles[i]->piece_size > size) {
-            goto found_class;
+    for (; i < len; i++) {
+        if (cake_release(segregate_list[i], ptr)) {
+            return;

         }
     }
         }
     }

+}
+
+void*
+valloc(unsigned int size)
+{
+    return __valloc(size, piles, CLASS_LEN(piles_names), 3);
+}

 
 

-    return NULL;
+void*
+vzalloc(unsigned int size)
+{
+    void* ptr = __valloc(size, piles, CLASS_LEN(piles_names), 3);
+    memset(ptr, 0, size);
+    return ptr;
+}
+
+void*
+vcalloc(unsigned int size, unsigned int count)
+{
+    unsigned int alloc_size;
+    if (umul_overflow(size, count, &alloc_size)) {
+        return 0;
+    }

 
 

-found_class:
-    return cake_grab(piles[i]);
+    void* ptr = __valloc(alloc_size, piles, CLASS_LEN(piles_names), 3);
+    memset(ptr, 0, alloc_size);
+    return ptr;

 }
 
 void
 vfree(void* ptr)
 {
 }
 
 void
 vfree(void* ptr)
 {

-    size_t i = 0;
-    for (; i < MAX_CLASS; i++) {
-        if (cake_release(piles[i], ptr)) {
-            return;
-        }
+    __vfree(ptr, piles, CLASS_LEN(piles_names));
+}
+
+void
+vfree_safe(void* ptr)
+{
+    if (!ptr) {
+        return;

     }
     }

+
+    __vfree(ptr, piles, CLASS_LEN(piles_names));
+}
+
+void*
+valloc_dma(unsigned int size)
+{
+    return __valloc(size, piles_dma, CLASS_LEN(piles_names_dma), 7);
+}
+
+void*
+vzalloc_dma(unsigned int size)
+{
+    void* ptr = __valloc(size, piles_dma, CLASS_LEN(piles_names_dma), 7);
+    memset(ptr, 0, size);
+    return ptr;
+}
+
+void
+vfree_dma(void* ptr)
+{
+    __vfree(ptr, piles_dma, CLASS_LEN(piles_names_dma));

 }
\ No newline at end of file
 }
\ No newline at end of file