Subversion Repositories Kolibri OS

#include 

#include 

#include 

#include 

extern u32_t mem_amount;

{

    link_t    link;

    SPINLOCK_DECLARE(lock);

    u32_t     state;

    void     *parent;

    count_t   avail;

    addr_t    base;

    index_t   next;

    int       list[512];

}pslab_t;

{

    SPINLOCK_DECLARE(lock);

    link_t   partial_slabs;        /**< List of partial slabs */

}pcache_t;

{

    int i;

    u32_t     size;

    count_t   pages;

    size_t    conf_size;

    size_t    core_size;

    pslab_t  *slab;

    DBG("last page = %x total pages =  %x\n",mem_amount, pages);

    DBG("conf_size = %x  free mem start =%x\n",conf_size, pg_balloc);

    zone_release(&z_core, 0, pages);

    zone_reserve(&z_core, 0, pg_balloc >> PAGE_WIDTH);

    list_initialize(&page_cache.partial_slabs);

    page_cache.partial_count++;

    list_prepend(&slab->link, &page_cache.partial_slabs);

};

static unsigned int badness(index_t order, size_t size)

{

	unsigned int objects;

	unsigned int ssize;

    objects = (PAGE_SIZE << order) / size;

	return ssize - objects * size;

}

{

    pslab_t  *slab;

    link_t   *tmp;

    {

        frame_t     *frame;

        int          i;

        addr_t       v;

        z_core.free_count -= 512;

        z_core.busy_count += 512;

        frame = (frame_t*)tmp;

                frame[i].parent = slab;

        slab->next  = 0;

            slab->list[i] = i + 1;

    else

    {

        spinlock_unlock(&z_core.lock);

        slab = NULL;

    };

}

{

    u32_t     order;

    count_t   idx;

    frame_t  *frame;

	order = frame->buddy_order;

    {

        spinlock_lock(&z_core.lock);

        z_core.free_count += (1 << order);

        z_core.busy_count -= (1 << order);

    }

}

fslab_t *create_slab(index_t order, size_t size)

{

    fslab_t *slab;

    {

        link_t      *tmp;

        ASSERT(tmp);

        {

            frame_t     *frame;

            count_t      objects;

            count_t      i;

            addr_t       v;

            z_core.free_count -= (1 << order);

            z_core.busy_count += (1 << order);

            frame = (frame_t*)tmp;

                frame[i].parent = slab;

            v = z_core.base + (index_t)(frame - z_core.frames);

            slab->next  = 0;

                slab->list[i] = i + 1;

        }

        else

        {

            spinlock_unlock(&z_core.lock);

            frame_free(KA2PA(slab));

            slab = NULL;

        };

    };

}

{

    u32_t order;

    count_t idx;

    frame_t *frame;

    frame = &z_core.frames[idx];

	order = frame->buddy_order;

    {

        spinlock_lock(&z_core.lock);

        z_core.free_count += (1 << order);

        z_core.busy_count -= (1 << order);

    }

#endif

{

    eflags_t  efl;

    pslab_t  *slab;

    addr_t    frame;

    {

        slab = create_page_slab();

        if (!slab)

        {

            spinlock_unlock(&page_cache.lock);

            safe_sti(efl);

            return 0;

        }

        slab->parent = &page_cache;

        slab->state  = 1;

        page_cache.partial_count++;

        list_prepend(&slab->link, &page_cache.partial_slabs);

    }

    else

        slab = (pslab_t*)page_cache.partial_slabs.next;

    slab->next = slab->list[slab->next];

    if( slab->avail == 0 )

    {

        slab->state  = 0;

        list_remove(&slab->link);

        list_prepend(&slab->link, &page_cache.full_slabs);

        page_cache.partial_count--;

        DBG("%s insert empty page slab\n", __FUNCTION__);

    };

    spinlock_unlock(&page_cache.lock);

}

{

    addr_t    frame;

    {

        eflags_t  efl;

        index_t   order;

        frame_t  *tmp;

        count_t   i;

        z_core.busy_count += (1 << order);

            tmp[i].parent = NULL;

                (index_t)(tmp - z_core.frames)) << PAGE_WIDTH;

             frame, order, z_core.free_count);

    }

    else

        frame = alloc_page();

}

{

    eflags_t  efl;

    index_t   idx;

    frame_t  *frame;

    size_t    frame_size;

        (idx >= z_core.base+z_core.count)) {

        DBG("%s: invalid address %x\n", __FUNCTION__, addr);

        return 0;

    }

    {

        pslab_t  *slab;

        slab->next = idx;

             (slab->avail >= 4))

        {

            slab->state = 1;

            list_remove(&slab->link);

            list_prepend(&slab->link, &page_cache.partial_slabs);

            page_cache.partial_count++;

        }

        spinlock_unlock(&page_cache.lock);

    }

    else

    {

        count_t   order;

        {

            buddy_system_free(&frame->buddy_link);

            z_core.free_count += (1 << order);

            z_core.busy_count -= (1 << order);

        }

        spinlock_unlock(&z_core.lock);

    };

    safe_sti(efl);

}

{

   return z_core.free_count;

}