Merged fs0 to mm0 for simpler progress on posix api.

mm0 and all other posix dependents are building ok.

conts/posix/mm0/fs/bdev.c

@@ -0,0 +1,15 @@
+/*
+ * This is just to allocate some memory as a block device.
+ */
+#include <l4/macros.h>
+#include <memfs/memfs.h>
+
+extern char _start_bdev[];
+extern char _end_bdev[];
+
+__attribute__((section(".data.memfs"))) char blockdevice[MEMFS_TOTAL_SIZE];
+
+void *vfs_rootdev_open(void)
+{
+	return (void *)_start_bdev;
+}

conts/posix/mm0/fs/c0fs/c0fs.h

@@ -0,0 +1,113 @@
+/*
+ * The disk layout of our simple unix-like filesystem.
+ *
+ * Copyright (C) 2007, 2008 Bahadir Balban
+ */
+
+#ifndef __C0FS_LAYOUT_H__
+#define __C0FS_LAYOUT_H__
+
+#include <l4lib/types.h>
+#include <l4/lib/list.h>
+#include <l4/macros.h>
+#include <l4/config.h>
+#include INC_GLUE(memory.h)
+
+/*
+ *
+ * Filesystem layout:
+ *
+ * |---------------|
+ * |    Group 0    |
+ * |---------------|
+ * |    Group 1    |
+ * |---------------|
+ * |      ...      |
+ * |---------------|
+ * |    Group n    |
+ * |---------------|
+ *
+ *
+ * Group layout:
+ *
+ * |---------------|
+ * |  Superblock   |
+ * |---------------|
+ * |  Inode table  |
+ * |---------------|
+ * |  Data blocks  |
+ * |---------------|
+ *
+ * or
+ *
+ * |---------------|
+ * |  Data blocks  |
+ * |---------------|
+ *
+ */
+
+#define BLOCK_SIZE		PAGE_SIZE
+#define BLOCK_BITS		PAGE_BITS
+#define GROUP_SIZE		SZ_8MB
+#define INODE_TABLE_SIZE	((GROUP_SIZE / BLOCK_SIZE) / 2)
+#define INODE_BITMAP_SIZE	(INODE_TABLE_SIZE >> 5)
+
+
+struct sfs_superblock {
+	u32 magic;		/* Filesystem magic number */
+	u64 fssize;		/* Total size of filesystem */
+	u32 total;		/* To */
+	u32 groupmap[];		/* Bitmap of all fs groups */
+};
+
+struct sfs_group_table {
+	u32 total;
+	u32 free;
+	u32 groupmap[];
+};
+
+struct sfs_inode_table {
+	u32 total;
+	u32 free;
+	u32 inodemap[INODE_BITMAP_SIZE];
+	struct sfs_inode inode[INODE_TABLE_SIZE];
+};
+
+/*
+ * The purpose of an inode:
+ *
+ * 1) Uniquely identify a file or a directory.
+ * 2) Keep file/directory metadata.
+ * 3) Provide access means to file blocks/directory contents.
+ */
+#define INODE_DIRECT_BLOCKS	5
+struct sfs_inode_blocks {
+	int  szidx;		/* Direct array index size */
+	unsigned long indirect;
+	unsigned long indirect2;
+	unsigned long indirect3;
+	unsigned long direct[];
+};
+
+struct sfs_inode {
+	u32 unum;	/* Unit number this inode is in */
+	u32 inum;	/* Inode number */
+	u32 mode;	/* File permissions */
+	u32 owner;	/* File owner */
+	u64 atime;	/* Last access time */
+	u64 mtime;	/* Last content modification */
+	u64 ctime;	/* Last inode modification */
+	u64 size;	/* Size of contents */
+	struct sfs_inode_blocks blocks;
+} __attribute__ ((__packed__));
+
+struct sfs_dentry {
+	u32 inum;	/* Inode number */
+	u32 nlength;	/* Name length */
+	u8  name[];	/* Name string */
+} __attribute__ ((__packed__));
+
+
+void sfs_register_type(struct link *);
+
+#endif /* __C0FS_LAYOUT_H__ */

conts/posix/mm0/fs/file.c

@@ -0,0 +1,25 @@
+/*
+ * File content tracking.
+ *
+ * Copyright (C) 2008 Bahadir Balban
+ */
+#include <fs.h>
+#include <file.h>
+#include <l4/lib/list.h>
+#include <l4/macros.h>
+#include INC_GLUE(memory.h)
+#include <stdio.h>
+
+/*
+ * This reads contents of a file in pages, calling the fs-specific file read function to read-in
+ * those pages' contents.
+ *
+ * Normally this is ought to be called by mm0 when a file's pages cannot be found in the page
+ * cache.
+ */
+int generic_file_read(struct vnode *v, unsigned long pfn, unsigned long npages, void *page_buf)
+{
+	BUG_ON(!is_page_aligned(page_buf));
+
+	return v->fops.read(v, pfn, npages, page_buf);
+}

conts/posix/mm0/fs/init.c

@@ -0,0 +1,88 @@
+/*
+ * FS0 Initialisation.
+ *
+ * Copyright (C) 2007 Bahadir Balban
+ */
+#include <fs.h>
+#include <vfs.h>
+#include <bdev.h>
+#include <task.h>
+#include <stdio.h>
+#include <string.h>
+#include <l4/lib/list.h>
+#include <l4/api/errno.h>
+#include <memfs/memfs.h>
+
+struct link fs_type_list;
+
+struct superblock *vfs_probe_filesystems(void *block)
+{
+	struct file_system_type *fstype;
+	struct superblock *sb;
+
+	list_foreach_struct(fstype, &fs_type_list, list) {
+		/* Does the superblock match for this fs type? */
+		if ((sb = fstype->ops.get_superblock(block))) {
+			/*
+			 * Add this to the list of superblocks this
+			 * fs already has.
+			 */
+			list_insert(&sb->list, &fstype->sblist);
+			return sb;
+		}
+	}
+
+	return PTR_ERR(-ENODEV);
+}
+
+/*
+ * Registers each available filesystem so that these can be
+ * used when probing superblocks on block devices.
+ */
+void vfs_register_filesystems(void)
+{
+	/* Initialise fstype list */
+	link_init(&fs_type_list);
+
+	/* Call per-fs registration functions */
+	memfs_register_fstype(&fs_type_list);
+}
+
+/*
+ * Filesystem initialisation.
+ */
+int initialise(void)
+{
+	void *rootdev_blocks;
+	struct superblock *root_sb;
+
+	/* Get standard init data from microkernel */
+	// request_initdata(&initdata);
+
+	/* Register compiled-in filesystems with vfs core. */
+	vfs_register_filesystems();
+
+	/* Get a pointer to first block of root block device */
+	rootdev_blocks = vfs_rootdev_open();
+
+	/*
+	 * Since the *only* filesystem we have is a temporary memory
+	 * filesystem, we create it on the root device first.
+	 */
+	memfs_format_filesystem(rootdev_blocks);
+
+	/* Search for a filesystem on the root device */
+	BUG_ON(IS_ERR(root_sb = vfs_probe_filesystems(rootdev_blocks)));
+
+	/* Mount the filesystem on the root device */
+	vfs_mount_root(root_sb);
+
+	printf("%s: Mounted memfs root filesystem.\n", __TASKNAME__);
+
+	/*
+	 * Initialisation is done. From here on, we can start
+	 * serving filesystem requests.
+	 */
+	return 0;
+}
+

