kmem.h File Reference

#include <sys/queue.h>
#include <sys/spinlock.h>

Include dependency graph for kmem.h:

Go to the source code of this file.

Data Structures
struct	Page
struct	SlabElement
struct	Slab

Macros
#define	SLAB_NAMELEN   32
#define	DECLARE_SLAB(_type)
#define	DEFINE_SLAB(_type, _pool)

Typedefs
typedef struct Page	Page
typedef struct XMem	XMem
typedef struct SlabElement	SlabElement
typedef struct Slab	Slab

Functions
void	PAlloc_Init ()
void	PAlloc_AddRegion (uintptr_t start, uintptr_t len)
void *	PAlloc_AllocPage ()
void	PAlloc_Retain (void *pg)
void	PAlloc_Release (void *pg)
void	XMem_Init ()
XMem *	XMem_New ()
void	XMem_Destroy (XMem *xmem)
uintptr_t	XMem_GetBase (XMem *xmem)
uintptr_t	XMem_GetLength (XMem *xmem)
bool	XMem_Allocate (XMem *xmem, uintptr_t length)
void	Slab_Init (Slab *slab, const char *name, uintptr_t objsz, uintptr_t align)
void *	Slab_Alloc (Slab *slab) __attribute__((malloc))
void	Slab_Free (Slab *slab, void *obj)

---

Data Structure Documentation

Page

struct Page

Definition at line 8 of file kmem.h.

Collaboration diagram for Page:

Data Fields
uint32_t	_unused
uint32_t	flags
uint32_t	pincount
uint32_t	refcount

Macro Definition Documentation

DECLARE_SLAB

#define DECLARE_SLAB

(

_type

)

Value:

    _type *_type##_Alloc();             \
    void _type##_Free(_type *obj);

Definition at line 65 of file kmem.h.

DEFINE_SLAB

#define DEFINE_SLAB	(		_type,
			_pool
	)

Value:

    _type *_type##_Alloc() {                    \
        return (_type *)Slab_Alloc(_pool);      \
    }                                           \
    void _type##_Free(_type *obj) {             \
        Slab_Free(_pool, obj);                  \
    }

Definition at line 69 of file kmem.h.

SLAB_NAMELEN

#define SLAB_NAMELEN   32

Definition at line 40 of file kmem.h.

Typedef Documentation

Page

typedef struct Page Page

Slab

typedef struct Slab Slab

SlabElement

typedef struct SlabElement SlabElement

XMem

typedef struct XMem XMem

Definition at line 27 of file kmem.h.

Function Documentation

PAlloc_AddRegion()

void PAlloc_AddRegion	(	uintptr_t	start,
		uintptr_t	len
	)

PAlloc_AddRegion –

Add a physical memory region to the page allocator.

Definition at line 92 of file palloc.c.

{
    uintptr_t i;
    FreePage *pg;
 
    if ((start % PGSIZE) != 0)
        Panic("Region start is not page aligned!");
    if ((len % PGSIZE) != 0)
        Panic("Region length is not page aligned!");
 
    /*
     * PageInfo table isn't initialized on the first call to this function.  We 
     * must allocate a temporary table that will be copied into the XMem region 
     * inside PAlloc_LateInit.
     *
     * Note that the PageInfo table is invalid for regions that are not added 
     * to the free list such as MMIO regions.
     */
    if (pageInfoTable == NULL) {
        // Physical Address Offsets
        uintptr_t base = (uintptr_t)DMVA2PA(start);
        uintptr_t end = base + len;
 
        pageInfoLength = ROUNDUP(end / PGSIZE * sizeof(PageInfo), PGSIZE);
        pageInfoTable = (PageInfo *)start;
 
        start += pageInfoLength;
        len -= pageInfoLength;
 
        for (i = 0; i < (base / PGSIZE); i++) {
            pageInfoTable[i].refCount = 1;
        }
        for (i = (base / PGSIZE); i < (end / PGSIZE); i++) {
            pageInfoTable[i].refCount = 0;
        }
        for (i = 0; i < (pageInfoLength / PGSIZE); i++) {
            pageInfoTable[i + (base / PGSIZE)].refCount = 1;
        }
    } else {
        /*
         * Only the first call to AddRegion should occur before the XMem region 
         * is initialized.
         */
        
        ASSERT(pageInfoXMem != NULL);
 
        uintptr_t base = (uintptr_t)DMVA2PA(start);
        uintptr_t end = base + len;
 
        uintptr_t newLength = ROUNDUP(end / PGSIZE * sizeof(PageInfo), PGSIZE);
 
        if (!XMem_Allocate(pageInfoXMem, newLength))
            Panic("Cannot allocate XMem region!");
 
        // Initialize new pages
        for (i = (base / PGSIZE); i < (end / PGSIZE); i++) {
            pageInfoTable[i].refCount = 0;
        }
    }
 
    Spinlock_Lock(&pallocLock);
    for (i = 0; i < len; i += PGSIZE)
    {
        pg = (void *)(start + i);
        pg->magic = FREEPAGE_MAGIC_FREE;
 
        totalPages++;
        freePages++;
 
        LIST_INSERT_HEAD(&freeList, pg, entries);
    }
    Spinlock_Unlock(&pallocLock);
}

