Subversion Repositories c0or1k

/*
 * Copyright (C) 2008 Bahadir Balban
 */
#include <l4/macros.h>
#include <l4/lib/list.h>
#include L4LIB_INC_ARCH(syscalls.h)
#include L4LIB_INC_ARCH(syslib.h)
#include <malloc/malloc.h>
#include <mm/alloc_page.h>
#include <vm_area.h>
#include <string.h>
#include <globals.h>
#include <file.h>
#include <init.h>
#include <l4/api/errno.h>
#include <fs.h>
 
struct page *page_init(struct page *page)
{
	/* Reset page */
	memset(page, 0, sizeof(*page));
	page->refcnt = -1;
	spin_lock_init(&page->lock);
	link_init(&page->list);
 
	return page;
}
 
struct page *find_page(struct vm_object *obj, unsigned long pfn)
{
	struct page *p;
 
	list_foreach_struct(p, &obj->page_cache, list)
		if (p->offset == pfn)
			return p;
 
	return 0;
}
 
/*
 * Deletes all pages in a page cache, assumes pages are from the
 * page allocator, and page structs are from the page_array, which
 * is the default situation.
 */
int default_release_pages(struct vm_object *vm_obj)
{
	struct page *p, *n;
 
	list_foreach_removable_struct(p, n, &vm_obj->page_cache, list) {
		list_remove_init(&p->list);
		BUG_ON(p->refcnt);
 
		/* Reinitialise the page */
		page_init(p);
 
		/* Return page back to allocator */
		free_page((void *)page_to_phys(p));
 
		/* Reduce object page count */
		BUG_ON(--vm_obj->npages < 0);
	}
	return 0;
}
 
int file_page_out(struct vm_object *vm_obj, unsigned long page_offset)
{
	struct vm_file *f = vm_object_to_file(vm_obj);
	struct page *page;
	void *paddr;
	int err;
 
	/* Check first if the file has such a page at all */
	if (__pfn(page_align_up(f->length) <= page_offset)) {
		printf("%s: %s: Trying to look up page %lu, but file length "
		       "is %lu bytes.\n", __TASKNAME__, __FUNCTION__,
		       page_offset, f->length);
		BUG();
	}
 
	/* If the page is not in the page cache, simply return. */
	if (!(page = find_page(vm_obj, page_offset)))
		return 0;
 
	/* If the page is not dirty, simply return */
	if (!(page->flags & VM_DIRTY))
		return 0;
 
	paddr = (void *)page_to_phys(page);
 
	//printf("%s/%s: Writing to vnode %lu, at pgoff 0x%lu, %d pages, buf at %p\n",
	//	__TASKNAME__, __FUNCTION__, f->vnode->vnum, page_offset, 1, vaddr);
 
	/* Syscall to vfs to write page back to file. */
	if ((err = vfs_write(f->vnode, page_offset, 1,
			     phys_to_virt(paddr))) < 0)
		return err;
 
	/* Clear dirty flag */
	page->flags &= ~VM_DIRTY;
 
	return 0;
}
 
struct page *file_page_in(struct vm_object *vm_obj, unsigned long page_offset)
{
	struct vm_file *f = vm_object_to_file(vm_obj);
	struct page *page;
	void *paddr;
	int err;
 
	/* Check first if the file has such a page at all */
	if (__pfn(page_align_up(f->length) <= page_offset)) {
		printf("%s: %s: Trying to look up page %lu, but file length "
		       "is %lu bytes.\n", __TASKNAME__, __FUNCTION__,
		       page_offset, f->length);
		BUG();
	}
 
	/* Call vfs only if the page is not resident in page cache. */
	if (!(page = find_page(vm_obj, page_offset))) {
		/* Allocate a new page */
		paddr = alloc_page(1);
		page = phys_to_page(paddr);
 
		/* Call to vfs to read into the page. */
		if ((err = vfs_read(f->vnode, page_offset,
				    1, phys_to_virt(paddr))) < 0) {
 
			free_page(paddr);
			return PTR_ERR(err);
		}
 
	//	printf("%s/%s: Reading into vnode %lu, at pgoff 0x%lu, %d pages, buf at %p\n",
	//	       __TASKNAME__, __FUNCTION__, f->vnode->vnum, page_offset, 1, vaddr);
 
		/* Update vm object details */
		vm_obj->npages++;
 
		/* Update page details */
		page_init(page);
		page->refcnt++;
		page->owner = vm_obj;
		page->offset = page_offset;
		page->virtual = 0;
 
		/* Add the page to owner's list of in-memory pages */
		BUG_ON(!list_empty(&page->list));
		insert_page_olist(page, vm_obj);
	}
 
	return page;
}
 
/*
 * All non-mmapable char devices are handled by this.
 * VFS calls those devices to read their pages
 */
struct vm_pager file_pager = {
	.ops = {
		.page_in = file_page_in,
		.page_out = file_page_out,
		.release_pages = default_release_pages,
	},
};
 
 
/* A proposal for shadow vma container, could be part of vm_file->priv_data */
struct vm_swap_node {
	struct vm_file *swap_file;
	struct task_ids task_ids;
	struct address_pool *pool;
};
 
/*
 * This should save swap_node/page information either in the pte or in a global
 * list of swap descriptors, and then write the page into the possibly one and
 * only swap file.
 */
struct page *swap_page_in(struct vm_object *vm_obj, unsigned long file_offset)
{
	struct page *p;
 
	/* No swapping yet, so the page is either here or not here. */
	if (!(p = find_page(vm_obj, file_offset)))
		return PTR_ERR(-EINVAL);
	else
		return p;
}
 