conts/posix/mm0/fs/lookup.c

@@ -0,0 +1,90 @@
+/*
+ * Inode lookup.
+ *
+ * Copyright (C) 2007, 2008 Bahadir Balban
+ */
+#include <fs.h>
+#include <vfs.h>
+#include <stat.h>
+#include <l4/api/errno.h>
+#include <lib/pathstr.h>
+#include <path.h>
+
+/*
+ * Given a dentry that has been populated by readdir with children dentries
+ * and their vnodes, this itself checks all those children on that level for
+ * a match, but it also calls lookup, which recursively checks lower levels.
+ */
+struct vnode *lookup_dentry_children(struct dentry *parentdir,
+				     struct pathdata *pdata)
+{
+	struct dentry *childdir;
+	struct vnode *v;
+	const char *component = pathdata_next_component(pdata);
+
+	list_foreach_struct(childdir, &parentdir->children, child)
+		if (IS_ERR(v = childdir->vnode->ops.lookup(childdir->vnode,
+							   pdata, component)))
+			/* Means not found, continue search */
+			if ((int)v == -ENOENT)
+				continue;
+			else	/* A real error */
+				return v;
+		else	/* No error, so found it */
+			return v;
+
+	/* Out of all children dentries, neither was a match */
+	return PTR_ERR(-ENOENT);
+}
+
+/* Lookup, recursive, assuming single-mountpoint */
+struct vnode *generic_vnode_lookup(struct vnode *thisnode,
+				   struct pathdata *pdata,
+				   const char *component)
+{
+	struct dentry *d;
+	struct vnode *found;
+	int err;
+
+	/* Does this path component match with any of this vnode's dentries? */
+	list_foreach_struct(d, &thisnode->dentries, vref) {
+		if (d->ops.compare(d, component)) {
+			/* Is this a directory? */
+			if (vfs_isdir(thisnode)) {
+				/* Are there more path components? */
+				if (!list_empty(&pdata->list)) {
+					/* Read directory contents */
+					if ((err = d->vnode->ops.readdir(d->vnode)) < 0)
+						return PTR_ERR(err);
+
+					/* Search all children one level below. */
+					if ((found = lookup_dentry_children(d, pdata)))
+					 	/* Either found, or non-zero error */
+						return found;
+				} else
+					return thisnode;
+			} else { /* Its a file */
+				if (!list_empty(&pdata->list)) /* There's still path, but not directory */
+					return PTR_ERR(-ENOTDIR);
+				else /* No path left, found it, so return file */
+					return thisnode;
+			}
+		}
+	}
+
+	/* Not found, return nothing */
+	return PTR_ERR(-ENOENT);
+}
+
+int generic_dentry_compare(struct dentry *d, const char *name)
+{
+	if (!strcmp(d->name, name) || !strcmp(name, VFS_STR_CURDIR))
+		return 1;
+	else
+		return 0;
+}
+
+struct dentry_ops generic_dentry_operations = {
+	.compare = generic_dentry_compare,
+};
+

conts/posix/mm0/fs/memfs/file.c

