Don't zero new blocks.
[akaros.git] / kern / src / ns / allocb.c
index 068f05d..f179b28 100644 (file)
 #include <ip.h>
 #include <process.h>
 
-enum
-{
-       Hdrspc          = 64,           /* leave room for high-level headers */
-       Bdead           = 0x51494F42,   /* "QIOB" */
-       BLOCKALIGN  = 32,               /* was the old BY2V in inferno, which was 8 */
+enum {
+       Hdrspc = 64,                            /* leave room for high-level headers */
+       Bdead = 0x51494F42,     /* "QIOB" */
+       BLOCKALIGN = 32,        /* was the old BY2V in inferno, which was 8 */
 };
 
 static atomic_t ialloc_bytes = 0;
@@ -35,8 +34,8 @@ struct block *_allocb(int size)
        int n;
 
        /* TODO: verify we end up with properly aligned blocks */
-       b = kzmalloc(sizeof(struct block) + size + Hdrspc + (BLOCKALIGN - 1),
-                    KMALLOC_WAIT);
+       b = kmalloc(sizeof(struct block) + size + Hdrspc + (BLOCKALIGN - 1),
+                                KMALLOC_WAIT);
        if (b == NULL)
                return NULL;
 
@@ -45,10 +44,17 @@ struct block *_allocb(int size)
        b->free = NULL;
        b->flag = 0;
 
-       addr = (uintptr_t)b;
+       addr = (uintptr_t) b;
        addr = ROUNDUP(addr + sizeof(struct block), BLOCKALIGN);
-       b->base = (uint8_t*)addr;
-       b->lim = ((uint8_t*)b) + msize(b);
+       b->base = (uint8_t *) addr;
+       /* interesting. We can ask the allocator, after allocating,
+        * the *real* size of the block we got. Very nice.
+        * Not on akaros yet.
+        b->lim = ((uint8_t*)b) + msize(b);
+        */
+       b->lim =
+               ((uint8_t *) b) + sizeof(struct block) + size + Hdrspc + (BLOCKALIGN -
+                                                                                                                                 1);
        b->rp = b->base;
        n = b->lim - b->base - size;
        b->rp += n & ~(BLOCKALIGN - 1);
@@ -61,8 +67,6 @@ struct block *allocb(int size)
 {
        struct block *b;
 
-       if (!current)
-               panic("allocb outside process: %8.8lux", getcallerpc(&size));
        b = _allocb(size);
        if (b == 0)
                exhausted("Blocks");
@@ -76,17 +80,17 @@ struct block *iallocb(int size)
 {
        struct block *b;
 
-       #if 0 /* conf is some inferno global config */
+#if 0  /* conf is some inferno global config */
        if (atomic_read(&ialloc_bytes) > conf.ialloc) {
-               //printk("iallocb: limited %lud/%lud\n", atomic_read(&ialloc_bytes),
+               //printk("iallocb: limited %lu/%lu\n", atomic_read(&ialloc_bytes),
                //       conf.ialloc);
                return NULL;
        }
-       #endif
+#endif
 
        b = _allocb(size);
        if (b == NULL) {
-               //printk("iallocb: no memory %lud/%lud\n", atomic_read(&ialloc_bytes),
+               //printk("iallocb: no memory %lu/%lu\n", atomic_read(&ialloc_bytes),
                //       conf.ialloc);
                return NULL;
        }
@@ -132,29 +136,29 @@ void checkb(struct block *b, char *msg)
        void *dead = (void *)Bdead;
 
        if (b == dead)
-               panic("checkb b %s %lux", msg, b);
+               panic("checkb b %s 0x%lx", msg, b);
        if (b->base == dead || b->lim == dead || b->next == dead
                || b->rp == dead || b->wp == dead) {
-               printd("checkb: base 0x%8.8luX lim 0x%8.8luX next 0x%8.8luX\n",
+               printd("checkb: base 0x%8.8lx lim 0x%8.8lx next 0x%8.8lx\n",
                           b->base, b->lim, b->next);
-               printd("checkb: rp 0x%8.8luX wp 0x%8.8luX\n", b->rp, b->wp);
+               printd("checkb: rp 0x%8.8lx wp 0x%8.8lx\n", b->rp, b->wp);
                panic("checkb dead: %s\n", msg);
        }
 
        if (b->base > b->lim)
-               panic("checkb 0 %s %lux %lux", msg, b->base, b->lim);
+               panic("checkb 0 %s 0x%lx 0x%lx", msg, b->base, b->lim);
        if (b->rp < b->base)
-               panic("checkb 1 %s %lux %lux", msg, b->base, b->rp);
+               panic("checkb 1 %s 0x%lx 0x%lx", msg, b->base, b->rp);
        if (b->wp < b->base)
-               panic("checkb 2 %s %lux %lux", msg, b->base, b->wp);
+               panic("checkb 2 %s 0x%lx 0x%lx", msg, b->base, b->wp);
        if (b->rp > b->lim)
-               panic("checkb 3 %s %lux %lux", msg, b->rp, b->lim);
+               panic("checkb 3 %s 0x%lx 0x%lx", msg, b->rp, b->lim);
        if (b->wp > b->lim)
-               panic("checkb 4 %s %lux %lux", msg, b->wp, b->lim);
+               panic("checkb 4 %s 0x%lx 0x%lx", msg, b->wp, b->lim);
 
 }
 
 void iallocsummary(void)
 {
-       printd("ialloc %lud/%lud\n", atomic_read(&ialloc_bytes), 0 /*conf.ialloc*/);
+       printd("ialloc %lu/%lu\n", atomic_read(&ialloc_bytes), 0 /*conf.ialloc */ );
 }