struct vm_pager swap_pager = {
	.ops = {
		.page_in = swap_page_in,
		.release_pages = default_release_pages,
	},
};
 
/*
 * Just releases the page structures since the actual pages are
 * already in memory as read-only.
 */
int bootfile_release_pages(struct vm_object *vm_obj)
{
	struct page *p, *n;
 
	list_foreach_removable_struct(p, n, &vm_obj->page_cache, list) {
		list_remove(&p->list);
		BUG_ON(p->refcnt);
 
		/* Reinitialise the page */
		page_init(p);
 
		/*
		 * We don't free the page because it doesn't
		 * come from the page allocator
		 */
		// free_page((void *)page_to_phys(p));
 
 
		/* Reduce object page count */
		BUG_ON(--vm_obj->npages < 0);
	}
	return 0;
}
 
#if 0
/* Returns the page with given offset in this vm_object */
struct page *bootfile_page_in(struct vm_object *vm_obj,
			      unsigned long offset)
{
	struct vm_file *boot_file = vm_object_to_file(vm_obj);
	struct svc_image *img = boot_file->priv_data;
	struct page *page;
 
	/* Check first if the file has such a page at all */
	if (__pfn(page_align_up(boot_file->length) <= offset)) {
		printf("%s: %s: Trying to look up page %lu, but file length "
		       "is %lu bytes.\n", __TASKNAME__, __FUNCTION__,
		       offset, boot_file->length);
		BUG();
	}
 
	/* The page is not resident in page cache. */
	if (!(page = find_page(vm_obj, offset))) {
		page = phys_to_page(img->phys_start + __pfn_to_addr(offset));
 
		/* Update page */
		page_init(page);
		page->refcnt++;
		page->owner = vm_obj;
		page->offset = offset;
 
		/* Update object */
		vm_obj->npages++;
 
		/* Add the page to owner's list of in-memory pages */
		BUG_ON(!list_empty(&page->list));
		insert_page_olist(page, vm_obj);
	}
 
	return page;
}
 
struct vm_pager bootfile_pager = {
	.ops = {
		.page_in = bootfile_page_in,
		.release_pages = bootfile_release_pages,
	},
};
 
void bootfile_destroy_priv_data(struct vm_file *bootfile)
{
 
}
 
/* From bare boot images, create mappable device files */
int init_boot_files(struct initdata *initdata)
{
	struct bootdesc *bd = initdata->bootdesc;
	struct vm_file *boot_file;
	struct svc_image *img;
 
	link_init(&initdata->boot_file_list);
 
	for (int i = 0; i < bd->total_images; i++) {
		img = &bd->images[i];
		boot_file = vm_file_create();
 
		/* Allocate private data */
		boot_file->priv_data = kzalloc(sizeof(*img));
		memcpy(boot_file->priv_data, img, sizeof(*img));
 
		boot_file->length = img->phys_end - img->phys_start;
		boot_file->type = VM_FILE_BOOTFILE;
		boot_file->destroy_priv_data =
			bootfile_destroy_priv_data;
 
		/* Initialise the vm object */
		boot_file->vm_obj.flags = VM_OBJ_FILE;
		boot_file->vm_obj.pager = &bootfile_pager;
 
		/* Add the file to initdata's bootfile list */
		list_insert_tail(&boot_file->list, &initdata->boot_file_list);
	}
 
	return 0;
}
#endif
 
/*
 * FIXME:
 * Problem is that devzero is a character device and we don't have a
 * character device subsystem yet.
 *
 * Therefore even though the vm_file for devzero requires a vnode,
 * currently it has no vnode field, and the information (the zero page)
 * that needs to be stored in the dynamic vnode is now stored in the
 * field file_private_data in the vm_file, which really needs to be
 * removed.
 */
 
/* Returns the page with given offset in this vm_object */
struct page *devzero_page_in(struct vm_object *vm_obj,
			     unsigned long page_offset)
{
	struct vm_file *devzero = vm_object_to_file(vm_obj);
	struct page *zpage = devzero->private_file_data;
 
	BUG_ON(!(devzero->type & VM_FILE_DEVZERO));
 
	/* Update zero page struct. */
	spin_lock(&zpage->lock);
	BUG_ON(zpage->refcnt < 0);
	zpage->refcnt++;
	spin_unlock(&zpage->lock);
 
	return zpage;
}
 
struct vm_pager devzero_pager = {
	.ops = {
		.page_in = devzero_page_in,
	},
};
 
struct vm_file *get_devzero(void)
{
	struct vm_file *f;
 
	list_foreach_struct(f, &global_vm_files.list, list)
		if (f->type == VM_FILE_DEVZERO)
			return f;
	return 0;
}
 
int init_devzero(void)
{
	void *zphys, *zvirt;
	struct page *zpage;
	struct vm_file *devzero;
 
	/* Allocate and initialise the zero page */
	zphys = alloc_page(1);
	zpage = phys_to_page(zphys);
	zvirt = (void *)phys_to_virt(zphys);
	memset(zvirt, 0, PAGE_SIZE);
 
	/*
	 * FIXME:
	 * Flush the dcache if virtual data cache
	 */
 
	/* Allocate and initialise devzero file */
	devzero = vm_file_create();
	devzero->type = VM_FILE_DEVZERO;
	devzero->private_file_data = zpage;
	devzero->length = page_align(~0UL); /* So we dont wraparound to 0! */
	devzero->vm_obj.npages = __pfn(devzero->length);
	devzero->vm_obj.pager = &devzero_pager;
	devzero->vm_obj.flags = VM_OBJ_FILE;
 
	/* Initialise zpage */
	zpage->refcnt++;
	zpage->owner = &devzero->vm_obj;
 
	global_add_vm_file(devzero);
	return 0;
}