vfs: Remove KFS, blockdev and devfs
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 7 Mar 2018 21:57:24 +0000 (13:57 -0800)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 30 Apr 2018 18:31:44 +0000 (14:31 -0400)
Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
81 files changed:
kern/arch/x86/apic9.c
kern/arch/x86/ioapic.c
kern/arch/x86/mp.c
kern/arch/x86/mpacpi.c
kern/arch/x86/msi.c
kern/drivers/dev/acpi.c
kern/drivers/dev/capability.c
kern/drivers/dev/coreboot.c
kern/drivers/dev/ether.c
kern/drivers/dev/mnt.c
kern/drivers/dev/pci.c
kern/drivers/dev/pipe.c
kern/drivers/dev/proc.c
kern/drivers/dev/random.c
kern/drivers/dev/regress.c
kern/drivers/dev/sd.c
kern/drivers/dev/sdiahci.c
kern/drivers/dev/sdscsi.c
kern/drivers/dev/srv.c
kern/drivers/net/bnx2x/bnx2x_dev.c
kern/drivers/net/ether8139.c
kern/drivers/net/ether82563.c
kern/drivers/net/etherigbe.c
kern/drivers/net/ethermii.c
kern/drivers/net/mlx4/main.c
kern/drivers/net/udrvr/compat.c
kern/drivers/net/udrvr/compat.h
kern/include/blockdev.h [deleted file]
kern/include/devfs.h [deleted file]
kern/include/kfs.h [deleted file]
kern/include/vfs.h
kern/src/Kbuild
kern/src/blockdev.c [deleted file]
kern/src/devfs.c [deleted file]
kern/src/err.c
kern/src/init.c
kern/src/kfs.c [deleted file]
kern/src/ktest/pb_ktests.c
kern/src/manager.c
kern/src/net/arp.c
kern/src/net/devip.c
kern/src/net/dial.c
kern/src/net/eipconv.c
kern/src/net/ethermedium.c
kern/src/net/icmp.c
kern/src/net/ip.c
kern/src/net/ipaux.c
kern/src/net/ipifc.c
kern/src/net/ipprotoinit.c
kern/src/net/iproute.c
kern/src/net/iprouter.c
kern/src/net/loopbackmedium.c
kern/src/net/netaux.c
kern/src/net/netif.c
kern/src/net/netlog.c
kern/src/net/nullmedium.c
kern/src/net/pktmedium.c
kern/src/net/plan9.c
kern/src/net/ptclbsum.c
kern/src/net/tcp.c
kern/src/net/udp.c
kern/src/ns/allocb.c
kern/src/ns/cache.c
kern/src/ns/chan.c
kern/src/ns/cleanname.c
kern/src/ns/convD2M.c
kern/src/ns/convM2D.c
kern/src/ns/convM2S.c
kern/src/ns/convM2kdirent.c
kern/src/ns/convS2M.c
kern/src/ns/dev.c
kern/src/ns/getfields.c
kern/src/ns/parse.c
kern/src/ns/pgrp.c
kern/src/ns/qio.c
kern/src/ns/sysfile.c
kern/src/ns/tokenize.c
kern/src/syscall.c
kern/src/vfs.c
scripts/etherboot/fixincludes
scripts/fixincludes

index ae71c02..0a0b39c 100644 (file)
@@ -1,5 +1,4 @@
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index e59c6c8..50ba6b1 100644 (file)
@@ -8,7 +8,6 @@
  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index eddb9c8..82b219c 100644 (file)
@@ -6,7 +6,6 @@
  * in the LICENSE file. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index e56c3aa..cd09ccb 100644 (file)
@@ -6,7 +6,6 @@
  * in the LICENSE file. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index bbb59ea..81fc237 100644 (file)
@@ -8,7 +8,6 @@
  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index e836162..7e8e8e8 100644 (file)
@@ -8,7 +8,6 @@
  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 5e396b6..aab5346 100644 (file)
@@ -8,7 +8,6 @@
  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index cb45353..b5fa923 100644 (file)
@@ -29,7 +29,6 @@
  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index f0a7c14..26d2441 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 650d017..22767e0 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index c9a82b9..0d9b778 100644 (file)
@@ -8,7 +8,6 @@
  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index d53a2c0..403ef7b 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index bcbda22..dc2c669 100644 (file)
@@ -18,7 +18,6 @@
  * #if 0 until we know we don't want it
  */
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index d666ed7..497bca9 100644 (file)
@@ -8,7 +8,6 @@
  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 9dfc63a..671748e 100644 (file)
@@ -13,7 +13,6 @@
 // TODO: read them back :-)
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 776348b..ab6ece5 100644 (file)
@@ -17,7 +17,6 @@
 #include <cpio.h>
 #include <error.h>
 #include <net/ip.h>
-#include <kfs.h>
 #include <kmalloc.h>
 #include <kref.h>
 #include <pmap.h>
index baf5865..2ec5771 100644 (file)
@@ -18,7 +18,6 @@
 #include <cpio.h>
 #include <error.h>
 #include <net/ip.h>
-#include <kfs.h>
 #include <kmalloc.h>
 #include <kref.h>
 #include <pmap.h>
index 4508fb2..7344dc4 100644 (file)
@@ -13,7 +13,6 @@
 #include <cpio.h>
 #include <error.h>
 #include <net/ip.h>
-#include <kfs.h>
 #include <kmalloc.h>
 #include <kref.h>
 #include <pmap.h>
index 1338588..a501600 100644 (file)
@@ -22,7 +22,6 @@
  * giving it's refs to some other file in the walk. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index e377e87..803cfb8 100644 (file)
@@ -8,7 +8,6 @@
 /* Network driver stub for bnx2x_ */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index b492949..e7095c9 100644 (file)
@@ -32,7 +32,6 @@
  * may need work.
  */
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index ba44a1c..d4bf9a0 100644 (file)
@@ -35,7 +35,6 @@
  * much slower (as is true of the 82579), never allow jumbos.
  */
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index f92468f..4502089 100644 (file)
@@ -30,7 +30,6 @@
  *     made sure igbepci only runs once, even if it fails */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 30da877..af3d642 100644 (file)
@@ -6,7 +6,6 @@
  * in the LICENSE file. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 494ff68..11242eb 100644 (file)
@@ -3844,7 +3844,6 @@ module_exit(mlx4_cleanup);
 /* Network driver stub for mlx4 */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 08d786e..4647558 100644 (file)
@@ -13,7 +13,6 @@
 #include <error.h>
 #include <pmap.h>
 #include <smp.h>
-#include <devfs.h>
 #include <linux/rdma/ib_user_verbs.h>
 #include "uverbs.h"
 #include <ros/procinfo.h>
@@ -223,11 +222,13 @@ static ssize_t ib_api_ver_read(struct file *filp, char __user *buf,
        return sysfs_read(buf, count, pos, src);
 }
 
+#if 0 // AKAROS_PORT (9ns hooks)
 static const struct file_operations ib_api_ver = {
        .read   = ib_api_ver_read,
        .open   = kfs_open,
        .release= kfs_release,
 };
+#endif
 
 static ssize_t mlx4_mgm_read(struct file *filp, char __user *buf,
     size_t count, loff_t *pos)
@@ -241,11 +242,13 @@ static ssize_t mlx4_mgm_read(struct file *filp, char __user *buf,
        return sysfs_read(buf, count, pos, src);
 }
 
+#if 0 // AKAROS_PORT
 static const struct file_operations mlx4_mgm = {
        .read   = mlx4_mgm_read,
        .open   = kfs_open,
        .release= kfs_release,
 };
+#endif
 
 #if 0
 static void stradd(char *dest, int val, int num)