@@ -0,0 +1,142 @@
+/*
+ * Memfs file operations
+ *
+ * Copyright (C) 2008 Bahadir Balban
+ */
+#include <fs.h>
+#include <vfs.h>
+#include <file.h>
+#include <memfs/memfs.h>
+#include <stdio.h>
+#include <string.h>
+#include <l4/macros.h>
+#include <l4/api/errno.h>
+#include INC_GLUE(memory.h)
+
+
+#if 0
+
+/*
+ * FIXME: read_write() could be more layered using these functions.
+ */
+void *memfs_read_block(struct vnode *v, int blknum)
+{
+	void *buf = vfs_alloc_block();
+
+	if (!buf)
+		return PTR_ERR(-ENOMEM);
+
+	if(!v->block[blknum])
+		return PTR_ERR(-EEXIST);
+
+	memcpy(buf, &v->block[blknum], v->sb->blocksize);
+	return buf;
+}
+
+int memfs_write_block(struct vnode *v, int blknum, void *buf)
+{
+	if(!v->block[blknum])
+		return -EEXIST;
+
+	memcpy(&v->block[blknum], buf, v->sb->blocksize);
+	return 0;
+}
+#endif
+
+/*
+ * Handles both read and writes since most details are common.
+ *
+ * TODO: Think about whether to use inode or the vnode's fields (e.g. size)
+ * and when updated, which one is to be updated first. Normally if you use and
+ * update inode, then you sync vnode via read_vnode. but this is not really meant for
+ * this use, its meant for retrieving an unknown inode under the vnode with valid vnum.
+ * here we already have the inode.
+ */
+int memfs_file_read_write(struct vnode *v, unsigned int pfn,
+			  unsigned int npages, void *buf, int wr)
+{
+	struct memfs_inode *i;
+	struct memfs_superblock *memfs_sb;
+	unsigned int start, end, count;
+	u32 blocksize;
+
+	/* Don't support different block and page sizes for now */
+	BUG_ON(v->sb->blocksize != PAGE_SIZE);
+
+	/* Buffer must be page aligned */
+	BUG_ON(!is_page_aligned(buf));
+
+	/* Low-level fs refs must be valid */
+	BUG_ON(!(i = v->inode));
+	BUG_ON(!(memfs_sb = v->sb->fs_super));
+	blocksize = v->sb->blocksize;
+
+	/* Check filesystem per-file size limit */
+	if ((pfn + npages) > memfs_sb->fmaxblocks) {
+		printf("%s: fslimit: Trying to %s outside maximum file range: %x-%x\n",
+		       __FUNCTION__, (wr) ? "write" : "read", pfn, pfn + npages);
+		return -EINVAL;	/* Same error that posix llseek returns */
+	}
+
+	/* Read-specific operations */
+	if (!wr) {
+		/* Find read boundaries from expected range and file's current range */
+		start = pfn < __pfn(v->size) ? pfn : __pfn(v->size);
+		end = pfn + npages < __pfn(page_align_up(v->size))
+		      ? pfn + npages : __pfn(page_align_up(v->size));
+		count = end - start;
+
+		/* Copy the data from inode blocks into page buffer */
+		for (int x = start, bufpage = 0; x < end; x++, bufpage++)
+			memcpy(((void *)buf) + (bufpage * blocksize),
+			       i->block[x], blocksize);
+		return (int)(count * blocksize);
+	} else { /* Write-specific operations */
+		/* Is the write beyond current file size? */
+		if (v->size < ((pfn + npages) * (blocksize))) {
+			unsigned long pagediff = pfn + npages - __pfn(v->size);
+			unsigned long holes;
+
+			/*
+			 * If write is not consecutively after the currently
+			 * last file block, the gap must be filled in by holes.
+			 */
+			if (pfn > __pfn(v->size))
+				holes = pfn - __pfn(v->size);
+			else
+				holes = 0;
+
+			/* Allocate new blocks */
+			for (int x = 0; x < pagediff; x++)
+				if (!(i->block[__pfn(v->size) + x] =
+				      memfs_alloc_block(v->sb->fs_super)))
+					return -ENOSPC;
+
+			/* Zero out the holes. FIXME: How do we zero out non-page-aligned bytes?` */
+			for (int x = 0; x < holes; x++)
+				memset(i->block[__pfn(v->size) + x], 0, blocksize);
+		}
+
+		/* Copy the data from page buffer into inode blocks */
+		for (int x = pfn, bufpage = 0; x < pfn + npages; x++, bufpage++)
+			memcpy(i->block[x], ((void *)buf) + (bufpage * blocksize), blocksize);
+	}
+
+	return (int)(npages * blocksize);
+}
+
+int memfs_file_write(struct vnode *v, unsigned long pfn, unsigned long npages, void *buf)
+{
+	return memfs_file_read_write(v, pfn, npages, buf, 1);
+}
+
+int memfs_file_read(struct vnode *v, unsigned long pfn, unsigned long npages, void *buf)
+{
+	return memfs_file_read_write(v, pfn, npages, buf, 0);
+}
+
+struct file_ops memfs_file_operations = {
+	.read = memfs_file_read,
+	.write = memfs_file_write,
+};
+

conts/posix/mm0/fs/memfs/memfs.c

@@ -0,0 +1,215 @@
+/*
+ * A simple read/writeable memory-only filesystem.
+ *
+ * Copyright (C) 2007, 2008 Bahadir Balban
+ */
+#include <init.h>
+#include <fs.h>
+#include <vfs.h>
+#include <task.h>
+#include <stdio.h>
+#include <memfs/memfs.h>
+#include <memfs/vnode.h>
+#include <lib/idpool.h>
+#include <l4/macros.h>
+#include <l4/types.h>
+#include <l4/api/errno.h>
+#include INC_GLUE(memory.h)
+
+struct memfs_superblock *memfs_superblock;
+
+/* Initialise allocation caches as part of superblock initialisation */
+int memfs_init_caches(struct memfs_superblock *sb)
+{
+	void *free_block;
+	struct mem_cache *block_cache;
+	struct mem_cache *inode_cache;
+
+	/* Use the whole filesystem space to initialise block cache */
+	free_block = (void *)sb + sizeof(*sb);
+	block_cache = mem_cache_init(free_block, sb->fssize - sizeof(*sb),
+				     sb->blocksize, 1);
+	list_insert(&block_cache->list, &sb->block_cache_list);
+
+	/* Allocate a block and initialise it as first inode cache */
+	free_block = mem_cache_alloc(block_cache);
+	inode_cache = mem_cache_init(free_block, sb->blocksize,
+				     sizeof(struct memfs_inode), 0);
+	list_insert(&inode_cache->list, &sb->inode_cache_list);
+
+	return 0;
+}
+
+/*
+ * Given an empty block buffer, initialises a filesystem there.
+ */
+int memfs_format_filesystem(void *buffer)
+{
+	struct memfs_superblock *sb = buffer;	/* Buffer is the first block */
+
+	/* Zero initialise the superblock area */
+	memset(sb, 0, sizeof(*sb));
+
+	/* Initialise filesystem parameters */
+	sb->magic = MEMFS_MAGIC;
+	memcpy(sb->name, MEMFS_NAME, MEMFS_NAME_SIZE);
+	sb->blocksize = MEMFS_BLOCK_SIZE;
+	sb->fmaxblocks = MEMFS_FMAX_BLOCKS;
+	sb->fssize = MEMFS_TOTAL_SIZE;
+
+	/* Initialise block and inode index pools */
+	sb->ipool = id_pool_new_init(MEMFS_TOTAL_INODES);
+	sb->bpool = id_pool_new_init(MEMFS_TOTAL_BLOCKS);
+
+	/* Initialise bitmap allocation lists for blocks and inodes */
+	link_init(&sb->block_cache_list);
+	link_init(&sb->inode_cache_list);
+	memfs_init_caches(sb);
+
+	return 0;
+}
+
+/* Allocates a block of unused buffer */
+void *memfs_alloc_block(struct memfs_superblock *sb)
+{
+	struct mem_cache *cache;
+
+	list_foreach_struct(cache, &sb->block_cache_list, list) {
+		if (cache->free)
+			return mem_cache_zalloc(cache);
+		else
+			continue;
+	}
+	return PTR_ERR(-ENOSPC);
+}
+
+/*
+ * Even though on a list, block allocation is currently from a single cache.
+ * This frees a block back to the free buffer cache.
+ */
+int memfs_free_block(struct memfs_superblock *sb, void *block)
+{
+	struct mem_cache *c, *tmp;
+
+	list_foreach_removable_struct(c, tmp, &sb->block_cache_list, list)
+		if (!mem_cache_free(c, block))
+			return 0;
+		else
+			return -EINVAL;
+	return -EINVAL;
+}
+
+struct superblock *memfs_get_superblock(void *block);
+
+struct file_system_type memfs_fstype = {
+	.name = "memfs",
+	.magic = MEMFS_MAGIC,
+	.ops = {
+		.get_superblock = memfs_get_superblock,
+	},
+};
+
+/*
+ * Initialise root inode as a directory, as in the mknod() call
+ * but differently since root is parentless and is the parent of itself.
+ */
+int memfs_init_rootdir(struct superblock *sb)
+{
+	struct memfs_superblock *msb = sb->fs_super;
+	struct dentry *d;
+	struct vnode *v;
+
+	/*
+	 * Create the root vnode. Since this is memfs, root vnode is
+	 * not read-in but dynamically created here. We expect this
+	 * first vnode to have vnum = 0.
+	 */
+	v = sb->root = sb->ops->alloc_vnode(sb);
+	msb->root_vnum = sb->root->vnum;
+	BUG_ON(msb->root_vnum != 0);
+
+	/* Initialise fields */
+	vfs_set_type(v, S_IFDIR);
+
+	/* Allocate a new vfs dentry */
+	if (!(d = vfs_alloc_dentry()))
+		return -ENOMEM;
+
+	/*
+	 * Initialise root dentry.
+	 *
+	 * NOTE: Root's parent is itself.
+	 * Here's how it looks like in structures:
+	 * root's parent is root. But root's child is not root.
+	 *
+	 * NOTE: Root has no name. This helps since splitpath
+	 * cuts out the '/' and "" is left for root name search.
+	 */
+	strncpy(d->name, VFS_STR_ROOTDIR, VFS_DNAME_MAX);
+	d->ops = generic_dentry_operations;
+	d->parent = d;
+	d->vnode = v;
+
+	/* Associate dentry with its vnode */
+	list_insert(&d->vref, &d->vnode->dentries);
+
+	/* Add both vnode and dentry to their flat caches */
+	list_insert(&d->cache_list, &dentry_cache);
+	list_insert(&v->cache_list, &vnode_cache);
+
+	return 0;
+}
+
+/* Copies fs-specific superblock into generic vfs superblock */
+struct superblock *memfs_fill_superblock(struct memfs_superblock *sb,
+					 struct superblock *vfs_sb)
+{
+	vfs_sb->fs = &memfs_fstype;
+	vfs_sb->ops = &memfs_superblock_operations;
+	vfs_sb->fs_super = sb;
+	vfs_sb->fssize = sb->fssize;
+	vfs_sb->blocksize = sb->blocksize;
+
+	/* We initialise the root vnode as the root directory */
+	memfs_init_rootdir(vfs_sb);
+
+	return vfs_sb;
+}
+
+/*
+ * Probes block buffer for a valid memfs superblock, if found,
+ * allocates and copies data to a vfs superblock, and returns it.
+ */
+struct superblock *memfs_get_superblock(void *block)
+{
+	struct memfs_superblock *sb = block;
+	struct superblock *vfs_sb;
+
+	// printf("%s: %s: Reading superblock.\n", __TASKNAME__, __FUNCTION__);
+	/* We don't do sanity checks here, just confirm id. */
+	if (strcmp(sb->name, "memfs")) {
+		printf("%s: Name does not match: %s\n", __FUNCTION__, sb->name);
+		return 0;
+	}
+	if (sb->magic != MEMFS_MAGIC) {
+		printf("%s: Magic number not match: %u\n", __FUNCTION__, sb->magic);
+		return 0;
+	}
+
+	/* Allocate a vfs superblock. */
+	vfs_sb = vfs_alloc_superblock();
+
+	/* Fill generic sb from fs-specific sb */
+	return memfs_fill_superblock(sb, vfs_sb);
+}
+
+/* Registers sfs as an available filesystem type */
+void memfs_register_fstype(struct link *fslist)
+{
+	/* Initialise superblock list for this fstype */
+	link_init(&memfs_fstype.sblist);
+
+	/* Add this fstype to list of available fstypes. */
+	list_insert(&memfs_fstype.list, fslist);
+}
+

