slab.c File Reference

#include <stdbool.h>
#include <stdint.h>
#include <string.h>
#include <sys/cdefs.h>
#include <sys/kassert.h>
#include <sys/kdebug.h>
#include <sys/queue.h>
#include <sys/kmem.h>
#include <machine/pmap.h>

Include dependency graph for slab.c:

Go to the source code of this file.

Functions
	LIST_HEAD (SlabListHead, Slab)
int	SlabExtend (Slab *slab)
void *	Slab_Alloc (Slab *slab)
void	Slab_Free (Slab *slab, void *region)
static void	Debug_Slabs (int argc, const char *argv[])
	REGISTER_DBGCMD (slabs, "Display list of slabs", Debug_Slabs)

Function Documentation

Debug_Slabs()

static void Debug_Slabs ( int  argc, const char *  argv[]  )

static

Definition at line 148 of file slab.c.

{
    Slab *slab;
 
    kprintf("%-36s %-10s %-10s %-10s\n", "Slab Name", "Alloc", "Free", "Total");
    LIST_FOREACH(slab, &slabList, slabList) {
        kprintf("%-36s %-10lld %-10lld %-10lld\n", slab->name,
                slab->objs - slab->freeObjs, slab->freeObjs, slab->objs);
    }
}

Here is the call graph for this function:

LIST_HEAD()

LIST_HEAD	(	SlabListHead	,
		Slab
	)

Definition at line 18 of file slab.c.

{
    ASSERT(objsz >= sizeof(SlabElement));
 
    slab->objsz = objsz;
    slab->align = align;
    slab->xmem = XMem_New();
    slab->objs = 0;
    slab->freeObjs = 0;
    slab->allocs = 0;
    slab->frees = 0;
    LIST_INIT(&slab->freeList);
 
    ASSERT(slab->xmem != NULL);
 
    strncpy(&slab->name[0], name, SLAB_NAMELEN);
 
    Spinlock_Init(&slab->lock, name, SPINLOCK_TYPE_NORMAL);
 
    LIST_INSERT_HEAD(&slabList, slab, slabList);
}

REGISTER_DBGCMD()

REGISTER_DBGCMD	(	slabs	,
		"Display list of slabs"	,
		Debug_Slabs
	)

Slab_Alloc()

void * Slab_Alloc

(

Slab *

slab

)

Slab_Alloc –

 Free a slab object.

 @param [in] slab Slab that the object belongs to.
 @retval NULL Could not allocate an object.
 @return Pointer to the allocated object.

Definition at line 105 of file slab.c.

{
    SlabElement *elem;
 
    Spinlock_Lock(&slab->lock);
 
    if (slab->freeObjs == 0)
        SlabExtend(slab);
 
    elem = LIST_FIRST(&slab->freeList);
    if (elem != NULL) {
        LIST_REMOVE(elem, free);
        slab->allocs++;
        slab->freeObjs--;
    }
 
    Spinlock_Unlock(&slab->lock);
 
    return (void *)elem;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Slab_Free()

void Slab_Free	(	Slab *	slab,
		void *	region
	)

Slab_Free –

 Free a slab object.

 @param [in] slab Slab that the object belongs to.
 @param [in] region Object to free.

Definition at line 135 of file slab.c.

{
    Spinlock_Lock(&slab->lock);
 
    SlabElement *elem = (SlabElement *)region;
    LIST_INSERT_HEAD(&slab->freeList, elem, free);
    slab->frees++;
    slab->freeObjs++;
 
    Spinlock_Unlock(&slab->lock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SlabExtend()

int SlabExtend

(

Slab *

slab

)

SlabExtend –

 Grow the slab to allocate new objects.

 @param [in] slab Slab that we want to expand.
 @retval -1 Failed to expand the slab.
 @retval 0 Success.

Definition at line 63 of file slab.c.

{
    uintptr_t base = XMem_GetBase(slab->xmem);
    uintptr_t len = XMem_GetLength(slab->xmem);
    uintptr_t inc;
    uintptr_t realObjSz = ROUNDUP(slab->objsz, slab->align);
 
    inc = ROUNDUP(realObjSz * 64, PGSIZE);
    if (inc < 4 * PGSIZE) {
        inc = 4 * PGSIZE;
    }
 
    if (!XMem_Allocate(slab->xmem, len + inc)) {
        kprintf("Slab: Cannot grow XMem region!\n");
        return -1;
    }
 
    // Add empty objects to linked list
    uintptr_t i;
    uintptr_t objs = inc / realObjSz;
    for (i = 0; i < objs; i++) {
        SlabElement *elem = (SlabElement *)(base + len + i * realObjSz);
 
        LIST_INSERT_HEAD(&slab->freeList, elem, free);
    }
 
    slab->objs += objs;
    slab->freeObjs += objs;
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: