page_frame.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdio.h>
#include <errno.h>
#include <stddef.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <string.h>
#include <pthread.h>

#include <debug.h>

#include <list.h>
#include <cpu_node.h>
#include <zone.h>
#include <page_frame.h>
#include <page_allocator.h>

static pthread_mutex_t s_lock = PTHREAD_MUTEX_INITIALIZER;

static inline struct page_frame *find_frame(void *page, struct zone **_zone)
{
        struct zone *zone;
        struct list_head *pos;
        struct list_head *n;
        struct page_frame *frame;

        zone = find_zone_by_addr(page);
        if (!zone) {
                return NULL;
        }

        frame = NULL;
        list_for_each_safe(pos, n, &zone->page_list) {
                frame = list_entry(pos, struct page_frame, page_head);
                if (frame->pma == page) {
                        break;
                }

                frame = NULL;
        }

        if (_zone) {
                *_zone = zone;
        }

        return frame;
}

int page_frame_init(struct zone *zone, void *base, size_t size)
{
        void *info;

        info = malloc(page_allocator_info_size(size));
        if (!info) {
                return -ENOMEM;
        }

        zone->handle = page_allocator_init(info, base, size);
        if (!zone->handle) {
                free(info);
                return -EFAULT;
        }

        return 0;
}

int page_frame_fini(struct zone *zone)
{
        struct list_head *pos;
        struct list_head *n;
        struct page_frame *frame;

        list_for_each_safe(pos, n, &zone->page_list) {
                frame = list_entry(pos, struct page_frame, page_head);
                page_allocator_free(zone->handle, frame->pma);
        }

        list_for_each_safe(pos, n, &zone->managed_page_list) {
                frame = list_entry(pos, struct page_frame, page_head);
                list_del(&frame->page_head);
                free(frame);
        }

        return 0;
}

void *page_frame_alloc(enum zone_type zone_type, size_t nr_of_pages)
{
        struct page_frame *frame;
        struct zone *zone;
        void *ret = NULL;

        pthread_mutex_lock(&s_lock);
        NEED_LOCK_TEST_BEGIN

        zone = find_zone(zone_type);
        if (!zone) {
                dbg_printf("Failed to find a zone\n");
                goto out;
        }

        frame = malloc(sizeof(*frame));
        if (!frame) {
                dbg_printf("Failed to allocate frame\n");
                goto out;
        }

        frame->pma = page_allocator_alloc(zone->handle, nr_of_pages);
        if (frame->pma == (void *)-1) {
                free(frame);
                dbg_printf("Failed to allocate a page\n");
                goto out;
        }

        frame->refcnt = 1;
        list_add_tail(&frame->page_head, &zone->page_list);

        ret = frame->pma;

out:
        NEED_LOCK_TEST_END
        pthread_mutex_unlock(&s_lock);
        return ret;
}

int page_frame_free(void *page)
{
        struct page_frame *frame;
        struct zone *zone;
        int ret = 0;

        pthread_mutex_lock(&s_lock);
        NEED_LOCK_TEST_BEGIN

        frame = find_frame(page, &zone);
        if (!frame) {
                ret = -EINVAL;
                goto out;
        }

        frame->refcnt--;
        if (frame->refcnt > 0) {
                goto out;
        }

        page_allocator_free(zone->handle, frame->pma);
        list_del(&frame->page_head);
        free(frame);
        
out:
        NEED_LOCK_TEST_END
        pthread_mutex_unlock(&s_lock);
        return ret;
}

int page_frame_ref(void *page)
{
        struct page_frame *frame;
        int ret = 0;

        pthread_mutex_lock(&s_lock);
        NEED_LOCK_TEST_BEGIN

        frame = find_frame(page, NULL);
        if (!frame) {
                ret = -ENOENT;
                goto out;
        }

        frame->refcnt++;

out:
        NEED_LOCK_TEST_END
        pthread_mutex_unlock(&s_lock);
        return ret;
}

int page_frame_refcnt(void *page)
{
        struct page_frame *frame;
        int refcnt;

        pthread_mutex_lock(&s_lock);
        NEED_LOCK_TEST_BEGIN

        frame = find_frame(page, NULL);
        if (!frame) {
                refcnt = -ENOENT;
                goto out;
        }

        refcnt = frame->refcnt;

out:
        NEED_LOCK_TEST_END
        pthread_mutex_unlock(&s_lock);
        return refcnt;
}

int page_frame_manage(enum zone_type type, void *page, int nr_of_pages)
{
        struct page_frame *frame;
        struct zone *zone;
        int ret = 0;

        pthread_mutex_lock(&s_lock);
        NEED_LOCK_TEST_BEGIN

        frame = find_frame(page, NULL);
        if (frame) {
                ret = -EEXIST;
                goto out;
        }

        zone = find_zone(type);
        if (!zone) {
                ret = -EINVAL;
                goto out;
        }

        frame = malloc(sizeof(*frame));
        if (!frame) {
                ret = -ENOMEM;
                goto out;
        }

        frame->pma = page;
        frame->refcnt = 1;

        list_add_tail(&frame->page_head, &zone->managed_page_list);

out:
        NEED_LOCK_TEST_END
        pthread_mutex_unlock(&s_lock);
        return ret;
}

/* @} End of a file */