conts/posix/mm0/fs/memfs/vnode.c

@@ -0,0 +1,427 @@
+/*
+ * Inode and vnode implementation.
+ *
+ * Copyright (C) 2008 Bahadir Balban
+ */
+#include <fs.h>
+#include <vfs.h>
+#include <memfs/memfs.h>
+#include <memfs/file.h>
+#include <l4/lib/list.h>
+#include <l4/api/errno.h>
+#include <l4/macros.h>
+#include <lib/malloc.h>
+#include <stdio.h>
+
+
+struct memfs_inode *memfs_alloc_inode(struct memfs_superblock *sb)
+{
+	struct mem_cache *cache;
+	struct memfs_inode *i;
+	void *free_block;
+
+	/* Ask existing inode caches for a new inode */
+	list_foreach_struct(cache, &sb->inode_cache_list, list) {
+		if (cache->free)
+			if (!(i =  mem_cache_zalloc(cache)))
+				return PTR_ERR(-ENOSPC);
+			else
+				return i;
+		else
+			continue;
+	}
+
+	/* Ask existing block caches for a new block */
+	if (IS_ERR(free_block = memfs_alloc_block(sb)))
+		return PTR_ERR(free_block);
+
+	/* Initialise it as an inode cache */
+	cache = mem_cache_init(free_block, sb->blocksize,
+			       sizeof(struct memfs_inode), 0);
+	list_insert(&cache->list, &sb->inode_cache_list);
+
+	if (!(i =  mem_cache_zalloc(cache)))
+		return PTR_ERR(-ENOSPC);
+	else
+		return i;
+}
+
+/*
+ * O(n^2) complexity but its simple, yet it would only reveal on high numbers.
+ */
+int memfs_free_inode(struct memfs_superblock *sb, struct memfs_inode *i)
+{
+	struct mem_cache *c, *tmp;
+
+	list_foreach_removable_struct(c, tmp, &sb->inode_cache_list, list) {
+		/* Free it, if success */
+		if (!mem_cache_free(c, i)) {
+			/* If cache completely emtpy */
+			if (mem_cache_is_empty(c)) {
+				/* Free the block, too. */
+				list_remove(&c->list);
+				memfs_free_block(sb, c);
+			}
+			return 0;
+		}
+	}
+	return -EINVAL;
+}
+
+/* Allocates *and* initialises the inode */
+struct memfs_inode *memfs_create_inode(struct memfs_superblock *sb)
+{
+	struct memfs_inode *i;
+
+	/* Allocate the inode */
+	if (PTR_ERR(i = memfs_alloc_inode(sb)) < 0)
+		return i;
+
+	/* Allocate a new inode number */
+	if ((i->inum = id_new(sb->ipool)) < 0)
+		return i;
+
+	/* Put a reference to this inode in the inode table at this index */
+	sb->inode[i->inum] = i;
+
+	return i;
+}
+
+/* Deallocate the inode and any other closely relevant structure */
+int memfs_destroy_inode(struct memfs_superblock *sb, struct memfs_inode *i)
+{
+	int inum = i->inum;
+
+	/* Deallocate the inode */
+	if (memfs_free_inode(sb, i) < 0)
+		return -EINVAL;
+
+	/* Deallocate the inode number */
+	if (id_del(sb->ipool, inum) < 0)
+		return -EINVAL;
+
+	/* Clear the ref in inode table */
+	sb->inode[inum] = 0;
+
+	return 0;
+}
+
+/* Allocates both an inode and a vnode and associates the two together */
+struct vnode *memfs_alloc_vnode(struct superblock *sb)
+{
+	struct memfs_inode *i;
+	struct vnode *v;
+
+	/* Get a (pseudo-disk) memfs inode */
+	if (IS_ERR(i = memfs_create_inode(sb->fs_super)))
+		return PTR_ERR(i);
+
+	/* Get a vnode */
+	if (!(v = vfs_alloc_vnode()))
+		return PTR_ERR(-ENOMEM);
+
+	/* Associate the two together */
+	v->inode = i;
+	v->vnum = i->inum;
+
+	/* Associate memfs-specific fields with vnode */
+	v->ops = memfs_vnode_operations;
+	v->fops = memfs_file_operations;
+	v->sb = sb;
+
+	/* Return the vnode */
+	return v;
+}
+
+/* Frees the inode and the corresponding vnode */
+int memfs_free_vnode(struct superblock *sb, struct vnode *v)
+{
+	struct memfs_inode *i = v->inode;
+
+	BUG_ON(!i); /* Vnodes that come here must have valid inodes */
+
+	/* Destroy on-disk inode */
+	memfs_destroy_inode(sb->fs_super, i);
+
+	/* Free vnode */
+	vfs_free_vnode(v);
+
+	return 0;
+}
+
+/*
+ * Given a vnode with a valid vnum, this retrieves the corresponding
+ * inode from the filesystem.
+ */
+struct memfs_inode *memfs_read_inode(struct superblock *sb, struct vnode *v)
+{
+	struct memfs_superblock *fssb = sb->fs_super;
+
+	BUG_ON(!fssb->inode[v->vnum]);
+
+	return fssb->inode[v->vnum];
+}
+
+/*
+ * Given a preallocated vnode with a valid vnum, this reads the corresponding
+ * inode from the filesystem and fills in the vnode's fields.
+ */
+int memfs_read_vnode(struct superblock *sb, struct vnode *v)
+{
+	struct memfs_inode *i = memfs_read_inode(sb, v);
+
+	if (!i)
+		return -EEXIST;
+
+	/* Simply copy common fields */
+	v->vnum = i->inum;
+	v->size = i->size;
+	v->mode = i->mode;
+	v->owner = i->owner;
+	v->atime = i->atime;
+	v->mtime = i->mtime;
+	v->ctime = i->ctime;
+
+	return 0;
+}
+
+/* Writes a valid vnode's fields back to its fs-specific inode */
+int memfs_write_vnode(struct superblock *sb, struct vnode *v)
+{
+	struct memfs_inode *i = v->inode;
+
+	/* Vnodes that come here must have valid inodes */
+	BUG_ON(!i);
+
+	/* Simply copy common fields */
+	i->inum = v->vnum;
+	i->size = v->size;
+	i->mode = v->mode;
+	i->owner = v->owner;
+	i->atime = v->atime;
+	i->mtime = v->mtime;
+	i->ctime = v->ctime;
+
+	return 0;
+}
+
+
+/*
+ * Creates ordinary files and directories at the moment. In the future,
+ * other file types will be added. Returns the created node.
+ */
+struct vnode *memfs_vnode_mknod(struct vnode *v, const char *dirname,
+				unsigned int mode)
+{
+	struct dentry *d, *parent = link_to_struct(v->dentries.next,
+					       struct dentry, vref);
+	struct memfs_dentry *memfsd;
+	struct dentry *newd;
+	struct vnode *newv;
+	int err;
+
+	/*
+	 * Precautions to prove that parent is the *only* dentry,
+	 * since directories can't have multiple dentries associated
+	 * with them.
+	 */
+	BUG_ON(list_empty(&v->dentries));
+	BUG_ON(parent->vref.next != &v->dentries);
+	BUG_ON(!vfs_isdir(v));
+
+	/* Populate the children */
+	if ((err = v->ops.readdir(v)) < 0)
+		return PTR_ERR(err);
+
+	/* Check there's no existing child with same name */
+	list_foreach_struct(d, &parent->children, child) {
+		/* Does the name exist as a child? */
+		if(d->ops.compare(d, dirname))
+			return PTR_ERR(-EEXIST);
+	}
+
+	/* Allocate a new vnode for the new directory */
+	if (IS_ERR(newv = v->sb->ops->alloc_vnode(v->sb)))
+		return newv;
+
+	/* Initialise the vnode */
+	vfs_set_type(newv, mode);
+
+	/* Get the next directory entry available on the parent vnode */
+	if (v->dirbuf.npages * PAGE_SIZE <= v->size)
+		return PTR_ERR(-ENOSPC);
+
+	/* Fill in the new entry to parent directory entry */
+	memfsd = (struct memfs_dentry *)&v->dirbuf.buffer[v->size];
+	memfsd->offset = v->size;
+	memfsd->rlength = sizeof(*memfsd);
+	memfsd->inum = ((struct memfs_inode *)newv->inode)->inum;
+	strncpy((char *)memfsd->name, dirname, MEMFS_DNAME_MAX);
+	memfsd->name[MEMFS_DNAME_MAX - 1] = '\0';
+
+	/* Write the updated directory buffer back to disk block */
+	if ((err = v->fops.write(v, 0, 1, v->dirbuf.buffer)) < 0)
+		return PTR_ERR(err); /* FIXME: free all you allocated so far */
+
+	/* Update parent vnode size */
+	v->size += sizeof(*memfsd);
+	v->sb->ops->write_vnode(v->sb, v);
+
+	/* Allocate a new vfs dentry */
+	if (!(newd = vfs_alloc_dentry()))
+		return PTR_ERR(-ENOMEM);
+
+	/* Initialise it */
+	newd->ops = generic_dentry_operations;
+	newd->parent = parent;
+	newd->vnode = newv;
+	strncpy(newd->name, dirname, VFS_DNAME_MAX);
+
+	/* Associate dentry with its vnode */
+	list_insert(&newd->vref, &newd->vnode->dentries);
+
+	/* Associate dentry with its parent */
+	list_insert(&newd->child, &parent->children);
+
+	/* Add both vnode and dentry to their flat caches */
+	list_insert(&newd->cache_list, &dentry_cache);
+	list_insert(&newv->cache_list, &vnode_cache);
+
+	return newv;
+}
+
+/*
+ * Reads the vnode directory contents into vnode's buffer in a posix-compliant
+ * struct dirent format.
+ *
+ * Reading the buffer, allocates and populates all dentries and their
+ * corresponding vnodes that are the direct children of vnode v. This means
+ * that by each call to readdir, the vfs layer increases its cache of filesystem
+ * tree by one level beneath that directory.
+ */
+int memfs_vnode_readdir(struct vnode *v)
+{
+	int err;
+	struct memfs_dentry *memfsd;
+	struct dentry *parent = link_to_struct(v->dentries.next,
+					   struct dentry, vref);
+
+	/*
+	 * Precautions to prove that parent is the *only* dentry,
+	 * since directories can't have multiple dentries associated
+	 * with them.
+	 */
+	BUG_ON(parent->vref.next != &v->dentries);
+	BUG_ON(!vfs_isdir(v));
+
+	/* If a buffer is there, it means the directory is already read */
+	if (v->dirbuf.buffer)
+		return 0;
+
+	/* This is as big as a page */
+	if (IS_ERR(v->dirbuf.buffer = vfs_alloc_dirpage(v))) {
+		printf("%s: Could not allocate dirbuf.\n", __FUNCTION__);
+		return (int)v->dirbuf.buffer;
+	}
+	v->dirbuf.npages = 1;
+
+	/*
+	 * Fail if vnode size is bigger than a page. Since this allocation
+	 * method is to be origaced, we can live with this limitation for now.
+	 */
+	BUG_ON(v->size > PAGE_SIZE);
+
+	/* Read memfsd contents into the buffer */
+	if ((err = v->fops.read(v, 0, 1, v->dirbuf.buffer)))
+		return err;
+
+	memfsd = (struct memfs_dentry *)v->dirbuf.buffer;
+
+	/* Read fs-specific directory entry into vnode and dentry caches. */
+	for (int i = 0; i < (v->size / sizeof(struct memfs_dentry)); i++) {
+		struct dentry *newd;
+		struct vnode *newv;
+
+		/* Allocate a vfs dentry */
+		if (!(newd = vfs_alloc_dentry()))
+			return -ENOMEM;
+
+		/* Initialise it */
+		newd->ops = generic_dentry_operations;
+		newd->parent = parent;
+		list_insert(&newd->child, &parent->children);
+
+		/*
+		 * Lookup the vnode for dentry by its vnode number. We call
+		 * vnode_lookup_byvnum instead of directly reading it because
+		 * this dentry might just be a link to a vnode that's already
+		 * in the vnode cache. If it's not there, the lookup function
+		 * allocates and reads it for us as well.
+		 */
+		newv = newd->vnode = vfs_lookup_byvnum(v->sb, memfsd[i].inum);
+		if (!newv) {
+			printf("Filesystem seems to be broken. Directory has"
+			       "inode number: %d, but no such inode found.\n",
+				memfsd[i].inum);
+			BUG();
+		}
+
+		/* Assing this dentry as a name of its vnode */
+		list_insert(&newd->vref, &newd->vnode->dentries);
+
+		/* Increase link count */
+		newv->links++;
+
+		/* Copy fields into generic dentry */
+		memcpy(newd->name, memfsd[i].name, MEMFS_DNAME_MAX);
+
+		/* Add both vnode and dentry to their caches */
+		list_insert(&newd->cache_list, &dentry_cache);
+		list_insert(&newv->cache_list, &vnode_cache);
+	}
+
+	return 0;
+}
+
+/*
+ * Copies fs-specific dirent data into user buffer in
+ * generic struct dirent format.
+ */
+int memfs_vnode_filldir(void *userbuf, struct vnode *v, int count)
+{
+	int nbytes;
+	int err;
+
+	/* Bytes to read, minimum of vnode size and count requested */
+	nbytes = (v->size <= count) ? v->size : count;
+
+	/* Read the dir content from fs, if haven't done so yet */
+	if ((err = v->ops.readdir(v)) < 0)
+		return err;
+
+	/* Do we have those bytes at hand? */
+	if (v->dirbuf.buffer && (v->dirbuf.npages * PAGE_SIZE) >= nbytes) {
+		/*
+		 * Memfs does a direct copy since memfs dirent format
+		 * is the same as generic dirent format.
+		 */
+		memcpy(userbuf, v->dirbuf.buffer, nbytes);
+		return nbytes;
+	}
+	return 0;
+}
+
+struct vnode_ops memfs_vnode_operations = {
+	.readdir = memfs_vnode_readdir,
+	.filldir = memfs_vnode_filldir,
+	.mknod = memfs_vnode_mknod,
+	.lookup = generic_vnode_lookup,
+};
+
+struct superblock_ops memfs_superblock_operations = {
+	.read_vnode = memfs_read_vnode,
+	.write_vnode = memfs_write_vnode,
+	.alloc_vnode = memfs_alloc_vnode,
+	.free_vnode = memfs_free_vnode,
+};
+