PAlloc_AllocPage()

void * PAlloc_AllocPage

(

)

PAlloc_AllocPage –

Allocate a physical page and return the page's address in the Kernel's ident mapped memory region.

Return values

NULL	if no memory is available.

Returns

Newly allocated physical page.

Definition at line 188 of file palloc.c.

{
    PageInfo *info;
    FreePage *pg;
 
    Spinlock_Lock(&pallocLock);
    pg = LIST_FIRST(&freeList);
    ASSERT(pg != NULL);
    LIST_REMOVE(pg, entries);
 
    ASSERT(pg->magic == FREEPAGE_MAGIC_FREE);
 
    info = PAllocGetInfo(pg);
    ASSERT(info != NULL);
    ASSERT(info->refCount == 0);
    info->refCount++;
 
    pg->magic = FREEPAGE_MAGIC_INUSE;
 
    freePages--;
    Spinlock_Unlock(&pallocLock);
 
    memset(pg, 0, PGSIZE);
 
    return (void *)pg;
}

Here is the call graph for this function:

Here is the caller graph for this function:

PAlloc_Init()

void PAlloc_Init

(

)

Here is the caller graph for this function:

PAlloc_Release()

void PAlloc_Release

(

void *

pg

)

PAlloc_Release –

Deccrement the reference count for a physical page. If the reference count is zero the page will be freed.

Definition at line 265 of file palloc.c.

{
    PageInfo *info = PAllocGetInfo(pg);
 
    Spinlock_Lock(&pallocLock);
    ASSERT(info->refCount != 0);
    info->refCount--;
    if (info->refCount == 0)
        PAllocFreePage(pg);
    Spinlock_Unlock(&pallocLock);
}

Here is the call graph for this function:

Here is the caller graph for this function:

PAlloc_Retain()

void PAlloc_Retain

(

void *

pg

)

PAlloc_Retain –

Increment the reference count for a physical page.

Definition at line 248 of file palloc.c.

{
    PageInfo *info = PAllocGetInfo(pg);
 
    Spinlock_Lock(&pallocLock);
    ASSERT(info->refCount != 0);
    info->refCount++;
    Spinlock_Unlock(&pallocLock);
}

Here is the call graph for this function:

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:

Slab_Init()

void Slab_Init	(	Slab *	slab,
		const char *	name,
		uintptr_t	objsz,
		uintptr_t	align
	)

Here is the caller graph for this function:

XMem_Allocate()

bool XMem_Allocate	(	XMem *	xmem,
		uintptr_t	length
	)

Definition at line 92 of file xmem.c.

{
    uint64_t off;
 
    // We already allocated up to that size
    if (xmem->length > length)
        return true;
 
    // Allocation too long
    if (length > xmem->maxLength)
        return false;
 
    for (off = xmem->length; off < length; off += PGSIZE) {
        void *pg = PAlloc_AllocPage();
        if (pg == NULL)
            return false;
 
        PMap_SystemMap(DMVA2PA((uint64_t)pg), xmem->base + off, 1, 0);
 
        xmem->length += PGSIZE;
    }
 
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

XMem_Destroy()

void XMem_Destroy

(

XMem *

xmem

)

Definition at line 63 of file xmem.c.

{
    uintptr_t off;
    PageEntry *entry;
 
    for (off = 0; off < xmem->length; off += PGSIZE) {
        PMap_SystemLookup(xmem->base + off, &entry, PGSIZE);
 
        // Compute DM
 
        // Free Page
    }
 
    //PMap_SystemUnmap(virt, pages);
}

Here is the call graph for this function:

XMem_GetBase()

uintptr_t XMem_GetBase

(

XMem *

xmem

)

Definition at line 80 of file xmem.c.

{
    return xmem->base;
}

Here is the caller graph for this function:

XMem_GetLength()

uintptr_t XMem_GetLength

(

XMem *

xmem

)

Definition at line 86 of file xmem.c.

{
    return xmem->length;
}

Here is the caller graph for this function:

XMem_Init()

void XMem_Init

(

)

Definition at line 28 of file xmem.c.

{
    int r;
    uintptr_t regionSize = MEM_XMAP_LEN / MAX_XMEM_REGIONS;
 
    kprintf("Initializing XMEM ... ");
 
    for (r = 0; r < MAX_XMEM_REGIONS; r++)
    {
        regions[r].inUse = false;
        regions[r].base = MEM_XMAP_BASE + r * regionSize;
        regions[r].maxLength = regionSize;
        regions[r].length = 0;
    }
 
    kprintf("Done!\n");
}

Here is the call graph for this function:

Here is the caller graph for this function:

XMem_New()

XMem * XMem_New

(

)

Definition at line 47 of file xmem.c.

{
    int r;
 
    for (r = 0; r < MAX_XMEM_REGIONS; r++)
    {
        if (!regions[r].inUse) {
            regions[r].inUse = true;
            return &regions[r];
        }
    }
 
    return NULL;
}

Here is the caller graph for this function: