Kalloc Class Reference

Public Types
enum	Fill { NOFILL = 0 , FILL_0 , FILL_1 }

Public Member Functions
	Kalloc (mword virt_begin, mword virt_end)
void *	alloc (unsigned size)
void *	alloc_page (unsigned count, Fill fill=NOFILL)
	Allocate count virtually contiguous pages and optionally fill them with 0x00 or 0xFF.
void	free_page (void *)
	Free a page previously allocated with Kalloc::alloc_page().

Static Public Member Functions
static void *	phys2virt (mword)
	Returns the virtual address that can be used to access memory with physical address phys.
static mword	virt2phys (void *)
	Return the physical address that is mapped from the virtual address virt (opposite of phys2virt).

Static Public Attributes
static Kalloc	allocator

Member Enumeration Documentation

Fill

enum Kalloc::Fill

        {
            NOFILL = 0,
            FILL_0,
            FILL_1
        };

Constructor & Destructor Documentation

Kalloc()

Kalloc::Kalloc ( mword virt_begin, mword virt_end )

inline

: begin (virt_begin), end (virt_end) {}

Member Function Documentation

alloc()

void * Kalloc::alloc

(

unsigned

size

)

{
    if (end - size < begin)
        panic ("kernel : no mem\n");
 
    end -= size;
    return reinterpret_cast<void*>(end);
}

alloc_page()

void * Kalloc::alloc_page	(	unsigned	count,
		Fill	fill = NOFILL )

Allocate count virtually contiguous pages and optionally fill them with 0x00 or 0xFF.

Returns

Virtual address of the first allocated page

{
    unsigned found = 0, first = 0;
 
    for (unsigned i = 0; i < ((end - begin) >> PAGE_BITS) && found < count; i++) {
        if (page_bitmap[i >> 5] == 0xffffffff) {
            i += 31;
            found = 0;
            continue;
        }
        if (!is_page_allocated(i)) {
            if (found++ == 0)
                first = i;
        } else {
            found = 0;
        }
    }
 
    if (found != count)
        return NULL;
 
    for (unsigned i = 0; i < count; i++)
        mark_page_allocated(first + i, true);
 
    void * p = reinterpret_cast<void *>(begin + first * PAGE_SIZE);
    if (fill)
        memset (p, fill == FILL_0 ? 0 : ~0, count * PAGE_SIZE);
 
    return p;
}

free_page()

void Kalloc::free_page

(

void *

virt

)

Free a page previously allocated with Kalloc::alloc_page().

Parameters

[in]

virt

Virtual address of the page to free.

{
    mword p = reinterpret_cast<mword>(virt);
    if (p < begin || p >= end || (p & (PAGE_SIZE - 1)) != 0 ||
        !is_page_allocated((p - begin) >> PAGE_BITS))
        panic ("kernel: attempt to free invalid page\n");
 
    mark_page_allocated((p - begin) >> PAGE_BITS, false);
}

phys2virt()

void * Kalloc::phys2virt ( mword phys )

static

Returns the virtual address that can be used to access memory with physical address phys.

Even kernel can only access virtual memory, it cannot access physical memory directly. However, CPU and bootloader work with physical addresses, so we sometimes need to access memory via its physical addresses.

To resolve this, part of the physical memory is mapped 1:1 to a sequential block of virtual memory addresses at a known offset OFFSET, so that the physical address X is accessible at the virtual address OFFSET + X. This mapping is configured during kernel startup at kern/src/start.S (section SETUP BOOT PAGE TABLE).

{
    mword virt = phys + reinterpret_cast<mword>(&OFFSET);
    return reinterpret_cast<void*>(virt);
}

virt2phys()

mword Kalloc::virt2phys ( void * virt )

static

Return the physical address that is mapped from the virtual address virt (opposite of phys2virt).

{
    mword phys = reinterpret_cast<mword>(virt) - reinterpret_cast<mword>(&OFFSET);
    return phys;
}

---

The documentation for this class was generated from the following files:

• include/kalloc.h
• src/kalloc.cc