conts/posix/mm0/fs/path.c

@@ -0,0 +1,145 @@
+/*
+ * Path manipulation functions.
+ *
+ * Copyright (C) 2008 Bahadir Balban
+ */
+#include <l4/macros.h>
+#include <l4/lib/list.h>
+#include <l4/api/errno.h>
+#include <lib/pathstr.h>
+#include <lib/malloc.h>
+#include <path.h>
+#include <stdio.h>
+#include <fs.h>
+#include <task.h>
+#include <vfs.h>
+
+const char *pathdata_next_component(struct pathdata *pdata)
+{
+	struct pathcomp *p, *n;
+	const char *pathstr;
+
+	list_foreach_removable_struct(p, n, &pdata->list, list) {
+		list_remove(&p->list);
+		pathstr = p->str;
+		kfree(p);
+		return pathstr;
+	}
+	return "";
+}
+
+/* Check there's at least one element, unlink and return the last element */
+const char *pathdata_last_component(struct pathdata *pdata)
+{
+	struct pathcomp *p;
+	const char *pathstr;
+
+	if (!list_empty(&pdata->list)) {
+		p = link_to_struct(pdata->list.prev, struct pathcomp, list);
+		list_remove(&p->list);
+		pathstr = p->str;
+		kfree(p);
+		return pathstr;
+	}
+
+	return "";
+}
+
+/* Unlink and free all path components in pathdata, and then free pathdata */
+void pathdata_destroy(struct pathdata *p)
+{
+	struct pathcomp *c, *n;
+
+	list_foreach_removable_struct(c, n, &p->list, list) {
+		list_remove(&c->list);
+		kfree(c);
+	}
+	kfree(p);
+}
+
+void pathdata_print(struct pathdata *p)
+{
+	struct pathcomp *comp;
+
+	printf("Extracted path is:\n");
+	list_foreach_struct(comp, &p->list, list)
+		printf("%s\n", comp->str);
+}
+
+/* Extracts all path components from pathname into more presentable form */
+struct pathdata *pathdata_parse(const char *pathname,
+				char *pathbuf, struct tcb *task)
+{
+	struct pathdata *pdata = kzalloc(sizeof(*pdata));
+	struct pathcomp *comp;
+	char *str;
+
+	if (!pdata)
+		return PTR_ERR(-ENOMEM);
+
+	/* Initialise pathdata */
+	link_init(&pdata->list);
+	strcpy(pathbuf, pathname);
+
+	/* First component is root if there's a root */
+	if (pathname[0] == VFS_CHAR_SEP) {
+		if (!(comp = kzalloc(sizeof(*comp)))) {
+			kfree(pdata);
+			return PTR_ERR(-ENOMEM);
+		}
+		link_init(&comp->list);
+		comp->str = VFS_STR_ROOTDIR;
+		list_insert_tail(&comp->list, &pdata->list);
+
+		if (task)
+			/* Lookup start vnode is root vnode */
+			pdata->vstart = task->fs_data->rootdir;
+		else /* If no task, we use the root mountpoint pivot vnode */
+			pdata->vstart = vfs_root.pivot;
+
+	/* Otherwise start from current directory */
+	} else {
+		struct dentry *curdir;
+
+		if (!(comp = kzalloc(sizeof(*comp)))) {
+			kfree(pdata);
+			return PTR_ERR(-ENOMEM);
+		}
+		link_init(&comp->list);
+
+		/* Get current dentry for this task */
+		curdir = link_to_struct(task->fs_data->curdir->dentries.next,
+				    struct dentry, vref);
+
+		/* Use its name in path component */
+		comp->str = curdir->name;
+		list_insert_tail(&comp->list, &pdata->list);
+
+		/* Lookup start vnode is current dir vnode */
+		pdata->vstart = task->fs_data->curdir;
+	}
+
+	/* Add every other path component */
+	str = splitpath(&pathbuf, VFS_CHAR_SEP);
+	while(*str) {
+		/* Any curdir components in path are ignored. */
+		if (!strcmp(str, VFS_STR_CURDIR)) {
+			;
+		} else {
+			if (!(comp = kzalloc(sizeof(*comp)))) {
+				pathdata_destroy(pdata);
+				return PTR_ERR(-ENOMEM);
+			}
+			link_init(&comp->list);
+			comp->str = str;
+			list_insert_tail(&comp->list, &pdata->list);
+		}
+
+		/* Next component */
+		str = splitpath(&pathbuf, VFS_CHAR_SEP);
+	}
+	// pathdata_print(pdata);
+
+	return pdata;
+}
+