@@ -300,6 +303,9 @@ static const struct file_operations cpuinfo = {
 
 void sysfs_init(void)
 {
+#if 1 // AKAROS_PORT
+       warn("mlx4: udrvr stuff requires various files, implement for 9ns!");
+#else
        do_mkdir("/dev_vfs/infiniband", S_IRWXU | S_IRWXG | S_IRWXO);
        do_mkdir("/sys", S_IRWXU | S_IRWXG | S_IRWXO);
        do_mkdir("/sys/class", S_IRWXU | S_IRWXG | S_IRWXO);
@@ -324,6 +330,7 @@ void sysfs_init(void)
        make_device("/proc/cpuinfo", S_IWUSR | S_IWGRP | S_IWOTH | S_IRUSR |
            S_IRGRP | S_IROTH, __S_IFCHR, (struct file_operations *)&cpuinfo);
 #endif
+#endif
 }
 
 static ssize_t dver_read(struct file *filp, char __user *buf,
@@ -379,6 +386,7 @@ static ssize_t vsd_read(struct file *filp, char __user *buf,
        return sysfs_read(buf, count, pos, src);
 }
 
+#if 0 // AKAROS_PORT
 static const struct file_operations dver_fops = {
        .read   = dver_read,
        .open   = kfs_open,
@@ -414,10 +422,14 @@ static const struct file_operations vsd_fops = {
        .open   = kfs_open,
        .release= kfs_release,
 };
+#endif
 
 void sysfs_create(int devnum, const struct file_operations *verb_fops,
     void *ptr)
 {
+#if 1 // AKAROS_PORT
+       warn("mlx4: udrvr stuff requires various files, implement for 9ns!");
+#else
        char            sysname[256] = "/sys/class/infiniband_verbs/uverbs0";
        char            devname[] = "/dev_vfs/infiniband/uverbs0";
        char            drvname[64] = "/sys/class/infiniband/";
@@ -489,6 +501,7 @@ void sysfs_create(int devnum, const struct file_operations *verb_fops,
            S_IWUSR | S_IWGRP | S_IWOTH | S_IRUSR | S_IRGRP | S_IROTH,
            __S_IFCHR, (struct file_operations *)&dver_fops);
        set_fs_info(fp, ptr);
+#endif
 }
 
 /* END: Linux /sys support for lib/apps */
index 873879e..50a9911 100644 (file)
@@ -212,6 +212,7 @@ struct ib_ud_header {
 };
 
 extern void sysfs_init(void);
+struct file_operations;
 extern void sysfs_create(int devnum, const struct file_operations *verb_fops,
                          void *ptr);
 
diff --git a/kern/include/blockdev.h b/kern/include/blockdev.h
deleted file mode 100644 (file)
index 19ca8d9..0000000
+++ /dev/null
@@ -1,98 +0,0 @@
-/* Copyright (c) 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Block device interfaces and structures */
-
-#pragma once
-
-#include <ros/common.h>
-#include <kref.h>
-#include <slab.h>
-#include <pagemap.h>
-#include <kthread.h>
-
-/* All block IO is done assuming a certain size sector, which is the smallest
- * possible unit of transfer between the kernel and the block layer.  This can
- * be bigger than what the underlying hardware can handle, but it shouldn't be
- * smaller than any higher-level block (like an FS block, which are often 1 KB).
- */
-#define SECTOR_SZ_LOG 9
-#define SECTOR_SZ (1 << SECTOR_SZ_LOG)
-
-/* Every block device is represented by one of these, with custom methods, as
- * applicable for the type of device.  Subject to massive changes. */
-#define BDEV_INLINE_NAME 10
-struct block_device {
-       int                                                     b_id;
-       unsigned int                            b_sector_sz;            /* HW sector size */
-       unsigned long                           b_nr_sector;            /* Total sectors on dev */
-       struct kref                                     b_kref;
-       struct page_map                         b_pm;
-       void                                            *b_data;                        /* dev-specific use */
-       char                                            b_name[BDEV_INLINE_NAME];
-       // TODO: list or something of buffer heads (?)
-       // list of outstanding requests
-       // io scheduler
-       // callbacks for completion
-};
-
-/* So far, only NEEDS_ZEROED is used */
-#define BH_LOCKED              0x001   /* involved in an IO op */
-#define BH_UPTODATE            0x002   /* buffer is filled with file data */
-#define BH_DIRTY               0x004   /* buffer is dirty */
-#define BH_NEEDS_ZEROED        0x008   /* buffer should be 0'd, not read in */
-
-/* This maps to and from a buffer within a page to a block(s) on a bdev.  Some
- * of it might not be needed later, etc (page, numblock). */
-struct buffer_head {
-       struct page                                     *bh_page;                       /* redundant with buffer */
-       void                                            *bh_buffer;
-       unsigned int                            bh_flags;
-       struct buffer_head                      *bh_next;                       /* circular LL of BHs */
-       struct block_device                     *bh_bdev;
-       unsigned long                           bh_sector;
-       unsigned int                            bh_nr_sector;           /* length (in sectors) */
-};
-struct kmem_cache *bh_kcache;
-
-/* Buffer Head Requests.  For now, just use these for dealing with non-file IO
- * on a block device.  Tell it what size you think blocks are. */
-struct buffer_head *bdev_get_buffer(struct block_device *bdev,
-                                    unsigned long blk_num, unsigned int blk_sz);
-void bdev_dirty_buffer(struct buffer_head *bh);
-void bdev_put_buffer(struct buffer_head *bh);
-
-/* This encapsulates the work of a request (instead of having a variety of
- * slightly-different functions for things like read/write and scatter-gather
- * ops).  Reads and writes are essentially the same, so all we need is a flag to
- * differentiate.  This struct also serves as a tool to track the progress of a
- * block request throughout its servicing.  This is analagous to Linux's struct
- * bio.
- *
- * bhs normally points to the inline version (enough for a page).  kmalloc
- * another array of BH pointers if you want more.  The BHs do not need to be
- * linked or otherwise associated with a page mapping. */
-#define NR_INLINE_BH (PGSIZE >> SECTOR_SZ_LOG)
-struct block_request;
-struct block_request {
-       unsigned int                            flags;
-       void                                            (*callback)(struct block_request *breq);
-       void                                            *data;
-       struct semaphore                        sem;
-       struct buffer_head                      **bhs;                          /* BHs describing the IOs */
-       unsigned int                            nr_bhs;
-       struct buffer_head                      *local_bhs[NR_INLINE_BH];
-};
-struct kmem_cache *breq_kcache;        /* for the block requests */
-
-/* Block request flags */
-#define BREQ_READ                      0x001
-#define BREQ_WRITE                     0x002
-
-void block_init(void);
-struct block_device *get_bdev(char *path);
-void free_bhs(struct page *page);
-int bdev_submit_request(struct block_device *bdev, struct block_request *breq);
-void generic_breq_done(struct block_request *breq);
-void sleep_on_breq(struct block_request *breq);
diff --git a/kern/include/devfs.h b/kern/include/devfs.h
deleted file mode 100644 (file)
index db13645..0000000
+++ /dev/null
@@ -1,24 +0,0 @@
-/* Copyright (c) 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Devfs: filesystem interfaces to devices.  For now, we just create the
- * needed/discovered devices in KFS in its /dev/ folder.  In the future, we
- * might want to do something like nodes like other Unixes. */
-
-#pragma once
-
-#include <vfs.h>
-#include <kfs.h>
-
-void devfs_init(void);
-struct file *make_device(char *path, int mode, int type,
-                         struct file_operations *fop);
-
-/* Generic device (block or char) file ops.  Both of these are dummies that say
- * the device can't support the operation. */
-int dev_mmap(struct file *file, struct vm_region *vmr);
-int dev_c_llseek(struct file *file, off64_t offset, off64_t *ret, int whence);
-
-/* Exporting these for convenience (process creation) */
-extern struct file *dev_stdin, *dev_stdout, *dev_stderr;
diff --git a/kern/include/kfs.h b/kern/include/kfs.h
deleted file mode 100644 (file)
index c3d7ef2..0000000
+++ /dev/null
@@ -1,84 +0,0 @@
-/* Copyright (c) 2009, 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * KFS (Kernel File System)
- *
- * This is a cheap FS that is based off of a CPIO archive appended to the end of
- * the kernel binary image. */
-
-#pragma once
-
-#include <ros/common.h>
-#include <vfs.h>
-
-/* Every FS must extern it's type, and be included in vfs_init() */
-extern struct fs_type kfs_fs_type;
-
-/* KFS-specific inode info.  Could use a union, but I want to init filestart to
- * 0 to catch bugs. */
-struct kfs_i_info {
-       struct dentry_tailq             children;               /* our childrens */
-       void                                    *filestart;             /* or our file location */
-       size_t                                  init_size;              /* file size on the backing store */
-};
-
-/* KFS VFS functions.  Exported for use by similar FSs (devices, for now) */
-struct super_block *kfs_get_sb(struct fs_type *fs, int flags,
-                               char *dev_name, struct vfsmount *vmnt);
-void kfs_kill_sb(struct super_block *sb);
-/* Page Map Operations */
-int kfs_readpage(struct page_map *pm, struct page *page);
-/* Super Operations */
-struct inode *kfs_alloc_inode(struct super_block *sb);
-void kfs_dealloc_inode(struct inode *inode);
-void kfs_read_inode(struct inode *inode);
-void kfs_dirty_inode(struct inode *inode);
-void kfs_write_inode(struct inode *inode, bool wait);
-void kfs_put_inode(struct inode *inode);
-void kfs_drop_inode(struct inode *inode);
-void kfs_delete_inode(struct inode *inode);
-void kfs_put_super(struct super_block *sb);
-void kfs_write_super(struct super_block *sb);
-int kfs_sync_fs(struct super_block *sb, bool wait);
-int kfs_remount_fs(struct super_block *sb, int flags, char *data);
-void kfs_umount_begin(struct super_block *sb);
-/* inode_operations */
-int kfs_create(struct inode *dir, struct dentry *dentry, int mode,
-               struct nameidata *nd);
-struct dentry *kfs_lookup(struct inode *dir, struct dentry *dentry,
-                          struct nameidata *nd);
-int kfs_link(struct dentry *old_dentry, struct inode *dir,
-             struct dentry *new_dentry);
-int kfs_unlink(struct inode *dir, struct dentry *dentry);
-int kfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname);
-int kfs_mkdir(struct inode *dir, struct dentry *dentry, int mode);
-int kfs_rmdir(struct inode *dir, struct dentry *dentry);
-int kfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev);
-int kfs_rename(struct inode *old_dir, struct dentry *old_dentry,
-               struct inode *new_dir, struct dentry *new_dentry);
-char *kfs_readlink(struct dentry *dentry);
-void kfs_truncate(struct inode *inode);
-int kfs_permission(struct inode *inode, int mode, struct nameidata *nd);
-/* dentry_operations */
-int kfs_d_revalidate(struct dentry *dir, struct nameidata *nd);
-int kfs_d_compare(struct dentry *dir, struct qstr *name1, struct qstr *name2);
-int kfs_d_delete(struct dentry *dentry);
-int kfs_d_release(struct dentry *dentry);
-void kfs_d_iput(struct dentry *dentry, struct inode *inode);
-/* file_operations */
-int kfs_llseek(struct file *file, off64_t offset, off64_t *ret, int whence);
-int kfs_readdir(struct file *dir, struct kdirent *dirent);
-int kfs_mmap(struct file *file, struct vm_region *vmr);
-int kfs_open(struct inode *inode, struct file *file);
-int kfs_flush(struct file *file);
-int kfs_release(struct inode *inode, struct file *file);
-int kfs_fsync(struct file *file, struct dentry *dentry, int datasync);
-unsigned int kfs_poll(struct file *file, struct poll_table_struct *poll_table);
-ssize_t kfs_readv(struct file *file, const struct iovec *vector,
-                  unsigned long count, off64_t *offset);
-ssize_t kfs_writev(struct file *file, const struct iovec *vector,
-                  unsigned long count, off64_t *offset);
-ssize_t kfs_sendpage(struct file *file, struct page *page, int offset,
-                     size_t size, off64_t pos, int more);
-int kfs_check_flags(int flags);
index 3a457d4..baebe51 100644 (file)
@@ -22,7 +22,6 @@
 #include <radix.h>
 #include <hashtable.h>
 #include <pagemap.h>
-#include <blockdev.h>
 #include <fdtap.h>
 
 /* ghetto preprocessor hacks (since proc includes vfs) */
index 46315f8..9202163 100644 (file)
@@ -28,13 +28,11 @@ obj-y                                               += arena.o
 obj-y                                          += arsc.o
 obj-y                                          += atomic.o
 obj-y                                          += bitmap.o
-obj-y                                          += blockdev.o
 obj-y                                          += build_info.o
 obj-y                                          += ceq.o
 obj-y                                          += completion.o
 obj-y                                          += coreprov.o
 obj-y                                          += ctype.o
-obj-y                                          += devfs.o
 obj-y                                          += dmapool.o
 obj-y                                          += elf.o
 obj-y                                          += env.o
@@ -51,7 +49,6 @@ obj-y                                         += hexdump.o
 obj-y                                          += init.o
 obj-y                                          += kconfig_info.o
 obj-y                                          += kdebug.o
-obj-y                                          += kfs.o
 obj-y                                          += kmalloc.o
 obj-y                                          += kreallocarray.o
 obj-y                                          += ktest/
diff --git a/kern/src/blockdev.c b/kern/src/blockdev.c
deleted file mode 100644 (file)
index a16f83b..0000000
+++ /dev/null
@@ -1,283 +0,0 @@
-/* Copyright (c) 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Block devices and generic blockdev infrastructure */
-
-#include <devfs.h>
-#include <blockdev.h>
-#include <kmalloc.h>
-#include <slab.h>
-#include <page_alloc.h>
-#include <pmap.h>
-/* These two are needed for the fake interrupt */
-#include <alarm.h>
-#include <smp.h>
-
-struct file_operations block_f_op;
-struct page_map_operations block_pm_op;
-struct kmem_cache *breq_kcache;
-
-void block_init(void)
-{
-       breq_kcache = kmem_cache_create("block_reqs",
-                                       sizeof(struct block_request),
-                                       __alignof__(struct block_request), 0,
-                                       NULL, 0, 0, NULL);
-       bh_kcache = kmem_cache_create("buffer_heads",
-                                     sizeof(struct buffer_head),
-                                     __alignof__(struct buffer_head), 0,
-                                     NULL, 0, 0, NULL);
-}
-
-/* Generic helper, returns a kref'd reference out of principle. */
-struct block_device *get_bdev(char *path)
-{
-       struct block_device *bdev;
-       struct file *block_f;
-       block_f = do_file_open(path, O_RDWR, 0);
-       assert(block_f);
-       bdev = block_f->f_dentry->d_inode->i_bdev;
-       kref_get(&bdev->b_kref, 1);
-       kref_put(&block_f->f_kref);
-       return bdev;
-}
-
-/* Frees all the BHs associated with page.  There could be 0, to deal with one
- * that wasn't UPTODATE.  Don't call this on a page that isn't a PG_BUFFER.
- * Note, these are not a circular LL (for now). */
-void free_bhs(struct page *page)
-{
-       struct buffer_head *bh, *next;
-       assert(atomic_read(&page->pg_flags) & PG_BUFFER);
-       bh = (struct buffer_head*)page->pg_private;
-       while (bh) {
-               next = bh->bh_next;
-               bh->bh_next = 0;
-               kmem_cache_free(bh_kcache, bh);
-               bh = next;
-       }
-       page->pg_private = 0;           /* catch bugs */
-}
-
-/* This ultimately will handle the actual request processing, all the way down
- * to the driver, and will deal with blocking.  For now, we just fulfill the
- * request right away (RAM based block devs). */
-int bdev_submit_request(struct block_device *bdev, struct block_request *breq)
-{
-       void *src, *dst;
-       unsigned long first_sector;
-       unsigned int nr_sector;
-
-       for (int i = 0; i < breq->nr_bhs; i++) {
-               first_sector = breq->bhs[i]->bh_sector;
-               nr_sector = breq->bhs[i]->bh_nr_sector;
-               /* Sectors are indexed starting with 0, for now. */
-               if (first_sector + nr_sector > bdev->b_nr_sector) {
-                       warn("Exceeding the num sectors!");
-                       return -1;
-               }
-               if (breq->flags & BREQ_READ) {
-                       dst = breq->bhs[i]->bh_buffer;
-                       src = bdev->b_data + (first_sector << SECTOR_SZ_LOG);
-               } else if (breq->flags & BREQ_WRITE) {
-                       dst = bdev->b_data + (first_sector << SECTOR_SZ_LOG);
-                       src = breq->bhs[i]->bh_buffer;
-               } else {
-                       panic("Need a request type!\n");
-               }
-               memcpy(dst, src, nr_sector << SECTOR_SZ_LOG);
-       }
-       /* Faking the device interrupt with an alarm */
-       void breq_handler(struct alarm_waiter *waiter)
-       {
-               /* In the future, we'll need to figure out which breq this was in
-                * response to */
-               struct block_request *breq = (struct block_request*)waiter->data;
-               if (breq->callback)
-                       breq->callback(breq);
-               kfree(waiter);
-       }
-       struct timer_chain *tchain = &per_cpu_info[core_id()].tchain;
-       struct alarm_waiter *waiter = kmalloc(sizeof(struct alarm_waiter), 0);
-       init_awaiter(waiter, breq_handler);
-       /* Stitch things up, so we know how to find things later */
-       waiter->data = breq;
-       /* Set for 5ms. */
-       set_awaiter_rel(waiter, 5000);
-       set_alarm(tchain, waiter);
-       return 0;
-}
-
-/* Helper method, unblocks someone blocked on sleep_on_breq(). */
-void generic_breq_done(struct block_request *breq)
-{
-       int8_t irq_state = 0;
-       if (!sem_up_irqsave(&breq->sem, &irq_state)) {
-               /* This shouldn't happen anymore.  Let brho know if it does. */
-               warn("[kernel] no one waiting on breq %p", breq);
-       }
-}
-
-/* Helper, pairs with generic_breq_done().  Note we sleep here on a semaphore
- * instead of faking it with an alarm.  Ideally, this code will be the same even
- * for real block devices (that don't fake things with timer interrupts). */
-void sleep_on_breq(struct block_request *breq)
-{
-       int8_t irq_state = 0;
-       /* Since printk takes a while, this may make you lose the race */
-       printd("Sleeping on breq %p\n", breq);
-       assert(irq_is_enabled());
-       sem_down_irqsave(&breq->sem, &irq_state);
-}
-
-/* This just tells the page cache that it is 'up to date'.  Due to the nature of
- * the blocks in the page cache, we don't actually read the items in on
- * readpage, we read them in when a specific block is there */
-int block_readpage(struct page_map *pm, struct page *page)
-{
-       atomic_or(&page->pg_flags, PG_UPTODATE);
-       return 0;
-}
-
-/* Returns a BH pointing to the buffer where blk_num from bdev is located (given
- * blocks of size blk_sz).  This uses the page cache for the page allocations
- * and evictions, but only caches blocks that are requested.  Check the docs for
- * more info.  The BH isn't refcounted, but a page refcnt is returned.  Call
- * put_block (nand/xor dirty block).
- *
- * Note we're using the lock_page() to sync (which is what we do with the page
- * cache too.  It's not ideal, but keeps things simpler for now.
- *
- * Also note we're a little inconsistent with the use of sector sizes in certain
- * files.  We'll sort it eventually. */
-struct buffer_head *bdev_get_buffer(struct block_device *bdev,
-                                    unsigned long blk_num, unsigned int blk_sz)
-{
-       struct page *page;
-       struct page_map *pm = &bdev->b_pm;
-       struct buffer_head *bh, *new, *prev, **next_loc;
-       struct block_request *breq;
-       int error;
-       unsigned int blk_per_pg = PGSIZE / blk_sz;
-       unsigned int sct_per_blk = blk_sz / bdev->b_sector_sz;
-       unsigned int blk_offset = (blk_num % blk_per_pg) * blk_sz;
-       void *my_buf;
-       assert(blk_offset < PGSIZE);
-       if (!blk_num)
-               warn("Asking for the 0th block of a bdev...");
-       /* Make sure there's a page in the page cache.  Should always be one. */
-       error = pm_load_page(pm, blk_num / blk_per_pg, &page);
-       if (error)
-               panic("Failed to load page! (%d)", error);
-       my_buf = page2kva(page) + blk_offset;
-       atomic_or(&page->pg_flags, PG_BUFFER);
-retry:
-       bh = (struct buffer_head*)page->pg_private;
-       prev = 0;
-       /* look through all the BHs for ours, stopping if we go too far. */
-       while (bh) {
-               if (bh->bh_buffer == my_buf) {
-                       goto found;
-               } else if (bh->bh_buffer > my_buf) {
-                       break;
-               }
-               prev = bh;
-               bh = bh->bh_next;
-       }
-       /* At this point, bh points to the one beyond our space (or 0), and prev is
-        * either the one before us or 0.  We make a BH, and try to insert */
-       new = kmem_cache_alloc(bh_kcache, 0);
-       assert(new);
-       new->bh_page = page;                                    /* weak ref */
-       new->bh_buffer = my_buf;
-       new->bh_flags = 0;
-       new->bh_next = bh;
-       new->bh_bdev = bdev;                                    /* uncounted ref */
-       new->bh_sector = blk_num * sct_per_blk;
-       new->bh_nr_sector = sct_per_blk;
-       /* Try to insert the new one in place.  If it fails, retry the whole "find
-        * the bh" process.  This should be rare, so no sense optimizing it. */
-       next_loc = prev ? &prev->bh_next : (struct buffer_head**)&page->pg_private;
-       /* Normally, there'd be an ABA problem here, but we never actually remove
-        * bhs from the chain until the whole page gets cleaned up, which can't
-        * happen while we hold a reference to the page. */
-       if (!atomic_cas_ptr((void**)next_loc, bh, new)) {
-               kmem_cache_free(bh_kcache, new);
-               goto retry;
-       }
-       bh = new;
-found:
-       /* At this point, we have the BH for our buf, but it might not be up to
-        * date, and there might be someone else trying to update it. */
-       /* is it already here and up to date?  if so, we're done */
-       if (bh->bh_flags & BH_UPTODATE)
-               return bh;
-       /* if not, try to lock the page (could BLOCK).  Using this for syncing. */
-       lock_page(page);
-       /* double check, are we up to date?  if so, we're done */
-       if (bh->bh_flags & BH_UPTODATE) {
-               unlock_page(page);
-               return bh;
-       }
-       /* if we're here, the page is locked by us, we need to read the block */
-       breq = kmem_cache_alloc(breq_kcache, 0);
-       assert(breq);
-       breq->flags = BREQ_READ;
-       breq->callback = generic_breq_done;
-       breq->data = 0;
-       sem_init_irqsave(&breq->sem, 0);
-       breq->bhs = breq->local_bhs;
-       breq->bhs[0] = bh;
-       breq->nr_bhs = 1;
-       error = bdev_submit_request(bdev, breq);
-       assert(!error);
-       sleep_on_breq(breq);
-       kmem_cache_free(breq_kcache, breq);
-       /* after the data is read, we mark it up to date and unlock the page. */
-       bh->bh_flags |= BH_UPTODATE;
-       unlock_page(page);
-       return bh;
-}
-
-/* Will dirty the block/BH/page for the given block/buffer.  Will have to be
- * careful with the page reclaimer - if someone holds a reference, they can
- * still dirty it. */
-void bdev_dirty_buffer(struct buffer_head *bh)
-{
-       struct page *page = bh->bh_page;
-       /* TODO: race on flag modification */
-       bh->bh_flags |= BH_DIRTY;
-       atomic_or(&page->pg_flags, PG_DIRTY);
-}
-
-/* Decrefs the buffer from bdev_get_buffer().  Call this when you no longer
- * reference your block/buffer.  For now, we do refcnting on the page, since the
- * reclaiming will be in page sized chunks from the page cache. */
-void bdev_put_buffer(struct buffer_head *bh)
-{
-       pm_put_page(bh->bh_page);
-}
-
-/* Block device page map ops: */
-struct page_map_operations block_pm_op = {
-       block_readpage,
-};
-
-/* Block device file ops: for now, we don't let you do much of anything */
-struct file_operations block_f_op = {
-       dev_c_llseek,
-       0,
-       0,
-       kfs_readdir,    /* this will fail gracefully */
-       dev_mmap,
-       kfs_open,
-       kfs_flush,
-       kfs_release,
-       0,      /* fsync - makes no sense */
-       kfs_poll,
-       0,      /* readv */
-       0,      /* writev */
-       kfs_sendpage,
-       kfs_check_flags,
-};
diff --git a/kern/src/devfs.c b/kern/src/devfs.c
deleted file mode 100644 (file)
index 3f5e658..0000000
+++ /dev/null
@@ -1,59 +0,0 @@
-/* Copyright (c) 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Devfs: filesystem interfaces to devices.  For now, we just create the
- * needed/discovered devices in KFS in its /dev/ folder, and only do this for
- * stdin and stdout. */
-
-#include <devfs.h>
-#include <kfs.h>
-#include <error.h>
-#include <syscall.h>
-#include <process.h>
-#include <smp.h>
-#include <umem.h>
-#include <kmalloc.h>
-#include <ns.h>
-
-void devfs_init(void)
-{
-       int mode;
-       /* Make sure there is a dev directory */
-       struct dentry *dentry = lookup_dentry("/dev_vfs/", 0);
-       if (!dentry) {
-               assert(!do_mkdir("/dev_vfs/", S_IRWXU | S_IRWXG | S_IRWXO));
-       } else {
-               kref_put(&dentry->d_kref);
-       }
-}
-
-/* Creates a device node at a given location in the FS-tree */
-/* TODO: consider making this only deal with the inode */
-struct file *make_device(char *path, int mode, int type,
-                         struct file_operations *fop)
-{
-       struct file *f_dev = do_file_open(path, O_CREAT | O_RDWR, mode);
-       assert(f_dev);
-       /* Overwrite the f_op with our own f_ops */
-       f_dev->f_dentry->d_inode->i_fop = fop;
-       f_dev->f_op = fop;
-       SET_FTYPE(f_dev->f_dentry->d_inode->i_mode, type);
-       return f_dev;
-}
-
-/* We provide a separate set of f_ops for devices (char and block), and the fops
- * is the only thing that differs from the regular KFS.  We need to do some
- * ghetto-overriding of these ops after we create them. */
-int dev_c_llseek(struct file *file, off64_t offset, off64_t *ret, int whence)
-{
-       set_errno(EINVAL);
-       return -1;
-}
-
-/* we don't allow mmapping of any device file */
-int dev_mmap(struct file *file, struct vm_region *vmr)
-{
-       set_errno(EINVAL);
-       return -1;
-}
index a7a1848..7b5e494 100644 (file)
@@ -4,7 +4,6 @@
 //#define DEBUG
 #include <setjmp.h>
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 62bfdff..f1b2286 100644 (file)
 #include <arch/init.h>
 #include <bitmask.h>
 #include <slab.h>
-#include <kfs.h>
 #include <vfs.h>
-#include <devfs.h>
-#include <blockdev.h>
 #include <kthread.h>
 #include <linker_func.h>
 #include <net/ip.h>
@@ -157,11 +154,8 @@ static void __kernel_init_part_deux(void *arg)
 {
        kernel_msg_init();
        timer_init();
-       vfs_init();
-       devfs_init();
        time_init();
        arch_init();
-       block_init();
        enable_irq();
        run_linker_funcs();
        /* reset/init devtab after linker funcs 3 and 4.  these run NIC and medium
diff --git a/kern/src/kfs.c b/kern/src/kfs.c
deleted file mode 100644 (file)
index e851e28..0000000
+++ /dev/null
@@ -1,926 +0,0 @@
-/* Copyright (c) 2009, 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Implementation of the KFS file system.  It is a RAM based, read-only FS
- * consisting of files that are added to the kernel binary image.  Might turn
- * this into a read/write FS with directories someday. */
-#include <vfs.h>
-#include <kfs.h>
-#include <slab.h>
-#include <kmalloc.h>
-#include <string.h>
-#include <stdio.h>
-#include <assert.h>
-#include <error.h>
-#include <cpio.h>
-#include <pmap.h>
-#include <smp.h>
-
-#define KFS_MAX_FILE_SIZE 1024*1024*128
-#define KFS_MAGIC 0xdead0001
-
-/* VFS required Functions */
-/* These structs are declared again and initialized farther down */
-struct page_map_operations kfs_pm_op;
-struct super_operations kfs_s_op;
-struct inode_operations kfs_i_op;
-struct dentry_operations kfs_d_op;
-struct file_operations kfs_f_op_file;
-struct file_operations kfs_f_op_dir;
-struct file_operations kfs_f_op_sym;
-
-static int add_kfs_entry(struct cpio_bin_hdr *c_bhdr, void *cb_arg);
-
-/* TODO: something more better.  Prob something like the vmem cache, for this,
- * pids, etc.  Good enough for now.  This also means we can only have one
- * KFS instance, and we also aren't synchronizing access. */
-static unsigned long kfs_get_free_ino(void)
-{
-       static unsigned long last_ino = 1;       /* 1 is reserved for the root */
-       last_ino++;
-       if (!last_ino)
-               panic("Out of inos in KFS!");
-       return last_ino;
-}
-
-/* Slabs for KFS specific info chunks */
-struct kmem_cache *kfs_i_kcache;
-
-static void kfs_init(void)
-{
-       kfs_i_kcache = kmem_cache_create("kfs_ino_info",
-                                        sizeof(struct kfs_i_info),
-                                        __alignof__(struct kfs_i_info), 0,
-                                        NULL, 0, 0, NULL);
-}
-
-/* Creates the SB (normally would read in from disc and create).  Passes its
- * ref out to whoever consumes this.  Returns 0 on failure.
- * TODO: consider pulling out more of the FS-independent stuff, if possible.
- * There are only two things, but the pain in the ass is that you'd need to read
- * the disc to get that first inode, and it's a FS-specific thing. */
-struct super_block *kfs_get_sb(struct fs_type *fs, int flags,
-                               char *dev_name, struct vfsmount *vmnt)
-{
-       /* Ought to check that dev_name has our FS on it.  in this case, it's
-        * irrelevant. */
-       //if (something_bad)
-       //      return 0;
-       static bool ran_once = FALSE;
-       if (!ran_once) {
-               ran_once = TRUE;
-               kfs_init();
-       }
-
-       /* Build and init the SB.  No need to read off disc. */
-       struct super_block *sb = get_sb();
-       sb->s_dev = 1337;
-       sb->s_blocksize = 1;
-       sb->s_maxbytes = KFS_MAX_FILE_SIZE;
-       sb->s_type = &kfs_fs_type;
-       sb->s_op = &kfs_s_op;
-       sb->s_flags = flags;
-       sb->s_magic = KFS_MAGIC;
-       sb->s_mount = vmnt;
-       sb->s_syncing = FALSE;
-       sb->s_bdev = 0;
-       strlcpy(sb->s_name, "KFS", 32);
-       /* store the location of the CPIO archive.  make this more generic later. */
-       extern uint8_t _binary_obj_kern_initramfs_cpio_size[];
-       extern uint8_t _binary_obj_kern_initramfs_cpio_start[];
-       sb->s_fs_info = (void*)_binary_obj_kern_initramfs_cpio_start;
-
-       /* Final stages of initializing the sb, mostly FS-independent */
-       /* 1 is the KFS root ino (inode number) */
-       init_sb(sb, vmnt, &kfs_d_op, 1, 0);
-       /* Parses the CPIO entries and builds the in-memory KFS tree. */
-       parse_cpio_entries(sb->s_fs_info,
-                          (size_t)_binary_obj_kern_initramfs_cpio_size,
-                          add_kfs_entry, sb);
-       printk("KFS superblock loaded\n");
-       return sb;
-}
-
-void kfs_kill_sb(struct super_block *sb)
-{
-       panic("Killing KFS is not supported!");
-}
-
-/* Every FS must have a static FS Type, with which the VFS code can bootstrap */
-struct fs_type kfs_fs_type = {"KFS", 0, kfs_get_sb, kfs_kill_sb, {0, 0},
-               TAILQ_HEAD_INITIALIZER(kfs_fs_type.fs_supers)};
-
-/* Page Map Operations */
-
-/* Fills page with its contents from its backing store file.  Note that we do
- * the zero padding here, instead of higher in the VFS.  Might change in the
- * future. */
-int kfs_readpage(struct page_map *pm, struct page *page)
-{
-       size_t pg_idx_byte = page->pg_index * PGSIZE;
-       struct kfs_i_info *k_i_info = (struct kfs_i_info*)
-                                     pm->pm_host->i_fs_info;
-       uintptr_t begin = (size_t)k_i_info->filestart + pg_idx_byte;
-
-       /* Pretend that we blocked while filing this page.  This catches a lot of
-        * bugs.  It does slightly slow down the kernel, but it's only when filling
-        * the page cache, and considering we are using a RAMFS, you shouldn't
-        * measure things that actually rely on KFS's performance. */
-       kthread_usleep(1);
-       /* If we're beyond the initial start point, we just need a zero page.  This
-        * is for a hole or for extending a file (even though it won't be saved).
-        * Otherwise, we want the data from KFS, being careful to not copy from
-        * beyond the original EOF (and zero padding anything extra). */
-       if (pg_idx_byte >= k_i_info->init_size) {
-               memset(page2kva(page), 0, PGSIZE);
-       } else {
-               size_t copy_amt = MIN(PGSIZE, k_i_info->init_size - pg_idx_byte);
-               memcpy(page2kva(page), (void*)begin, copy_amt);
-               memset(page2kva(page) + copy_amt, 0, PGSIZE - copy_amt);
-       }
-       struct buffer_head *bh = kmem_cache_alloc(bh_kcache, 0);
-       if (!bh)
-               return -1;                      /* untested, un-thought-through */
-       atomic_or(&page->pg_flags, PG_BUFFER);
-       /* KFS does a 1:1 BH to page mapping */
-       bh->bh_page = page;                                                             /* weak ref */
-       bh->bh_buffer = page2kva(page);
-       bh->bh_flags = 0;                                                               /* whatever... */
-       bh->bh_next = 0;                                                                /* only one BH needed */
-       bh->bh_bdev = pm->pm_host->i_sb->s_bdev;                /* uncounted */
-       bh->bh_sector = page->pg_index;
-       bh->bh_nr_sector = 1;                                                   /* sector size = PGSIZE */
-       page->pg_private = bh;
-       /* This is supposed to be done in the IO system when the operation is
-        * complete.  Since we aren't doing a real IO request, and it is already
-        * done, we can do it here. */
-       atomic_or(&page->pg_flags, PG_UPTODATE);
-       return 0;
-}
-
-int kfs_writepage(struct page_map *pm, struct page *page)
-{
-       warn_once("KFS writepage does not save file contents!\n");
-       return -1;
-}
-
-/* Super Operations */
-
-/* Creates and initializes a new inode.  FS specific, yet inode-generic fields
- * are filled in.  inode-specific fields are filled in in read_inode() based on
- * what's on the disk for a given i_no.  i_no and i_fop are set by the caller.
- *
- * Note that this means this inode can be for an inode that is already on disk,
- * or it can be used when creating.  The i_fop depends on the type of file
- * (file, directory, symlink, etc). */
-struct inode *kfs_alloc_inode(struct super_block *sb)
-{
-       struct inode *inode = kmem_cache_alloc(inode_kcache, 0);
-       memset(inode, 0, sizeof(struct inode));
-       inode->i_op = &kfs_i_op;
-       inode->i_pm.pm_op = &kfs_pm_op;
-       inode->i_fs_info = kmem_cache_alloc(kfs_i_kcache, 0);
-       TAILQ_INIT(&((struct kfs_i_info*)inode->i_fs_info)->children);
-       ((struct kfs_i_info*)inode->i_fs_info)->filestart = 0;
-       ((struct kfs_i_info*)inode->i_fs_info)->init_size = 0;
-       return inode;
-}
-
-/* FS-specific clean up when an inode is dealloced.  this is just cleaning up
- * the in-memory version, and only the FS-specific parts.  whether or not the
- * inode is still on disc is irrelevant. */
-void kfs_dealloc_inode(struct inode *inode)
-{
-       /* If we're a symlink, give up our storage for the symname */
-       if (S_ISLNK(inode->i_mode))
-               kfree(((struct kfs_i_info*)inode->i_fs_info)->filestart);
-       kmem_cache_free(kfs_i_kcache, inode->i_fs_info);
-}
-
-/* reads the inode data on disk specified by inode->i_ino into the inode.
- * basically, it's a "make this inode the one for i_ino (i number)" */
-void kfs_read_inode(struct inode *inode)
-{
-       /* need to do something to link this inode/file to the actual "blocks" on
-        * "disk". */
-
-       /* TODO: what does it mean to ask for an inode->i_ino that doesn't exist?
-        *      possibly a bug, since these inos come from directories */
-       if (inode->i_ino == 1) {
-               inode->i_mode = S_IRWXU | S_IRWXG | S_IRWXO;
-               SET_FTYPE(inode->i_mode, __S_IFDIR);
-               inode->i_fop = &kfs_f_op_dir;
-               inode->i_nlink = 1;                             /* assuming only one hardlink */
-               inode->i_uid = 0;
-               inode->i_gid = 0;
-               inode->i_size = 0;                              /* make sense for KFS? */
-               inode->i_atime.tv_sec = 0;
-               inode->i_atime.tv_nsec = 0;
-               inode->i_mtime.tv_sec = 0;
-               inode->i_mtime.tv_nsec = 0;
-               inode->i_ctime.tv_sec = 0;
-               inode->i_ctime.tv_nsec = 0;
-               inode->i_blocks = 0;
-               inode->i_flags = 0;
-               inode->i_socket = FALSE;
-       } else {
-               panic("Not implemented");
-       }
-       /* TODO: unused: inode->i_hash add to hash (saves on disc reading) */
-}
-
-/* called when an inode in memory is modified (journalling FS's care) */
-void kfs_dirty_inode(struct inode *inode)
-{      // KFS doesn't care
-}
-
-/* write the inode to disk (specifically, to inode inode->i_ino), synchronously
- * if we're asked to wait */
-void kfs_write_inode(struct inode *inode, bool wait)
-{      // KFS doesn't care
-}
-
-/* called when an inode is decref'd, to do any FS specific work */
-void kfs_put_inode(struct inode *inode)
-{      // KFS doesn't care
-}
-
-/* called when an inode is about to be destroyed.  the generic version ought to
- * remove every reference to the inode from the VFS, and if the inode isn't in
- * any directory, calls delete_inode */
-void kfs_drop_inode(struct inode *inode)
-{ // TODO: should call a generic one instead.  or at least do something...
-       // remove from lists
-}
-
-/* delete the inode from disk (all data) */
-void kfs_delete_inode(struct inode *inode)
-{
-       // would remove from "disk" here
-       /* TODO: give up our i_ino */
-}
-
-/* unmount and release the super block */
-void kfs_put_super(struct super_block *sb)
-{
-       panic("Shazbot! KFS can't be unmounted yet!");
-}
-
-/* updates the on-disk SB with the in-memory SB */
-void kfs_write_super(struct super_block *sb)
-{      // KFS doesn't care
-}
-
-/* syncs FS metadata with the disc, synchronously if we're waiting.  this info
- * also includes anything pointed to by s_fs_info. */
-int kfs_sync_fs(struct super_block *sb, bool wait)
-{
-       return 0;
-}
-
-/* remount the FS with the new flags */
-int kfs_remount_fs(struct super_block *sb, int flags, char *data)
-{
-       warn("KFS will not remount.");
-       return -1; // can't remount
-}
-
-/* interrupts a mount operation - used by NFS and friends */
-void kfs_umount_begin(struct super_block *sb)
-{
-       panic("Cannot abort a KFS mount, and why would you?");
-}
-
-/* inode_operations */
-
-/* Little helper, used for initializing new inodes for file-like objects (files,
- * symlinks, etc).  We pass the dentry, since we need to up it. */
-static void kfs_init_inode(struct inode *dir, struct dentry *dentry)
-{
-       struct inode *inode = dentry->d_inode;
-       kref_get(&dentry->d_kref, 1);   /* to pin the dentry in RAM, KFS-style... */
-       inode->i_ino = kfs_get_free_ino();
-       /* our parent dentry's inode tracks our dentry info.  We do this
-        * since it's all in memory and we aren't using the dcache yet.
-        * We're reusing the subdirs link, which is used by the VFS when
-        * we're a directory.  But since we're a file, it's okay to reuse
-        * it. */
-       TAILQ_INSERT_TAIL(&((struct kfs_i_info*)dir->i_fs_info)->children,
-                         dentry, d_subdirs_link);
-}
-
-/* Called when creating a new disk inode in dir associated with dentry.  We need
- * to fill out the i_ino, set the type, and do whatever else we need */
-int kfs_create(struct inode *dir, struct dentry *dentry, int mode,
-               struct nameidata *nd)
-{
-       struct inode *inode = dentry->d_inode;
-       kfs_init_inode(dir, dentry);
-       SET_FTYPE(inode->i_mode, __S_IFREG);
-       inode->i_fop = &kfs_f_op_file;
-       /* fs_info->filestart is set by the caller, or else when first written (for
-        * new files.  it was set to 0 in alloc_inode(). */
-       return 0;
-}
-
-/* Searches the directory for the filename in the dentry, filling in the dentry
- * with the FS specific info of this file.  If it succeeds, it will pass back
- * the *dentry you should use.  If this fails, it will return 0.  It will NOT
- * take your dentry ref (it used to).  It probably will not be the same dentry
- * you passed in.  This is ugly.
- *
- * Callers, make sure you alloc and fill out the name parts of the dentry, and
- * an initialized nameidata. TODO: not sure why we need an ND.  Don't use it in
- * a fs_lookup for now!
- *
- * Because of the way KFS currently works, if there is ever a dentry, it's
- * already in memory, along with its inode (all path's pinned).  So we just find
- * it and return it, freeing the one that came in. */
-struct dentry *kfs_lookup(struct inode *dir, struct dentry *dentry,
-                          struct nameidata *nd)
-{
-       struct kfs_i_info *k_i_info = (struct kfs_i_info*)dir->i_fs_info;
-       struct dentry *dir_dent = TAILQ_FIRST(&dir->i_dentry);
-       struct dentry *d_i;
-
-       assert(dir_dent && dir_dent == TAILQ_LAST(&dir->i_dentry, dentry_tailq));
-       /* had this fail when kern/kfs has a symlink go -> ../../../go, though
-        * a symlink like lib2 -> lib work okay. */
-       assert(S_ISDIR(dir->i_mode));
-       assert(kref_refcnt(&dentry->d_kref) == 1);
-       TAILQ_FOREACH(d_i, &dir_dent->d_subdirs, d_subdirs_link) {
-               if (!strcmp(d_i->d_name.name, dentry->d_name.name)) {
-                       /* since this dentry is already in memory (that's how KFS works), we
-                        * just return the real one (with another refcnt) */
-                       kref_get(&d_i->d_kref, 1);
-                       return d_i;
-               }
-       }
-       TAILQ_FOREACH(d_i, &k_i_info->children, d_subdirs_link) {
-               if (!strcmp(d_i->d_name.name, dentry->d_name.name)) {
-                       /* since this dentry is already in memory (that's how KFS works), we
-                        * just return the real one (with another refcnt) */
-                       kref_get(&d_i->d_kref, 1);
-                       return d_i;
-               }
-       }
-       printd("Not Found %s!!\n", dentry->d_name.name);
-       return 0;
-}
-
-/* Hard link to old_dentry in directory dir with a name specified by new_dentry.
- * At the very least, set the new_dentry's FS-specific fields. */
-int kfs_link(struct dentry *old_dentry, struct inode *dir,
-             struct dentry *new_dentry)
-{
-       assert(new_dentry->d_op = &kfs_d_op);
-       kref_get(&new_dentry->d_kref, 1);               /* pin the dentry, KFS-style */
-       /* KFS-style directory-tracking-of-kids */
-       TAILQ_INSERT_TAIL(&((struct kfs_i_info*)dir->i_fs_info)->children,
-                         new_dentry, d_subdirs_link);
-       return 0;
-}
-
-/* Removes the link from the dentry in the directory */
-int kfs_unlink(struct inode *dir, struct dentry *dentry)
-{
-       /* Stop tracking our child */
-       TAILQ_REMOVE(&((struct kfs_i_info*)dir->i_fs_info)->children, dentry,
-                    d_subdirs_link);
-       kref_put(&dentry->d_kref);                              /* unpin the dentry, KFS-style */
-       return 0;
-}
-
-/* Creates a new inode for a symlink dir, linking to / containing the name
- * symname.  dentry is the controlling dentry of the inode. */
-int kfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
-{
-       struct inode *inode = dentry->d_inode;
-       struct kfs_i_info *k_i_info = (struct kfs_i_info*)inode->i_fs_info;
-       size_t len = strlen(symname);
-       char *string = kmalloc(len + 1, 0);
-
-       kfs_init_inode(dir, dentry);
-       SET_FTYPE(inode->i_mode, __S_IFLNK);
-       inode->i_fop = &kfs_f_op_sym;
-       strlcpy(string, symname, len + 1);
-       k_i_info->filestart = string;   /* reusing this void* to hold the char* */
-       return 0;
-}
-
-/* Called when creating a new inode for a directory associated with dentry in
- * dir with the given mode.  Note, we might (later) need to track subdirs within
- * the parent inode, like we do with regular files.  I'd rather not, so we'll
- * see if we need it. */
-int kfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
-{
-       struct inode *inode = dentry->d_inode;
-       kref_get(&dentry->d_kref, 1);   /* to pin the dentry in RAM, KFS-style... */
-       inode->i_ino = kfs_get_free_ino();
-       SET_FTYPE(inode->i_mode, __S_IFDIR);
-       inode->i_fop = &kfs_f_op_dir;
-       /* get ready to have our own kids */
-       TAILQ_INIT(&((struct kfs_i_info*)inode->i_fs_info)->children);
-       ((struct kfs_i_info*)inode->i_fs_info)->filestart = 0;
-       return 0;
-}
-
-/* Removes from dir the directory 'dentry.'  KFS doesn't store anything in the
- * inode for which children it has.  It probably should, but since everything is
- * pinned, it just relies on the dentry connections. */
-int kfs_rmdir(struct inode *dir, struct dentry *dentry)
-{
-       struct kfs_i_info *d_info = (struct kfs_i_info*)dentry->d_inode->i_fs_info;
-       struct dentry *d_i;
-       bool empty = TRUE;
-       /* Check if we are empty.  If not, error out, need to check the sub-dirs as
-        * well as the sub-"files" */
-       TAILQ_FOREACH(d_i, &dentry->d_subdirs, d_subdirs_link) {
-               empty = FALSE;
-               break;
-       }
-       TAILQ_FOREACH(d_i, &d_info->children, d_subdirs_link) {
-               empty = FALSE;
-               break;
-       }
-       if (!empty)
-               return -ENOTEMPTY;
-       kref_put(&dentry->d_kref);                              /* unpin the dentry, KFS-style */
-       printd("DENTRY %s REFCNT %d\n", dentry->d_name.name, kref_refcnt(&dentry->d_kref));
-       return 0;
-}
-
-/* Used to make a generic file, based on the type and the major/minor numbers
- * (in rdev), with the given mode.  As with others, this creates a new disk
- * inode for the file */
-int kfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
-{
-       return -1;
-}
-
-/* Moves old_d from old_dir to new_d in new_dir.  TODO: super racy */
-int kfs_rename(struct inode *old_dir, struct dentry *old_d,
-               struct inode *new_dir, struct dentry *new_d)
-{
-       /* new_d is already gone, we just use it for its name.  kfs might not care
-        * about the name.  it might just use whatever the dentry says. */
-       struct kfs_i_info *old_info = (struct kfs_i_info*)old_dir->i_fs_info;
-       struct kfs_i_info *new_info = (struct kfs_i_info*)new_dir->i_fs_info;
-       printd("KFS rename: %s/%s -> %s/%s\n",
-              TAILQ_FIRST(&old_dir->i_dentry)->d_name.name, old_d->d_name.name,
-              TAILQ_FIRST(&new_dir->i_dentry)->d_name.name, new_d->d_name.name);
-       /* we want to remove from the old and add to the new.  for non-directories,
-        * we need to adjust parent's children lists (which reuses subdirs_link,
-        * yikes!).  directories aren't actually tracked by KFS; it just hopes the
-        * VFS's pinned dentry tree is enough (aka, "all paths pinned"). */
-       if (!S_ISDIR(old_d->d_inode->i_mode)) {
-               TAILQ_REMOVE(&old_info->children, old_d, d_subdirs_link);
-               TAILQ_INSERT_TAIL(&new_info->children, old_d, d_subdirs_link);
-       }
-       return 0;
-}
-
-/* Returns the char* for the symname for the given dentry.  The VFS code that
- * calls this for real FS's might assume it's already read in, so if the char *
- * isn't already in memory, we'd need to read it in here.  Regarding the char*
- * storage, the char* only will last as long as the dentry and inode are in
- * memory. */
-char *kfs_readlink(struct dentry *dentry)
-{
-       struct inode *inode = dentry->d_inode;
-       struct kfs_i_info *k_i_info = (struct kfs_i_info*)inode->i_fs_info;
-       if (!S_ISLNK(inode->i_mode))
-               return 0;
-       return k_i_info->filestart;
-}
-
-/* Modifies the size of the file of inode to whatever its i_size is set to */
-void kfs_truncate(struct inode *inode)
-{
-       struct kfs_i_info *k_i_info = (struct kfs_i_info*)inode->i_fs_info;
-       /* init_size tracks how much of the file KFS has.  everything else is 0s.
-        * we only need to update it if we are dropping data.  as with other data
-        * beyond init_size, KFS will not save it during a write page! */
-       k_i_info->init_size = MIN(k_i_info->init_size, inode->i_size);
-}
-
-/* Checks whether the the access mode is allowed for the file belonging to the
- * inode.  Implies that the permissions are on the file, and not the hardlink */
-int kfs_permission(struct inode *inode, int mode, struct nameidata *nd)
-{
-       return -1;
-}
-
-
-/* dentry_operations */
-/* Determines if the dentry is still valid before using it to translate a path.
- * Network FS's need to deal with this. */
-int kfs_d_revalidate(struct dentry *dir, struct nameidata *nd)
-{ // default, nothing
-       return -1;
-}
-
-/* Compares name1 and name2.  name1 should be a member of dir. */
-int kfs_d_compare(struct dentry *dir, struct qstr *name1, struct qstr *name2)
-{ // default, string comp (case sensitive)
-       return -1;
-}
-
-/* Called when the last ref is deleted (refcnt == 0) */
-int kfs_d_delete(struct dentry *dentry)
-{ // default, nothin
-       return -1;
-}
-
-/* Called when it's about to be slab-freed */
-int kfs_d_release(struct dentry *dentry)
-{
-       return -1;
-}
-
-/* Called when the dentry loses its inode (becomes "negative") */
-void kfs_d_iput(struct dentry *dentry, struct inode *inode)
-{ // default, call i_put to release the inode object
-}
-
-
-/* file_operations */
-
-/* Updates the file pointer.  TODO: think about locking. */
-int kfs_llseek(struct file *file, off64_t offset, off64_t *ret, int whence)
-{
-       off64_t temp_off = 0;
-       switch (whence) {
-               case SEEK_SET:
-                       temp_off = offset;
-                       break;
-               case SEEK_CUR:
-                       temp_off = file->f_pos + offset;
-                       break;
-               case SEEK_END:
-                       temp_off = file->f_dentry->d_inode->i_size + offset;
-                       break;
-               default:
-                       set_errno(EINVAL);
-                       warn("Unknown 'whence' in llseek()!\n");
-                       return -1;
-       }
-       file->f_pos = temp_off;
-       *ret = temp_off;
-       return 0;
-}
-
-/* Fills in the next directory entry (dirent), starting with d_off.  KFS treats
- * the size of each dirent as 1 byte, which we can get away with since the d_off
- * is a way of communicating with future calls to readdir (FS-specific).
- *
- * Like with read and write, there will be issues with userspace and the *dirent
- * buf.  TODO: we don't really do anything with userspace concerns here, in part
- * because memcpy_to doesn't work well.  When we fix how we want to handle the
- * userbuffers, we can write this accordingly. (UMEM)  */
-int kfs_readdir(struct file *dir, struct kdirent *dirent)
-{
-       int count = 2;  /* total num dirents, gets incremented in check_entry() */
-       int desired_file = dirent->d_off;
-       bool found = FALSE;
-       struct dentry *subent;
-       struct dentry *dir_d = dir->f_dentry;
-       struct kfs_i_info *k_i_info = (struct kfs_i_info*)dir_d->d_inode->i_fs_info;
-
-       /* how we check inside the for loops below.  moderately ghetto. */
-       void check_entry(void)
-       {
-               if (count++ == desired_file) {
-                       dirent->d_ino = subent->d_inode->i_ino;
-                       dirent->d_off = count;
-                       dirent->d_reclen = subent->d_name.len;
-                       /* d_name.name is null terminated, the byte after d_name.len.
-                        * Regardless, exercise caution as we copy into d_name, should
-                        * the size of the quickstring buffer and the size of d_name
-                        * fall out of sync with one another. */
-                       assert(subent->d_name.len < sizeof(dirent->d_name));
-                       strncpy(dirent->d_name, subent->d_name.name,
-                               sizeof(dirent->d_name) - 1);
-                       dirent->d_name[sizeof(dirent->d_name) - 1] = '\0';
-                       found = TRUE;
-               }
-       }
-
-       /* Handle . and .. (first two dirents) */
-       if (desired_file == 0) {
-               dirent->d_ino = dir_d->d_inode->i_ino;
-               dirent->d_off = 1;
-               dirent->d_reclen = 1;
-               strlcpy(dirent->d_name, ".", sizeof(dirent->d_name));
-               found = TRUE;
-       } else if (desired_file == 1) {
-               dirent->d_ino = dir_d->d_parent->d_inode->i_ino;
-               dirent->d_off = 2;
-               dirent->d_reclen = 2;
-               strlcpy(dirent->d_name, "..", sizeof(dirent->d_name));
-               found = TRUE;
-       }
-       /* need to check the sub-dirs as well as the sub-"files".  The main
-        * ghetto-ness with this is that we check even though we have our result,
-        * simply to figure out how big our directory is.  It's just not worth
-        * changing at this point. */
-       TAILQ_FOREACH(subent, &dir_d->d_subdirs, d_subdirs_link)
-               check_entry();
-       TAILQ_FOREACH(subent, &k_i_info->children, d_subdirs_link)
-               check_entry();
-       if (!found)
-               return -ENOENT;
-       if (count - 1 == desired_file)          /* found the last dir in the list */
-               return 0;
-       return 1;                                                       /* normal success for readdir */
-}
-
-/* This is called when a VMR is mapping a particular file.  The FS needs to do
- * whatever it needs so that faults can be handled by read_page(), and handle all
- * of the cases of MAP_SHARED, MAP_PRIVATE, whatever.  It also needs to ensure
- * the file is not being mmaped in a way that conflicts with the manner in which
- * the file was opened or the file type. */
-int kfs_mmap(struct file *file, struct vm_region *vmr)
-{
-       if (S_ISREG(file->f_dentry->d_inode->i_mode))
-               return 0;
-       return -1;
-}
-
-/* Called by the VFS while opening the file, which corresponds to inode,  for
- * the FS to do whatever it needs. */
-int kfs_open(struct inode *inode, struct file *file)
-{
-       return 0;
-}
-
-/* Called when a file descriptor is closed. */
-int kfs_flush(struct file *file)
-{
-       return -1;
-}
-
-/* Called when the file is about to be closed (file obj freed) */
-int kfs_release(struct inode *inode, struct file *file)
-{
-       return 0;
-}
-
-/* Flushes the file's dirty contents to disc */
-int kfs_fsync(struct file *file, struct dentry *dentry, int datasync)
-{
-       return -1;
-}
-
-/* Traditionally, sleeps until there is file activity.  We probably won't
- * support this, or we'll handle it differently. */
-unsigned int kfs_poll(struct file *file, struct poll_table_struct *poll_table)
-{
-       return -1;
-}
-
-/* Reads count bytes from a file, starting from (and modifiying) offset, and
- * putting the bytes into buffers described by vector */
-ssize_t kfs_readv(struct file *file, const struct iovec *vector,
-                  unsigned long count, off64_t *offset)
-{
-       return -1;
-}
-
-/* Writes count bytes to a file, starting from (and modifiying) offset, and
- * taking the bytes from buffers described by vector */
-ssize_t kfs_writev(struct file *file, const struct iovec *vector,
-                  unsigned long count, off64_t *offset)
-{
-       return -1;
-}
-
-/* Write the contents of file to the page.  Will sort the params later */
-ssize_t kfs_sendpage(struct file *file, struct page *page, int offset,
-                     size_t size, off64_t pos, int more)
-{
-       return -1;
-}
-
-/* Checks random FS flags.  Used by NFS. */
-int kfs_check_flags(int flags)
-{ // default, nothing
-       return -1;
-}
-
-/* Redeclaration and initialization of the FS ops structures */
-struct page_map_operations kfs_pm_op = {
-       kfs_readpage,
-       kfs_writepage,
-};
-
-struct super_operations kfs_s_op = {
-       kfs_alloc_inode,
-       kfs_dealloc_inode,
-       kfs_read_inode,
-       kfs_dirty_inode,
-       kfs_write_inode,
-       kfs_put_inode,
-       kfs_drop_inode,
-       kfs_delete_inode,
-       kfs_put_super,
-       kfs_write_super,
-       kfs_sync_fs,
-       kfs_remount_fs,
-       kfs_umount_begin,
-};
-
-struct inode_operations kfs_i_op = {
-       kfs_create,
-       kfs_lookup,
-       kfs_link,
-       kfs_unlink,
-       kfs_symlink,
-       kfs_mkdir,
-       kfs_rmdir,
-       kfs_mknod,
-       kfs_rename,
-       kfs_readlink,
-       kfs_truncate,
-       kfs_permission,
-};
-
-struct dentry_operations kfs_d_op = {
-       kfs_d_revalidate,
-       generic_dentry_hash,
-       kfs_d_compare,
-       kfs_d_delete,
-       kfs_d_release,
-       kfs_d_iput,
-};
-
-struct file_operations kfs_f_op_file = {
-       kfs_llseek,
-       generic_file_read,
-       generic_file_write,
-       kfs_readdir,
-       kfs_mmap,
-       kfs_open,
-       kfs_flush,
-       kfs_release,
-       kfs_fsync,
-       kfs_poll,
-       kfs_readv,
-       kfs_writev,
-       kfs_sendpage,
-       kfs_check_flags,
-};
-
-struct file_operations kfs_f_op_dir = {
-       kfs_llseek,
-       generic_dir_read,
-       0,
-       kfs_readdir,
-       kfs_mmap,
-       kfs_open,
-       kfs_flush,
-       kfs_release,
-       kfs_fsync,
-       kfs_poll,
-       kfs_readv,
-       kfs_writev,
-       kfs_sendpage,
-       kfs_check_flags,
-};
-
-struct file_operations kfs_f_op_sym = {
-       kfs_llseek,
-       generic_file_read,
-       generic_file_write,
-       kfs_readdir,
-       kfs_mmap,
-       kfs_open,
-       kfs_flush,
-       kfs_release,
-       kfs_fsync,
-       kfs_poll,
-       kfs_readv,
-       kfs_writev,
-       kfs_sendpage,
-       kfs_check_flags,
-};
-
-/* KFS Specific Internal Functions */
-
-/* Need to pass path separately, since we'll recurse on it.  TODO: this recurses,
- * and takes up a lot of stack space (~270 bytes).  Core 0's KSTACK is 8 pages,
- * which can handle about 120 levels deep...  Other cores are not so fortunate.
- * Can rework this if it becomes an issue. */
-static int __add_kfs_entry(struct dentry *parent, char *path,
-                           struct cpio_bin_hdr *c_bhdr)
-{
-       char *first_slash = strchr(path, '/');
-       char dir[MAX_FILENAME_SZ + 1];  /* room for the \0 */
-       size_t dirname_sz;                              /* not counting the \0 */
-       struct dentry *dentry = 0;
-       struct inode *inode;
-       int err, retval;
-       char *symname, old_end;                 /* for symlink manipulation */
-
-       if (first_slash) {
-               /* get the first part, find that dentry, pass in the second part,
-                * recurse.  this isn't being smart about extra slashes, dots, or
-                * anything like that. */
-               dirname_sz = first_slash - path;
-               assert(dirname_sz <= MAX_FILENAME_SZ);
-               memmove(dir, path, dirname_sz);
-               dir[dirname_sz] = '\0';
-               printd("Finding DIR %s in dentry %s (start: %p, size %d)\n", dir,
-                      parent->d_name.name, c_bhdr->c_filestart, c_bhdr->c_filesize);
-               /* Need to create a dentry for the lookup, and fill in the basic nd */
-               dentry = get_dentry(parent->d_sb, parent, dir);
-               /* TODO: use a VFS lookup instead, to use the dcache, thought its not a
-                * big deal since KFS currently pins all metadata. */
-               dentry = kfs_lookup(parent->d_inode, dentry, 0);
-               if (!dentry) {
-                       printk("Missing dir in CPIO archive or something, aborting.\n");
-                       return -1;
-               }
-               retval = __add_kfs_entry(dentry, first_slash + 1, c_bhdr);
-               kref_put(&dentry->d_kref);
-               return retval;
-       } else {
-               /* no directories left in the path.  add the 'file' to the dentry */
-               printd("Adding file/dir %s to dentry %s (start: %p, size %d)\n", path,
-                      parent->d_name.name, c_bhdr->c_filestart, c_bhdr->c_filesize);
-               /* Init the dentry for this path */
-               dentry = get_dentry(parent->d_sb, parent, path);
-               // want to test the regular/natural dentry caching paths
-               //dcache_put(dentry->d_sb, dentry);
-               /* build the inode */
-               switch (c_bhdr->c_mode & CPIO_FILE_MASK) {
-                       case (CPIO_DIRECTORY):
-                               err = create_dir(parent->d_inode, dentry, c_bhdr->c_mode);
-                               assert(!err);
-                               break;
-                       case (CPIO_SYMLINK):
-                               /* writing the '\0' is safe since the next entry is always still
-                                * in the CPIO (and we are processing sequentially). */
-                               symname = c_bhdr->c_filestart;
-                               old_end = symname[c_bhdr->c_filesize];
-                               symname[c_bhdr->c_filesize] = '\0';
-                               err = create_symlink(parent->d_inode, dentry, symname,
-                                                    c_bhdr->c_mode & CPIO_PERM_MASK);
-                               assert(!err);
-                               symname[c_bhdr->c_filesize] = old_end;
-                               break;
-                       case (CPIO_REG_FILE):
-                               err = create_file(parent->d_inode, dentry,
-                                                 c_bhdr->c_mode & CPIO_PERM_MASK);
-                               assert(!err);
-                               ((struct kfs_i_info*)dentry->d_inode->i_fs_info)->filestart =
-                                                                                                               c_bhdr->c_filestart;
-                               ((struct kfs_i_info*)dentry->d_inode->i_fs_info)->init_size =
-                                                                                                               c_bhdr->c_filesize;
-                               break;
-                       default:
-                               printk("Unknown file type %d in the CPIO!",
-                                      c_bhdr->c_mode & CPIO_FILE_MASK);
-                               kref_put(&dentry->d_kref);
-                               return -1;
-               }
-               inode = dentry->d_inode;
-               /* Set other info from the CPIO entry */
-               inode->i_uid = c_bhdr->c_uid;
-               inode->i_gid = c_bhdr->c_gid;
-               inode->i_atime.tv_sec = c_bhdr->c_mtime;
-               inode->i_ctime.tv_sec = c_bhdr->c_mtime;
-               inode->i_mtime.tv_sec = c_bhdr->c_mtime;
-               inode->i_size = c_bhdr->c_filesize;
-               //inode->i_XXX = c_bhdr->c_dev;                 /* and friends */
-               inode->i_bdev = 0;                                              /* assuming blockdev? */
-               inode->i_socket = FALSE;
-               inode->i_blocks = c_bhdr->c_filesize;   /* blocksize == 1 */
-               kref_put(&dentry->d_kref);
-       }
-       return 0;
-}
-
-/* Adds an entry (from a CPIO archive) to KFS.  This will put all the FS
- * metadata in memory, instead of having to reparse the entire archive each time
- * we need to traverse.
- *
- * The other option is to just maintain a LL of {FN, FS}, and O(n) scan it.
- *
- * The path is a complete path, interpreted from the root of the mount point.
- * Directories have a size of 0.  so do symlinks, but we don't handle those yet.
- *
- * If a directory does not exist for a file, this will return an error.  Don't
- * use the -depth flag to find when building the CPIO archive, and this won't be
- * a problem.  (Maybe) */
-static int add_kfs_entry(struct cpio_bin_hdr *c_bhdr, void *cb_arg)
-{
-       struct super_block *sb = cb_arg;
-       char *path = c_bhdr->c_filename;
-
-       /* Root of the FS, already part of KFS */
-       if (!strcmp(path, "."))
-               return 0;
-       return __add_kfs_entry(sb->s_mount->mnt_root, path, c_bhdr);
-}
index c56839b..e39d005 100644 (file)
@@ -24,7 +24,6 @@
 #include <process.h>
 #include <syscall.h>
 #include <time.h>
-#include <kfs.h>
 #include <mm.h>
 #include <multiboot.h>
 #include <pmap.h>
index e190ca7..38296ed 100644 (file)
@@ -18,7 +18,6 @@
 #include <schedule.h>
 #include <syscall.h>
 #include <ktest.h>
-#include <kfs.h>
 #include <stdio.h>
 #include <time.h>
 #include <monitor.h>
index 49eed3f..474764a 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 1014b01..e666ddb 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 41c2b5a..3963e7d 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index e8bf1c9..f95205a 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 930358c..f3b03fb 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index e63d4ab..b0fa70e 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
@@ -41,7 +40,6 @@
 #include <net/ip.h>
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index d814777..c12f88c 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 3f1e8e7..f6b5a94 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 6355104..fa68210 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index a1ed002..87ea95b 100644 (file)
@@ -1,5 +1,4 @@
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 8276e48..f62cbd5 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index e7e0499..bbc515b 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 40400a0..ab1d701 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index fa5c66d..9e9b3d6 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index a2a9446..ee34024 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 69d931c..afd2a2d 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 6cab0fe..9904631 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 4cb1f0f..2b5cde0 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 76980aa..5b97b5d 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index c18edbe..ca53887 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 898eb87..43c81a8 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index ecc941e..077fba6 100644 (file)
@@ -28,7 +28,6 @@
 
 #define DEBUG
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
@@ -42,7 +41,6 @@
 #include <net/ip.h>
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 1b199a1..48a2d3e 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 63c9e7c..b8d227e 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 8e4fe6d..f6bca6c 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 92ce562..5a77db6 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 3c2e8e9..d1b5cc7 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index bb7b7bf..fc56311 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index a3a5936..a14a529 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index c581601..6b86b3b 100644 (file)
@@ -5,7 +5,6 @@
  * See LICENSE for details.  */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index b20dc86..c14af7c 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 9e04d31..e4ea3ac 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 3d67b66..d6a25d4 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index f9727dc..93f5efe 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index f06b1bf..169ef41 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index b9d5d9e..54f6747 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 53198e2..4f2fa46 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index 0d96d77..7dac9db 100644 (file)
@@ -27,7 +27,6 @@
  * SOFTWARE. */
 
 #include <vfs.h>
-#include <kfs.h>
 #include <slab.h>
 #include <kmalloc.h>
 #include <kref.h>
index c88ecd1..9456fc4 100644 (file)
@@ -26,7 +26,6 @@
 #include <hashtable.h>
 #include <bitmask.h>
 #include <vfs.h>
-#include <devfs.h>
 #include <smp.h>
 #include <arsc_server.h>
 #include <event.h>
index f668f73..a1847fe 100644 (file)
@@ -12,7 +12,6 @@
 #include <atomic.h>
 #include <slab.h>
 #include <kmalloc.h>
-#include <kfs.h>
 #include <pmap.h>
 #include <umem.h>
 #include <smp.h>
@@ -129,14 +128,9 @@ void vfs_init(void)
 
        /* build list of all FS's in the system.  put yours here.  if this is ever
         * done on the fly, we'll need to lock. */
-       TAILQ_INSERT_TAIL(&file_systems, &kfs_fs_type, list);
        TAILQ_FOREACH(fs, &file_systems, list)
                printk("Supports the %s Filesystem\n", fs->name);
 
-       /* mounting KFS at the root (/), pending root= parameters */
-       // TODO: linux creates a temp root_fs, then mounts the real root onto that
-       default_ns.root = __mount_fs(&kfs_fs_type, "RAM", NULL, 0, &default_ns);
-
        printk("vfs_init() completed\n");
 }
 
index 675a3ca..3ecd349 100644 (file)
@@ -2,7 +2,6 @@
 # N.B. Preserve blank line we match against so this is idempotent.
 sed -i '/^#include/,/^$/c\
 #include <vfs.h>\
-#include <kfs.h>\
 #include <slab.h>\
 #include <kmalloc.h>\
 #include <kref.h>\
index 675a3ca..3ecd349 100644 (file)
@@ -2,7 +2,6 @@
 # N.B. Preserve blank line we match against so this is idempotent.
 sed -i '/^#include/,/^$/c\
 #include <vfs.h>\
-#include <kfs.h>\
 #include <slab.h>\
 #include <kmalloc.h>\
 #include <kref.h>\