conts/posix/mm0/fs/romfs/romfs.c

@@ -0,0 +1,86 @@
+#include <stdio.h>
+#include <block.h>
+#include <l4/lib/math.h>
+#include <l4/macros.h>
+#include <l4/types.h>
+#include INC_GLUE(memory.h)
+
+/*
+ * Romfs superblock descriptor:
+ *
+ * All words are Big-Endian.
+ *
+ * Word 0: | - | r | o | m |
+ * Word 1: | 1 | f | s | - |
+ * Word 2: |      Size     | The number of bytes in this fs.
+ * Word 3: |    Checksum   | The checksum of first 512 bytes.
+ * Word 4: |  Volume Name  | The name of volume, padded to 16-byte boundary.
+ * Rest:   |  File Headers | The rest of the data.
+ */
+struct romfs_superblock {
+	u32 word0;
+	u32 word1;
+	u32 size;
+	u32 checksum;
+	char name[0];
+};
+
+struct romfs_inode {
+	unsigned long mdata_size;	/* Size of metadata */
+	unsigned long data_offset;	/* Offset of data from start of fs */
+};
+
+static u32
+romfs_checksum(void *data)
+{
+	u32 sum = 0;
+	u32 *ptr = data;
+
+	size >>= 2;
+	while (size > 0) {
+		sum += be32_to_cpu(*ptr++);
+		size--;
+	}
+	return sum;
+}
+
+int romfs_fill_super(struct superblock *sb)
+{
+	char buf[PAGE_SIZE];
+	struct romfs_superblock *romfs_sb = (struct romfs_superblock *)buf;
+	unsigned long vroot_offset;
+	struct vnode *vroot;
+
+	/* Read first page from block device */
+	bdev_readpage(0, buf);
+
+	/* Check superblock sanity */
+	if (strcmp(be32_to_cpu(romfs_sb->word0), ROMFS_SB_WORD0)) {
+		printf("Bad magic word 0\n");
+	}
+	if (strcmp(be32_to_cpu(romfs_sb->word1), ROMFS_SB_WORD1)) {
+		printf("Bad magic word 1\n");
+	}
+	if (romfs_checksum(romfs_sb, min(romfs_sb->size, PAGE_SIZE))) {
+		printf("Bad checksum.\n");
+	}
+
+	/* Copy some params to generic superblock */
+	sb->size = be32_to_cpu(romfs_sb->size);
+	sb->magic = ROMFS_MAGIC;
+	sb->ops = romfs_ops;
+
+	/* Offset of first vnode, which is the root vnode */
+	vroot_offset = align_up(strnlen(romfs_sb->name, ROMFS_MAXNAME) + 1, 16);
+	if (!(vroot = romfs_read_vnode(s, vroot_offset))) {
+		printf("Error, could not get root inode.\n");
+	}
+
+	/* Get the dirent for this vnode */
+	if (!(sb->root = new_dentry(vroot))) {
+		printf("Error: Could not get new dentry for root vnode.\n");
+	}
+
+}
+
+

conts/posix/mm0/fs/romfs/romfs.h

@@ -0,0 +1,43 @@
+#ifndef __ROMFS_H__
+#define __ROMFS_H__
+
+#define ROMFS_MAGIC	0x7275
+
+#define ROMFS_FTYPE_MSK		0xF	/* File mask */
+#define ROMFS_FTYPE_HRD		0	/* Hard link */
+#define ROMFS_FTYPE_DIR		1	/* Directory */
+#define ROMFS_FTYPE_REG 	2	/* Regular file */
+#define ROMFS_FTYPE_SYM 	3	/* Symbolic link */
+#define ROMFS_FTYPE_BLK 	4	/* Block device */
+#define ROMFS_FTYPE_CHR 	5	/* Char device */
+#define ROMFS_FTYPE_SCK 	6	/* Socket */
+#define ROMFS_FTYPE_FIF 	7	/* FIFO */
+#define ROMFS_FTYPE_EXE 	8	/* Executable */
+
+#define ROMFS_NAME_ALIGN	16	/* Alignment size of names */
+
+#define ROMFS_SB_WORD0	"-rom"
+#define ROMFS_SB_WORD1	"1fs-"
+
+/*
+ * Romfs superblock descriptor:
+ *
+ * All words are Big-Endian.
+ *
+ * Word 0: | - | r | o | m |
+ * Word 1: | 1 | f | s | - |
+ * Word 2: |      Size     | The number of bytes in this fs.
+ * Word 3: |    Checksum   | The checksum of first 512 bytes.
+ * Word 4: |  Volume Name  | The name of volume, padded to 16-byte boundary.
+ * Rest:   |  File Headers | The rest of the data.
+ */
+struct romfs_superblock {
+	u32 word0;
+	u32 word1;
+	u32 size;
+	u32 checksum;
+	char name[0];
+};
+
+
+#endif /* __ROMFS_H__ */

conts/posix/mm0/fs/romfs/romfs_fs.h

@@ -0,0 +1,61 @@
+#ifndef __LINUX_ROMFS_FS_H
+#define __LINUX_ROMFS_FS_H
+
+/* The basic structures of the romfs filesystem */
+
+#define ROMBSIZE BLOCK_SIZE
+#define ROMBSBITS BLOCK_SIZE_BITS
+#define ROMBMASK (ROMBSIZE-1)
+#define ROMFS_MAGIC 0x7275
+
+#define ROMFS_MAXFN 128
+
+#define __mkw(h,l) (((h)&0x00ff)<< 8|((l)&0x00ff))
+#define __mkl(h,l) (((h)&0xffff)<<16|((l)&0xffff))
+#define __mk4(a,b,c,d) cpu_to_be32(__mkl(__mkw(a,b),__mkw(c,d)))
+#define ROMSB_WORD0 __mk4('-','r','o','m')
+#define ROMSB_WORD1 __mk4('1','f','s','-')
+
+/* On-disk "super block" */
+
+struct romfs_super_block {
+	__be32 word0;
+	__be32 word1;
+	__be32 size;
+	__be32 checksum;
+	char name[0];		/* volume name */
+};
+
+/* On disk inode */
+
+struct romfs_inode {
+	__be32 next;		/* low 4 bits see ROMFH_ */
+	__be32 spec;
+	__be32 size;
+	__be32 checksum;
+	char name[0];
+};
+
+#define ROMFH_TYPE 7
+#define ROMFH_HRD 0
+#define ROMFH_DIR 1
+#define ROMFH_REG 2
+#define ROMFH_SYM 3
+#define ROMFH_BLK 4
+#define ROMFH_CHR 5
+#define ROMFH_SCK 6
+#define ROMFH_FIF 7
+#define ROMFH_EXEC 8
+
+/* Alignment */
+
+#define ROMFH_SIZE 16
+#define ROMFH_PAD (ROMFH_SIZE-1)
+#define ROMFH_MASK (~ROMFH_PAD)
+
+#ifdef __KERNEL__
+
+/* Not much now */
+
+#endif /* __KERNEL__ */
+#endif

conts/posix/mm0/fs/vfs.c

@@ -0,0 +1,76 @@
+/*
+ * High-level vfs implementation.
+ *
+ * Copyright (C) 2008 Bahadir Balban
+ */
+#include <fs.h>
+#include <vfs.h>
+#include <task.h>
+#include <path.h>
+
+LINK_DECLARE(vnode_cache);
+LINK_DECLARE(dentry_cache);
+
+struct vfs_mountpoint vfs_root;
+
+/*
+ * Vnodes in the vnode cache have 2 keys. One is their dentry names, the other
+ * is their vnum. This one checks the vnode cache by the given vnum first.
+ * If nothing is found, it reads the vnode from disk into cache. This is called
+ * by system calls since tasks keep an fd-to-vnum table.
+ */
+struct vnode *vfs_lookup_byvnum(struct superblock *sb, unsigned long vnum)
+{
+	struct vnode *v;
+	int err;
+
+	/* Check the vnode flat list by vnum */
+	list_foreach_struct(v, &vnode_cache, cache_list)
+		if (v->vnum == vnum)
+			return v;
+
+	/* Check the actual filesystem for the vnode */
+	v = vfs_alloc_vnode();
+	v->vnum = vnum;
+
+	/* Note this only checks given superblock */
+	if ((err = sb->ops->read_vnode(sb, v)) < 0) {
+		vfs_free_vnode(v);
+		return PTR_ERR(err);
+	}
+
+	/* Add the vnode back to vnode flat list */
+	list_insert(&v->cache_list, &vnode_cache);
+
+	return v;
+}
+
+/*
+ * Vnodes in the vnode cache have 2 keys. One is the set of dentry names they
+ * have, the other is their vnum. This one checks the vnode cache by the path
+ * first. If nothing is found, it reads the vnode from disk into the cache.
+ */
+struct vnode *vfs_lookup_bypath(struct pathdata *pdata)
+{
+	const char *firstcomp;
+
+	/*
+	 * This does vfs cache + fs lookup.
+	 */
+	BUG_ON(list_empty(&pdata->list));
+	firstcomp = pathdata_next_component(pdata);
+	return pdata->vstart->ops.lookup(pdata->vstart, pdata, firstcomp);
+}
+
+int vfs_mount_root(struct superblock *sb)
+{
+	/*
+	 * Lookup the root vnode of this superblock.
+	 * The root superblock has vnode number 0.
+	 */
+	vfs_root.pivot = vfs_lookup_byvnum(sb, 0);
+	vfs_root.sb = sb;
+
+	return 0;
+}
+