vfs: Remove ext2 support
authorBarret Rhoden <brho@cs.berkeley.edu>
Wed, 7 Mar 2018 21:04:04 +0000 (13:04 -0800)
committerBarret Rhoden <brho@cs.berkeley.edu>
Mon, 30 Apr 2018 18:31:44 +0000 (14:31 -0400)
It only half worked, and only for the VFS.

Signed-off-by: Barret Rhoden <brho@cs.berkeley.edu>
Kconfig
Makefile
config-default
kern/include/ext2fs.h [deleted file]
kern/src/Kbuild
kern/src/blockdev.c
kern/src/ext2fs.c [deleted file]
kern/src/init.c
kern/src/vfs.c

diff --git a/Kconfig b/Kconfig
index e729c9f..2c28f45 100644 (file)
--- a/Kconfig
+++ b/Kconfig
@@ -60,23 +60,6 @@ config KFS_CPIO_BIN
                This binary (relative to the root directory) will be run before
                bundling the KFS Paths into the CPIO.
 
-config EXT2FS
-       bool "Ext2 filesystem"
-       default n
-       help
-               Build in support for ext2.  Extremely experimental, and only works with
-               a block device image, which will be mounted at /mnt.  If you select
-               this, you must specify a block device.
-
-config EXT2_BDEV
-       depends on EXT2FS
-       string "Ext2 image file"
-       default mnt/ext2fs.img
-       help
-               This file needs to be an ext2 image (file that looks like a block
-               device).  You should be able to mount this file in your host OS.  It
-               will be bundled into the kernel and mounted at /mnt.
-
 endmenu
 
 choice COREALLOC_POLICY
index 57e79e7..2182e72 100644 (file)
--- a/Makefile
+++ b/Makefile
@@ -22,8 +22,7 @@
 # TODO:
 #      - Consider merging the two target-detection bits (Linux's config, mixed, or
 #      dot target, and the symlink handling).  Also, could consider moving around
-#      the KFS and EXT2 targets.  Clean doesn't need to know about them, for
-#      instance.
+#      the KFS target.  Clean doesn't need to know about it, for instance.
 #
 #      - Review, with an eye for being better about $(srctree).  It might only be
 #      necessary in this file, if we every do the KBUILD_OUTPUT option.  But we
@@ -459,16 +458,6 @@ akaros-deps := $(kbuild_akaros_main)  kern/arch/$(ARCH)/$(KERNEL_LD)
 kern_cpio := $(OBJDIR)/kern/initramfs.cpio
 kern_cpio_obj := $(kern_cpio).o
 
-# ext2 will crash at runtime if we don't have a block device.  try to catch the
-# errors now.  if it is a bad one, you're just out of luck.
-ifneq ($(CONFIG_EXT2FS),)
-ext2-bdev := $(patsubst "%",%,$(CONFIG_EXT2_BDEV))
-ifeq ($(ext2-bdev),)
-$(error EXT2 selected with no block device [$(ext2-bdev)], fix your .config)
-endif
-ext2_bdev_obj = $(OBJDIR)/kern/$(shell basename $(ext2-bdev)).o
-endif
-
 # a bit hacky: we want to make sure the directories exist, and error out
 # otherwise.  we also want to error out before the initramfs target, otherwise
 # we might not get the error (if initramfs files are all up to date).  the
index ff5c2ee..d6e0875 100644 (file)
@@ -33,7 +33,6 @@ CONFIG_SOCKET=y
 CONFIG_KFS=y
 CONFIG_KFS_PATHS="kern/kfs"
 CONFIG_KFS_CPIO_BIN=""
-# CONFIG_EXT2FS is not set
 
 #
 # Kernel Debugging
diff --git a/kern/include/ext2fs.h b/kern/include/ext2fs.h
deleted file mode 100644 (file)
index 7d101c0..0000000
+++ /dev/null
@@ -1,263 +0,0 @@
-/* Copyright (c) 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * The ROS port for Ext2 FS.  Thanks to Dave Poirier for maintaining this great
- * documentation: http://www.nongnu.org/ext2-doc/ext2.html and the ext group
- * that wrote the FS in the first place.
- *
- * Note all of ext2's disk structures are little-endian. */
-
-#pragma once
-
-#include <ros/common.h>
-#include <vfs.h>
-#include <endian.h>
-
-#define EXT2_SUPER_MAGIC               0xef53
-
-/* State settings */
-#define EXT2_VALID_FS                  1               /* Cleanly unmounted */
-#define EXT2_ERROR_FS                  2               /* Currently mounted / not unmounted */
-
-/* s_error options */
-#define EXT2_ERRORS_CONTINUE   1               /* continue on error */
-#define EXT2_ERRORS_RO                 2               /* remount read-only */
-#define EXT2_ERRORS_PANIC              3               /* panic on error */
-
-/* Creator OS options */
-#define EXT2_OS_LINUX                  0
-#define EXT2_OS_HURD                   1
-#define EXT2_OS_MASIX                  2
-#define EXT2_OS_FREEBSD                        3
-#define EXT2_OS_LITES                  4
-#define EXT2_OS_ROS                            666             /* got dibs on the mark of the beast */
-
-/* Revision Levels */
-#define EXT2_GOOD_OLD_REV              0               /* Revision 0 */
-#define EXT2_DYNAMIC_REV               1               /* Revision 1, extra crazies, etc */
-
-/* FS Compatibile Features.  We can support them or now, without risk of
- * damaging meta-data. */
-#define EXT2_FEATURE_COMPAT_DIR_PREALLOC       0x0001  /* block prealloc */
-#define EXT2_FEATURE_COMPAT_MAGIC_INODES       0x0002
-#define EXT2_FEATURE_COMPAT_HAS_JOURNAL                0x0004  /* ext3/4 journal */
-#define EXT2_FEATURE_COMPAT_EXT_ATTR           0x0008  /* extended inode attr */
-#define EXT2_FEATURE_COMPAT_RESIZE_INO         0x0010  /* non-standard ino size */
-#define EXT2_FEATURE_COMPAT_DIR_INDEX          0x0020  /* h-tree dir indexing */
-
-/* FS Incompatibile Features.  We should refuse to mount if we don't support
- * any of these. */
-#define EXT2_FEATURE_INCOMPAT_COMPRESSION      0x0001  /* disk compression */
-#define EXT2_FEATURE_INCOMPAT_FILETYPE         0x0002
-#define EXT2_FEATURE_INCOMPAT_RECOVER          0x0004
-#define EXT2_FEATURE_INCOMPAT_JOURNAL_DEV      0x0008
-#define EXT2_FEATURE_INCOMPAT_META_BG          0x0010
-
-/* FS read-only features: We should mount read-only if we don't support these */
-#define EXT2_FEATURE_RO_COMPAT_SPARSE_SUPER    0x0001  /* sparse superblock */
-#define EXT2_FEATURE_RO_COMPAT_LARGE_FILE      0x0002  /* 64-bit filesize */
-#define EXT2_FEATURE_RO_COMPAT_BTREE_DIR       0x0004  /* binary tree sorted dir */
-
-/* Compression types (s_algo_bitmap) */
-#define EXT2_LZV1_ALG                  0x0001
-#define EXT2_LZRW3A_ALG                        0x0002
-#define EXT2_GZIP_ALG                  0x0004
-#define EXT2_BZIP2_ALG                 0x0008
-#define EXT2_LZO_ALG                   0x0010
-
-/* Defined Reserved inodes */
-#define EXT2_BAD_INO                   1               /* bad blocks inode */
-#define EXT2_ROOT_INO                  2               /* root directory inode */
-#define EXT2_ACL_IDX_INO               3               /* ACL index (deprecated?) */
-#define EXT2_ACL_DATA_INO              4               /* ACL data (deprecated?) */
-#define EXT2_BOOT_LOADER_INO   5               /* boot loader inode */
-#define EXT2_UNDEL_DIR_INO             6               /* undelete directory inode */
-
-/* Inode/File access mode and type (i_mode).  Note how they use hex here, but
-the crap we keep around for glibc/posix is (probably still) in octal. */
-#define EXT2_S_IFSOCK                  0xC000  /* socket */
-#define EXT2_S_IFLNK                   0xA000  /* symbolic link */
-#define EXT2_S_IFREG                   0x8000  /* regular file */
-#define EXT2_S_IFBLK                   0x6000  /* block device */
-#define EXT2_S_IFDIR                   0x4000  /* directory */
-#define EXT2_S_IFCHR                   0x2000  /* character device */
-#define EXT2_S_IFIFO                   0x1000  /* fifo */
-#define EXT2_S_ISUID                   0x0800  /* set process user id */
-#define EXT2_S_ISGID                   0x0400  /* set process group id */
-#define EXT2_S_ISVTX                   0x0200  /* sticky bit */
-#define EXT2_S_IRUSR                   0x0100  /* user read */
-#define EXT2_S_IWUSR                   0x0080  /* user write */
-#define EXT2_S_IXUSR                   0x0040  /* user execute */
-#define EXT2_S_IRGRP                   0x0020  /* group read */
-#define EXT2_S_IWGRP                   0x0010  /* group write */
-#define EXT2_S_IXGRP                   0x0008  /* group execute */
-#define EXT2_S_IROTH                   0x0004  /* others read */
-#define EXT2_S_IWOTH                   0x0002  /* others write */
-#define EXT2_S_IXOTH                   0x0001  /* others execute */
-
-/* Inode flags, for how to access data for an inode/file/object */
-#define EXT2_SECRM_FL                  0x00000001      /* secure deletion */
-#define EXT2_UNRM_FL                   0x00000002      /* record for undelete */
-#define EXT2_COMPR_FL                  0x00000004      /* compressed file */
-#define EXT2_SYNC_FL                   0x00000008      /* synchronous updates */
-#define EXT2_IMMUTABLE_FL              0x00000010      /* immutable file */
-#define EXT2_APPEND_FL                 0x00000020      /* append only */
-#define EXT2_NODUMP_FL                 0x00000040      /* do not dump/delete file */
-#define EXT2_NOATIME_FL                        0x00000080      /* do not update i_atime */
-/* Compression Flags */
-#define EXT2_DIRTY_FL                  0x00000100      /* dirty (modified) */
-#define EXT2_COMPRBLK_FL               0x00000200      /* compressed blocks */
-#define EXT2_NOCOMPR_FL                        0x00000400      /* access raw compressed data */
-#define EXT2_ECOMPR_FL                 0x00000800      /* compression error */
-/* End of compression flags */
-#define EXT2_BTREE_FL                  0x00010000      /* b-tree format directory */
-#define EXT2_INDEX_FL                  0x00010000      /* hash indexed directory */
-#define EXT2_IMAGIC_FL                 0x00020000      /* AFS directory */
-#define EXT3_JOURNAL_DATA_FL   0x00040000      /* journal file data */
-#define EXT2_RESERVED_FL               0x80000000      /* reserved for ext2 library */
-
-/* Directory entry file types */
-#define EXT2_FT_UNKNOWN                        0       /* unknown file type */
-#define EXT2_FT_REG_FILE               1       /* regular file */
-#define EXT2_FT_DIR                            2       /* directory */
-#define EXT2_FT_CHRDEV                 3       /* character device */
-#define EXT2_FT_BLKDEV                 4       /* block device */
-#define EXT2_FT_FIFO                   5       /* FIFO / buffer file */
-#define EXT2_FT_SOCK                   6       /* socket */
-#define EXT2_FT_SYMLINK                        7       /* symbolic link */
-
-struct ext2_sb {
-       uint32_t                                        s_inodes_cnt;           /* total, both used/free */
-       uint32_t                                        s_blocks_cnt;           /* used/free/reserved */
-       uint32_t                                        s_rblocks_cnt;          /* reserved for su/brho */
-       uint32_t                                        s_free_blocks_cnt;      /* free, incl reserved */
-       uint32_t                                        s_free_inodes_cnt;
-       uint32_t                                        s_first_data_block;     /* id of block holding sb */
-       uint32_t                                        s_log_block_size;
-       uint32_t                                        s_log_frag_size;        /* no real frag support */
-       uint32_t                                        s_blocks_per_group;
-       uint32_t                                        s_frags_per_group;
-       uint32_t                                        s_inodes_per_group;
-       uint32_t                                        s_mtime;                        /* last mount time */
-       uint32_t                                        s_wtime;                        /* last write to the FS */
-       uint16_t                                        s_mnt_cnt;                      /* mounts since fsck */
-       uint16_t                                        s_max_mnt_cnt;          /* mounts between fscks */
-       uint16_t                                        s_magic;
-       uint16_t                                        s_state;                        /* mount state */
-       uint16_t                                        s_errors;                       /* what to do on error */
-       uint16_t                                        s_minor_rev_level;
-       uint32_t                                        s_lastcheck;            /* last fsck */
-       uint32_t                                        s_checkinterval;        /* max time btw fscks */
-       uint32_t                                        s_creator_os;
-       uint32_t                                        s_rev_level;
-       uint16_t                                        s_def_resuid;           /* uid for reserved blocks*/
-       uint16_t                                        s_def_resgid;           /* gid for reserved blocks*/
-/* Next chunk, EXT2_DYNAMIC_REV specific */
-       uint32_t                                        s_first_ino;            /* first usable for F_REG */
-       uint16_t                                        s_inode_size;
-       uint16_t                                        s_block_group_nr;       /* BG holding *this* SB */
-       uint32_t                                        s_feature_compat;
-       uint32_t                                        s_feature_incompat;
-       uint32_t                                        s_feature_ro_compat;
-       uint64_t                                        s_uuid[2];                      /* volume id */
-       char                                            s_volume_name[16];      /* null terminated */
-       char                                            s_last_mounted[64];     /* dir path of mount */
-       uint32_t                                        s_algo_bitmap;          /* compression type */
-/* Next chunk, Performance Hints */
-       uint8_t                                         s_prealloc_blocks;      /* when making F_REG */
-       uint8_t                                         s_prealloc_dir_blocks;  /* when making F_DIR */
-       uint16_t                                        s_padding1;
-/* Next chunk, Journaling Support */
-       uint8_t                                         s_journal_uuid[16];
-       uint32_t                                        s_journal_inum;         /* ino of the journal file*/
-       uint32_t                                        s_journal_dev;          /* device num of journal */
-       uint32_t                                        s_last_orphan;          /* first in list to delete*/
-/* Next chunk, Directory Indexing Support */
-       uint32_t                                        s_hash_seed[4];         /* for directory indexing */
-       uint8_t                                         s_def_hash_version;     /* default */
-       uint8_t                                         s_padding2;
-       uint16_t                                        s_padding3;
-/* Next chunk, Other options */
-       uint32_t                                        s_default_mount_opts;
-       uint32_t                                        s_first_meta_bg;        /* BG id of first meta */
-       uint8_t                                         s_reserved[760];
-};
-
-/* All block ids are absolute (not relative to the BG). */
-struct ext2_block_group {
-       uint32_t                                        bg_block_bitmap;        /* block id of bitmap */
-       uint32_t                                        bg_inode_bitmap;        /* block id of bitmap */
-       uint32_t                                        bg_inode_table;         /* id of first block */
-       uint16_t                                        bg_free_blocks_cnt;
-       uint16_t                                        bg_free_inodes_cnt;
-       uint16_t                                        bg_used_dirs_cnt;       /* inodes alloc to dirs */
-       uint16_t                                        bg_padding;
-       uint8_t                                         bg_reserved[12];
-};
-
-/* Random note: expect some number of the initial inodes to be reserved (11 in
- * rev 0), and later versions just start from s_first_ino.
- *
- * Only regular files use the full 32bits of size.  Rev 0 uses a signed i_size.
- *
- * For the i_blocks, the first 12 are block numbers for direct blocks.  The
- * 13th entry ([12]) is the block number for the first indirect block.  The
- * 14th entry is the number for a doubly-indirect block, and the 15th is a
- * triply indirect block. Having a value of 0 in the array terminates it, with
- * no further blocks. (not clear how that works with holes)
- *
- * For the osd2[12], these should be unused for ext2, and they should be used
- * differently for ext4.
- *
- * Giant warning: the inode numbers start at 1 in the system, not 0! */
-struct ext2_inode {
-       uint16_t                                        i_mode;                         /* file type and mode */
-       uint16_t                                        i_uid;
-       uint32_t                                        i_size;                         /* lower 32bits of size */
-       uint32_t                                        i_atime;
-       uint32_t                                        i_ctime;
-       uint32_t                                        i_mtime;
-       uint32_t                                        i_dtime;                        /* delete time */
-       uint16_t                                        i_gid;
-       uint16_t                                        i_links_cnt;            /* fs_ino->i_nlink */
-       uint32_t                                        i_blocks;                       /* num blocks reserved */
-       uint32_t                                        i_flags;                        /* how to access data */
-       uint32_t                                        i_osd1;                         /* OS dependent */
-       uint32_t                                        i_block[15];            /* list of blocks reserved*/
-       uint32_t                                        i_generation;           /* used by NFS */
-       uint32_t                                        i_file_acl;                     /* block num hold ext attr*/
-       uint32_t                                        i_dir_acl;                      /* upper 32bits of size */
-       uint32_t                                        i_faddr;                        /* fragment, obsolete. */
-       uint8_t                                         i_osd2[12];                     /* OS dependent */
-};
-
-/* a dir_inode of 0 means an unused entry.  reclen will go to the end of the
- * data block when it is the last entry.  These are 4-byte aligned on disk. */
-struct ext2_dirent {
-       uint32_t                                        dir_inode;                      /* inode */
-       uint16_t                                        dir_reclen;                     /* len, including padding */
-       uint8_t                                         dir_namelen;            /* len of dir_name w/o \0 */
-       uint8_t                                         dir_filetype;
-       uint8_t                                         dir_name[256];          /* might be < 255 on disc */
-};
-
-/* Every FS must extern it's type, and be included in vfs_init() */
-extern struct fs_type ext2_fs_type;
-
-/* This hangs off the VFS's SB, and tracks in-memory copies of the disc SB and
- * the block group descriptor table.  For now, s_dirty (VFS) will track the
- * dirtiness of all things hanging off the sb.  Both of the objects contained
- * are kmalloc()d, as is this struct. */
-struct ext2_sb_info {
-       struct ext2_sb                          *e2sb;
-       struct ext2_block_group         *e2bg;
-       unsigned int                            nr_bgs;
-};
-
-/* Inode in-memory data.  This stuff is in cpu-native endianness.  If we start
- * using the data in the actual inode and in the buffer cache, change
- * ext2_my_bh() and its two callers.  Assume this data is dirty. */
-struct ext2_i_info {
-       uint32_t                                        i_block[15];            /* list of blocks reserved*/
-};
index 6e37ffc..46315f8 100644 (file)
@@ -41,7 +41,6 @@ obj-y                                         += env.o
 obj-y                                          += err.o
 obj-$(CONFIG_ETH_AUDIO)                += eth_audio.o
 obj-y                                          += event.o
-obj-y                                          += ext2fs.o
 obj-y                                          += ex_table.o
 obj-y                                          += fdtap.o
 obj-$(CONFIG_COREALLOC_FCFS) += corealloc_fcfs.o
index 434051b..a16f83b 100644 (file)
@@ -28,29 +28,6 @@ void block_init(void)
                                      sizeof(struct buffer_head),
                                      __alignof__(struct buffer_head), 0,
                                      NULL, 0, 0, NULL);
-
-       #ifdef CONFIG_EXT2FS
-       /* Now probe for and init the block device for the ext2 ram disk */
-       extern uint8_t _binary_mnt_ext2fs_img_size[];
-       extern uint8_t _binary_mnt_ext2fs_img_start[];
-       /* Build and init the block device */
-       struct block_device *ram_bd = kmalloc(sizeof(struct block_device), 0);
-       memset(ram_bd, 0, sizeof(struct block_device));
-       ram_bd->b_id = 31337;
-       ram_bd->b_sector_sz = 512;
-       ram_bd->b_nr_sector = (unsigned long)_binary_mnt_ext2fs_img_size / 512;
-       kref_init(&ram_bd->b_kref, fake_release, 1);
-       pm_init(&ram_bd->b_pm, &block_pm_op, ram_bd);
-       ram_bd->b_data = _binary_mnt_ext2fs_img_start;
-       strlcpy(ram_bd->b_name, "RAMDISK", BDEV_INLINE_NAME);
-       /* Connect it to the file system */
-       struct file *ram_bf = make_device("/dev_vfs/ramdisk", S_IRUSR | S_IWUSR,
-                                         __S_IFBLK, &block_f_op);
-       /* make sure the inode tracks the right pm (not it's internal one) */
-       ram_bf->f_dentry->d_inode->i_mapping = &ram_bd->b_pm;
-       ram_bf->f_dentry->d_inode->i_bdev = ram_bd;     /* this holds the bd kref */
-       kref_put(&ram_bf->f_kref);
-       #endif /* CONFIG_EXT2FS */
 }
 
 /* Generic helper, returns a kref'd reference out of principle. */
diff --git a/kern/src/ext2fs.c b/kern/src/ext2fs.c
deleted file mode 100644 (file)
index ed221ab..0000000
+++ /dev/null
@@ -1,1537 +0,0 @@
-/* Copyright (c) 2010 The Regents of the University of California
- * Barret Rhoden <brho@cs.berkeley.edu>
- * See LICENSE for details.
- *
- * Ext2, VFS required functions, internal functions, life, the universe, and
- * everything! */
-
-#include <vfs.h>
-#include <ext2fs.h>
-#include <blockdev.h>
-#include <kmalloc.h>
-#include <assert.h>
-#include <kref.h>
-#include <endian.h>
-#include <error.h>
-#include <pmap.h>
-#include <bitmask.h>
-
-/* These structs are declared again and initialized farther down */
-struct page_map_operations ext2_pm_op;
-struct super_operations ext2_s_op;
-struct inode_operations ext2_i_op;
-struct dentry_operations ext2_d_op;
-struct file_operations ext2_f_op_file;
-struct file_operations ext2_f_op_dir;
-struct file_operations ext2_f_op_sym;
-
-/* EXT2 Internal Functions */
-
-/* Useful helper functions. */
-
-/* Returns the block group ID of the BG containing the inode.  BGs start with 0,
- * inodes are indexed starting at 1. */
-static struct ext2_block_group *ext2_inode2bg(struct inode *inode)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
-       unsigned int bg_num = (inode->i_ino - 1) /
-                             le32_to_cpu(e2sbi->e2sb->s_inodes_per_group);
-       return &e2sbi->e2bg[bg_num];
-}
-
-/* This returns the inode's 0-index within a block group */
-static unsigned int ext2_inode2bgidx(struct inode *inode)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
-       return (inode->i_ino - 1) % le32_to_cpu(e2sbi->e2sb->s_inodes_per_group);
-}
-
-/* Returns the inode number given a 0-index of an inode within a block group */
-static unsigned long ext2_bgidx2ino(struct super_block *sb,
-                                    struct ext2_block_group *bg,
-                                    unsigned int ino_idx)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
-       struct ext2_sb *e2sb = e2sbi->e2sb;
-       struct ext2_block_group *e2bg = e2sbi->e2bg;
-       return (bg - e2bg) * le32_to_cpu(e2sb->s_inodes_per_group) + ino_idx + 1;
-}
-
-/* Returns an uncounted reference to the BG in the BG table, which is pinned,
- * hanging off the sb.  Note, the BGs cover the blocks starting from the first
- * data block, not from 0.  So if the FDB is 1, BG 0 covers 1 through 1024, and
- * not 0 through 1023. */
-static struct ext2_block_group *ext2_block2bg(struct super_block *sb,
-                                              uint32_t blk_num)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
-       unsigned int bg_num;
-       bg_num = (blk_num - le32_to_cpu(e2sbi->e2sb->s_first_data_block)) /
-                le32_to_cpu(e2sbi->e2sb->s_blocks_per_group);
-       return &e2sbi->e2bg[bg_num];
-}
-
-/* This returns the block's 0-index within a block group.  Note all blocks are
- * offset by FDB when dealing with BG membership. */
-static unsigned int ext2_block2bgidx(struct super_block *sb, uint32_t blk_num)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
-       return (blk_num - le32_to_cpu(e2sbi->e2sb->s_first_data_block)) %
-              le32_to_cpu(e2sbi->e2sb->s_blocks_per_group);
-}
-
-/* Returns the FS block for the given BG's idx block */
-static uint32_t ext2_bgidx2block(struct super_block *sb,
-                                 struct ext2_block_group *bg,
-                                 unsigned int blk_idx)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
-       struct ext2_sb *e2sb = e2sbi->e2sb;
-       struct ext2_block_group *e2bg = e2sbi->e2bg;
-       return (bg - e2bg) * le32_to_cpu(e2sb->s_blocks_per_group) + blk_idx +
-              le32_to_cpu(e2sb->s_first_data_block);
-}
-
-/* Slabs for ext2 specific info chunks */
-struct kmem_cache *ext2_i_kcache;
-
-/* One-time init for all ext2 instances */
-void ext2_init(void)
-{
-       ext2_i_kcache = kmem_cache_create("ext2_i_info",
-                                         sizeof(struct ext2_i_info),
-                                         __alignof__(struct ext2_i_info), 0,
-                                         NULL, 0, 0, NULL);
-}
-
-/* Block management */
-
-/* TODO: pull these metablock functions out of ext2 */
-/* Makes sure the FS block of metadata is in memory.  This returns a pointer to
- * the beginning of the requested block.  Release it with put_metablock().
- * Internally, the kreffing is done on the page. */
-void *__ext2_get_metablock(struct block_device *bdev, unsigned long blk_num,
-                           unsigned int blk_sz)
-{
-       return bdev_get_buffer(bdev, blk_num, blk_sz)->bh_buffer;
-}
-
-/* Convenience wrapper */
-void *ext2_get_metablock(struct super_block *sb, unsigned long block_num)
-{
-       return __ext2_get_metablock(sb->s_bdev, block_num, sb->s_blocksize);
-}
-
-/* Helper to figure out the BH for any address within it's buffer */
-static struct buffer_head *ext2_my_bh(struct super_block *sb, void *addr)
-{
-       struct page *page = kva2page(addr);
-       struct buffer_head *bh = (struct buffer_head*)page->pg_private;
-       /* This case is for when we try do decref a non-BH'd 'metablock'.  It's tied
-        * to e2ii->i_block[]. */
-       if (!bh)
-               return 0;
-       void *my_buf = (void*)ROUNDDOWN((uintptr_t)addr, sb->s_blocksize);
-       while (bh) {
-               if (bh->bh_buffer == my_buf)
-                       break;
-               bh = bh->bh_next;
-       }
-       assert(bh && bh->bh_buffer == my_buf);
-       return bh;
-}
-
-/* Decrefs the buffer from get_metablock().  Call this when you no longer
- * reference your metadata block/buffer.  Yes, we could just decref the page,
- * but this will work if we end up changing how bdev_put_buffer() works. */
-void ext2_put_metablock(struct super_block *sb, void *buffer)
-{
-       struct buffer_head *bh = ext2_my_bh(sb, buffer);
-       if (bh)
-               bdev_put_buffer(bh);
-}
-
-/* Will dirty the block/BH/page for the given metadata block/buffer. */
-void ext2_dirty_metablock(struct super_block *sb, void *buffer)
-{
-       struct buffer_head *bh = ext2_my_bh(sb, buffer);
-       if (bh)
-               bdev_dirty_buffer(bh);
-}
-
-/* Helper for alloc_block.  It will try to alloc a block from the BG, starting
- * with blk_idx (relative number within the BG).   If successful, it will return
- * the FS block number via *block_num.  TODO: concurrency protection */
-static bool ext2_tryalloc(struct super_block *sb, struct ext2_block_group *bg,
-                          unsigned int blk_idx, uint32_t *block_num)
-{
-       uint8_t *blk_bitmap;
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
-       unsigned int blks_per_bg = le32_to_cpu(e2sbi->e2sb->s_blocks_per_group);
-       bool found = FALSE;
-
-       /* Check to see if there are any free blocks */
-       if (!le32_to_cpu(bg->bg_free_blocks_cnt))
-               return FALSE;
-       /* Check the bitmap for your desired block.  We'll loop through the whole
-        * BG, starting with the one we want first. */
-       blk_bitmap = ext2_get_metablock(sb, bg->bg_block_bitmap);
-       for (int i = 0; i < blks_per_bg; i++) {
-               if (!(GET_BITMASK_BIT(blk_bitmap, blk_idx))) {
-                       SET_BITMASK_BIT(blk_bitmap, blk_idx);
-                       bg->bg_free_blocks_cnt--;
-                       ext2_dirty_metablock(sb, blk_bitmap);
-                       found = TRUE;
-                       break;
-               }
-               /* Note: the wrap-around hasn't been tested yet */
-               blk_idx = (blk_idx + 1) % blks_per_bg;
-       }
-       ext2_put_metablock(sb, blk_bitmap);
-       if (found)
-               *block_num = ext2_bgidx2block(sb, bg, blk_idx);
-       return found;
-}
-
-/* This allocates a fresh block for the inode, preferably 'fetish' (name
- * courtesy of L.F.), returning the FS block number that's been allocated.
- * Note, Linux does some block preallocation here.  Consider doing the same (off
- * the in-memory inode).  Note the lack of concurrency protections here. */
-uint32_t ext2_alloc_block(struct inode *inode, uint32_t fetish)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
-       struct ext2_block_group *fetish_bg, *bg_i = e2sbi->e2bg;
-       unsigned int blk_idx;
-       bool found = FALSE;
-       uint32_t retval = 0;
-
-       /* Get our ideal starting point */
-       fetish_bg = ext2_block2bg(inode->i_sb, fetish);
-       blk_idx = ext2_block2bgidx(inode->i_sb, fetish);
-       /* Try to find a free block in the BG of the one we desire */
-       found = ext2_tryalloc(inode->i_sb, fetish_bg, blk_idx, &retval);
-       if (found)
-               return retval;
-
-       warn("This part hasn't been tested yet.");
-       /* Find a block anywhere else (perhaps using the log trick, but for now just
-        * linearly scanning). */
-       for (int i = 0; i < e2sbi->nr_bgs; i++, bg_i++) {
-               if (bg_i == fetish_bg)
-                       continue;
-               found = ext2_tryalloc(inode->i_sb, bg_i, 0, &retval);
-               if (found)
-                       break;
-       }
-       if (!found)
-               panic("Ran out of blocks! (probably a bug)");
-       return retval;
-}
-
-/* Inode Management */
-
-/* Helper for alloc_diskinode.  It will try to alloc a disk inode from the BG.
- * If successful, it will return the inode number in *ino_num.  TODO:
- * concurrency protection */
-static bool ext2_tryalloc_diskinode(struct super_block *sb,
-                                    struct ext2_block_group *bg,
-                                    unsigned long *ino_num)
-{
-       uint8_t *ino_bitmap;
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)sb->s_fs_info;
-       unsigned int i, ino_per_bg = le32_to_cpu(e2sbi->e2sb->s_inodes_per_group);
-       bool found = FALSE;
-
-       /* Check to see if there are any free inodes */
-       if (!le32_to_cpu(bg->bg_free_inodes_cnt))
-               return FALSE;
-       /* Check the bitmap for the free inode */
-       ino_bitmap = ext2_get_metablock(sb, bg->bg_inode_bitmap);
-       for (i = 0; i < ino_per_bg; i++) {
-               if (!(GET_BITMASK_BIT(ino_bitmap, i))) {
-                       SET_BITMASK_BIT(ino_bitmap, i);
-                       bg->bg_free_inodes_cnt--;
-                       ext2_dirty_metablock(sb, ino_bitmap);
-                       found = TRUE;
-                       break;
-               }
-       }
-       ext2_put_metablock(sb, ino_bitmap);
-       /* Convert the i (a 0-index bit)  within the BG to a real inode number. */
-       if (found)
-               *ino_num = ext2_bgidx2ino(sb, bg, i);
-       return found;
-}
-
-/* This allocates a fresh ino number for inode, given the parent's BG.  Make
- * sure you set the inode's type before calling this, since it matters if we a
- * making a directory or not.  This disk inode is reserved on disk in the bitmap
- * (at least the bitmap is changed and dirtied).  Note the lack of concurrency
- * protections here.  Consider returning the BG too. */
-unsigned long ext2_alloc_diskinode(struct inode *inode,
-                                   struct ext2_block_group *dir_bg)
-{
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
-       struct ext2_block_group *bg = dir_bg;
-       struct ext2_block_group *bg_i = e2sbi->e2bg;
-       bool found = FALSE;
-       unsigned long retval = 0;
-
-       if (S_ISDIR(inode->i_mode)) {
-               /* TODO: intelligently pick a different bg to use than the current one.
-                * Right now, we just jump to the next one, though you should do things
-                * like take into account the ratio of directories to files. */
-               bg += 1;
-       }
-       /* Try to find a free inode in the chosen BG */
-       found = ext2_tryalloc_diskinode(inode->i_sb, bg, &retval);
-       if (found)
-               return retval;
-
-       warn("This part hasn't been tested yet.");
-       /* Find an inode anywhere else (perhaps using the log trick, but for now just
-        * linearly scanning). */
-       for (int i = 0; i < e2sbi->nr_bgs; i++, bg_i++) {
-               if (bg_i == bg)
-                       continue;
-               found = ext2_tryalloc_diskinode(inode->i_sb, bg_i, &retval);
-               if (found)
-                       break;
-       }
-       if (!found)
-               panic("Ran out of inodes! (probably a bug)");
-       return retval;
-}
-
-/* Helper for ino table management.  blkid is the inode table block we are
- * looking in, rel_blkid is the block we want, relative to the current
- * threshhold for a level of indirection, and reach is how many items a given
- * slot indexes.  Returns a pointer to the slot for the given block. */
-static uint32_t *ext2_find_inotable_slot(struct inode *inode, uint32_t blkid,
-                                         uint32_t rel_blkid,
-                                         unsigned int reach)
-{
-       uint32_t *blk_buf = ext2_get_metablock(inode->i_sb, blkid);
-       assert(blk_buf);
-       return &blk_buf[rel_blkid / reach];
-}
-
-/* If blk_slot is empty (no block mapped there) it will alloc and link a new
- * block.  This is only used for allocating a block to be an indirect table
- * (it's grabbing a metablock, we have no hint, and it handles the buffer
- * differently than for a file page/buffer). */
-static void ext2_fill_inotable_slot(struct inode *inode, uint32_t *blk_slot)
-{
-       uint32_t new_blkid, hint_blk;
-       void *new_blk;
-
-       if (le32_to_cpu(*blk_slot))
-               return;
-       /* Use any block in our inode's BG as a hint for the indirect block */
-       hint_blk = ext2_bgidx2block(inode->i_sb, ext2_inode2bg(inode), 0);
-       new_blkid = ext2_alloc_block(inode, hint_blk);
-       /* Actually read in the block we alloc'd */
-       new_blk = ext2_get_metablock(inode->i_sb, new_blkid);
-       memset(new_blk, 0, inode->i_sb->s_blocksize);
-       ext2_dirty_metablock(inode->i_sb, new_blk);
-       /* We put it, despite it getting relooked up in the next walk */
-       ext2_put_metablock(inode->i_sb, new_blk);
-       /* Now write the new block into its slot */
-       *blk_slot = cpu_to_le32(new_blkid);
-       ext2_dirty_metablock(inode->i_sb, blk_slot);
-}
-
-/* This walks a table stored at block 'blkid', returning which block you should
- * walk next in 'blkid'.  rel_inoblk is where you are given the current level of
- * indirection tables, and returns where you should be for the next one.  Reach
- * is how many items the current table's *items* can index (so if we're on a
- * 3x indir block, reach should be for the doubly-indirect entries, and
- * rel_inoblk will tell you where within that double block you want).
- *
- * This will also alloc intermediate tables if there isn't one already (TODO:
- * concurrency protection on modifying the table). */
-static void ext2_walk_inotable(struct inode *inode, uint32_t *blkid,
-                               uint32_t *rel_inoblk, unsigned int reach)
-{
-       uint32_t *blk_slot;
-       blk_slot = ext2_find_inotable_slot(inode, *blkid, *rel_inoblk, reach);
-       /* We could only do this based on a bool, but if we're trying to walk it,
-        * we ought to want to alloc if there is no block. */
-       ext2_fill_inotable_slot(inode, blk_slot);
-       *blkid = le32_to_cpu(*blk_slot);
-       *rel_inoblk = *rel_inoblk % reach;
-       ext2_put_metablock(inode->i_sb, blk_slot);      /* ref for the one looked in */
-}
-
-/* Finds the slot of the FS block corresponding to a specific block number of an
- * inode.  It does this by walking the inode's tables.  The general idea is that
- * if the ino_block num is above a threshold, we'll need to go into indirect
- * tables (1x, 2x, or 3x (triply indirect) tables).  Block numbers start at 0.
- *
- * This returns a pointer within a metablock, which needs to be decref'd (and
- * possibly dirtied) when you are done.  Note, it can return a pointer to
- * something that is NOT in a metablock (e2ii->i_block[]), but put_metablock can
- * handle it for now.
- *
- * Horrendously untested, btw. */
-uint32_t *ext2_lookup_inotable_slot(struct inode *inode, uint32_t ino_block)
-{
-       struct ext2_i_info *e2ii = (struct ext2_i_info*)inode->i_fs_info;
-
-       uint32_t blkid, *blk_slot;
-       /* The 'reach' is how many blocks a given table can 'address' */
-       int ptrs_per_blk = inode->i_sb->s_blocksize / sizeof(uint32_t);
-       int reach_1xblk = ptrs_per_blk;
-       int reach_2xblk = ptrs_per_blk * ptrs_per_blk;
-       /* thresholds are the first blocks that require a level of indirection */
-       int single_threshold = 12;
-       int double_threshold = single_threshold + reach_1xblk;
-       int triple_threshold = double_threshold + reach_2xblk;
-       /* this is the desired block num lookup within a level of indirection.  It
-        * will need to be offset based on what level of lookups we want (try it in
-        * your head with 12 first). */
-       uint32_t rel_inoblk;
-
-       if (ino_block >= triple_threshold) {
-               /* ino_block requires a triply-indirect lookup */
-               rel_inoblk = ino_block - triple_threshold;
-               /* Make sure a 14 block (3x indirect) is there */
-               ext2_fill_inotable_slot(inode, &e2ii->i_block[14]);
-               blkid = e2ii->i_block[14];
-               ext2_walk_inotable(inode, &blkid, &rel_inoblk, reach_2xblk);
-               ext2_walk_inotable(inode, &blkid, &rel_inoblk, reach_1xblk);
-               blk_slot = ext2_find_inotable_slot(inode, blkid, rel_inoblk, 1);
-       } else if (ino_block >= double_threshold) {
-               /* ino_block requires a doubly-indirect lookup  */
-               rel_inoblk = ino_block - double_threshold;
-               ext2_fill_inotable_slot(inode, &e2ii->i_block[13]);
-               blkid = e2ii->i_block[13];
-               ext2_walk_inotable(inode, &blkid, &rel_inoblk, reach_1xblk);
-               blk_slot = ext2_find_inotable_slot(inode, blkid, rel_inoblk, 1);
-       } else if (ino_block >= single_threshold) {
-               /* ino_block requires a singly-indirect lookup */
-               rel_inoblk = ino_block - single_threshold;
-               ext2_fill_inotable_slot(inode, &e2ii->i_block[12]);
-               blkid = e2ii->i_block[12];
-               blk_slot = ext2_find_inotable_slot(inode, blkid, rel_inoblk, 1);
-       } else {
-               /* Direct block, straight out of the inode */
-               blk_slot = &e2ii->i_block[ino_block];
-       }
-       return blk_slot;
-}
-
-/* Determines the FS block id for a given inode block id.  Convenience wrapper
- * that may go away soon. */
-uint32_t ext2_find_inoblock(struct inode *inode, unsigned int ino_block)
-{
-       uint32_t retval, *buf = ext2_lookup_inotable_slot(inode, ino_block);
-       retval = *buf;
-       ext2_put_metablock(inode->i_sb, buf);
-       return retval;
-}
-
-/* Returns an incref'd metadata block for the contents of the ino block.  Don't
- * use this for regular files - use their inode's page cache instead (used for
- * directories for now).  If there isn't a block allocated yet, it will provide
- * a zeroed one. */
-void *ext2_get_ino_metablock(struct inode *inode, unsigned long ino_block)
-{
-       uint32_t blkid, *retval, *blk_slot;
-       blk_slot = ext2_lookup_inotable_slot(inode, ino_block);
-       blkid = le32_to_cpu(*blk_slot);
-       if (blkid) {
-               ext2_put_metablock(inode->i_sb, blk_slot);
-               return ext2_get_metablock(inode->i_sb, blkid);
-       }
-       /* If there isn't a block there, alloc and insert one.  This block will be
-        * the next big chunk of "file" data for this inode. */
-       blkid = ext2_alloc_block(inode, ext2_bgidx2block(inode->i_sb,
-                                                        ext2_inode2bg(inode),
-                                                        0));
-       *blk_slot = cpu_to_le32(blkid);
-       ext2_dirty_metablock(inode->i_sb, blk_slot);
-       ext2_put_metablock(inode->i_sb, blk_slot);
-       inode->i_blocks += inode->i_sb->s_blocksize >> 9;       /* inc by 1 FS block */
-       inode->i_size += inode->i_sb->s_blocksize;
-       retval = ext2_get_metablock(inode->i_sb, blkid);
-       memset(retval, 0, inode->i_sb->s_blocksize);            /* 0 the new block */
-       return retval;
-}
-
-/* This should help with degubbing.  In read_inode(), print out the i_block, and
- * consider manually (via memory inspection) examining those blocks.  Odds are,
- * the 2x and 3x walks are jacked up. */
-void ext2_print_ino_blocks(struct inode *inode)
-{
-       printk("Inode %p, Size: %d, 512B 'blocks': %d\n-------------\n", inode,
-              inode->i_size, inode->i_blocks);
-       for (int i = 0; i < inode->i_blocks * (inode->i_sb->s_blocksize / 512); i++)
-               printk("# %03d, Block %03d\n", i, ext2_find_inoblock(inode, i));
-}
-
-/* Misc Functions */
-
-/* This checks an ext2 disc SB for consistency, optionally printing out its
- * stats.  It also will also read in a copy of the block group descriptor table
- * from its first location (right after the primary SB copy) */
-void ext2_check_sb(struct ext2_sb *e2sb, struct ext2_block_group *bg,
-                   bool print)
-{
-       int retval;
-       unsigned int blksize, blks_per_group, num_blk_group, num_blks;
-       unsigned int inodes_per_grp, inode_size;
-       unsigned int sum_blks = 0, sum_inodes = 0;
-
-       assert(le16_to_cpu(e2sb->s_magic) == EXT2_SUPER_MAGIC);
-       num_blks = le32_to_cpu(e2sb->s_blocks_cnt);
-       blksize = 1024 << le32_to_cpu(e2sb->s_log_block_size);
-       blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
-       num_blk_group = num_blks / blks_per_group + (num_blks % blks_per_group ? 1 : 0);
-
-       if (print) {
-               printk("EXT2 info:\n-------------------------\n");
-               printk("Total Inodes:     %8d\n", le32_to_cpu(e2sb->s_inodes_cnt));
-               printk("Total Blocks:     %8d\n", le32_to_cpu(e2sb->s_blocks_cnt));
-               printk("Num R-Blocks:     %8d\n", le32_to_cpu(e2sb->s_rblocks_cnt));
-               printk("Num Free Blocks:  %8d\n", le32_to_cpu(e2sb->s_free_blocks_cnt));
-               printk("Num Free Inodes:  %8d\n", le32_to_cpu(e2sb->s_free_inodes_cnt));
-               printk("First Data Block: %8d\n",
-                      le32_to_cpu(e2sb->s_first_data_block));
-               printk("Block Size:       %8d\n",
-                      1024 << le32_to_cpu(e2sb->s_log_block_size));
-               printk("Fragment Size:    %8d\n",
-                      1024 << le32_to_cpu(e2sb->s_log_frag_size));
-               printk("Blocks per group: %8d\n",
-                      le32_to_cpu(e2sb->s_blocks_per_group));
-               printk("Inodes per group: %8d\n",
-                      le32_to_cpu(e2sb->s_inodes_per_group));
-               printk("Block groups:     %8d\n", num_blk_group);
-               printk("Mount state:      %8d\n", le16_to_cpu(e2sb->s_state));
-               printk("Rev Level:        %8d\n", le32_to_cpu(e2sb->s_minor_rev_level));
-               printk("Minor Rev Level:  %8d\n", le16_to_cpu(e2sb->s_minor_rev_level));
-               printk("Creator OS:       %8d\n", le32_to_cpu(e2sb->s_creator_os));
-               printk("First Inode:      %8d\n", le32_to_cpu(e2sb->s_first_ino));
-               printk("Inode size:       %8d\n", le16_to_cpu(e2sb->s_inode_size));
-               printk("This block group: %8d\n", le16_to_cpu(e2sb->s_block_group_nr));
-               printk("BG ID of 1st meta:%8d\n", le16_to_cpu(e2sb->s_first_meta_bg));
-               printk("Volume name:      %s\n", e2sb->s_volume_name);
-               printk("\nBlock Group Info:\n----------------------\n");
-       }
-
-       for (int i = 0; i < num_blk_group; i++) {
-               sum_blks += le16_to_cpu(bg[i].bg_free_blocks_cnt);
-               sum_inodes += le16_to_cpu(bg[i].bg_free_inodes_cnt);
-               if (print) {
-                       printk("*** BG %d at %p\n", i, &bg[i]);
-                       printk("Block bitmap:%8d\n", le32_to_cpu(bg[i].bg_block_bitmap));
-                       printk("Inode bitmap:%8d\n", le32_to_cpu(bg[i].bg_inode_bitmap));
-                       printk("Inode table: %8d\n", le32_to_cpu(bg[i].bg_inode_table));
-                       printk("Free blocks: %8d\n", le16_to_cpu(bg[i].bg_free_blocks_cnt));
-                       printk("Free inodes: %8d\n", le16_to_cpu(bg[i].bg_free_inodes_cnt));
-                       printk("Used Dirs:   %8d\n", le16_to_cpu(bg[i].bg_used_dirs_cnt));
-               }
-       }
-
-       /* Sanity Assertions.  A good ext2 will always pass these. */
-       inodes_per_grp = le32_to_cpu(e2sb->s_inodes_per_group);
-       blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
-       inode_size = le32_to_cpu(e2sb->s_inode_size);
-       assert(le32_to_cpu(e2sb->s_inodes_cnt) <= inodes_per_grp * num_blk_group);
-       assert(le32_to_cpu(e2sb->s_free_inodes_cnt) == sum_inodes);
-       assert(le32_to_cpu(e2sb->s_blocks_cnt) <= blks_per_group * num_blk_group);
-       assert(le32_to_cpu(e2sb->s_free_blocks_cnt) == sum_blks);
-       if (blksize == 1024)
-               assert(le32_to_cpu(e2sb->s_first_data_block) == 1);
-       else
-               assert(le32_to_cpu(e2sb->s_first_data_block) == 0);
-       assert(inode_size <= blksize);
-       assert(inode_size == 1 << LOG2_UP(inode_size));
-       assert(blksize * 8 >= inodes_per_grp);
-       assert(inodes_per_grp % (blksize / inode_size) == 0);
-       if (print)
-               printk("Passed EXT2 Checks\n");
-}
-
-/* VFS required Misc Functions */
-
-/* Creates the SB.  Like with Ext2's, we should consider pulling out the
- * FS-independent stuff, if possible. */
-struct super_block *ext2_get_sb(struct fs_type *fs, int flags,
-                               char *dev_name, struct vfsmount *vmnt)
-{
-       struct block_device *bdev;
-       struct ext2_sb *e2sb;
-       struct ext2_block_group *e2bg;
-       unsigned int blks_per_group, num_blk_group, num_blks;
-
-       static bool ran_once = FALSE;
-       if (!ran_once) {
-               ran_once = TRUE;
-               ext2_init();
-       }
-       bdev = get_bdev(dev_name);
-       assert(bdev);
-       /* Read the SB.  It's always at byte 1024 and 1024 bytes long.  Note we do
-        * not put the metablock (we pin it off the sb later).  Same with e2bg. */
-       e2sb = (struct ext2_sb*)__ext2_get_metablock(bdev, 1, 1024);
-       if (!(le16_to_cpu(e2sb->s_magic) == EXT2_SUPER_MAGIC)) {
-               warn("EXT2 Not detected when it was expected!");
-               return 0;
-       }
-       /* Read in the block group descriptor table.  Which block the BG table is on
-        * depends on the blocksize */
-       unsigned int blksize = 1024 << le32_to_cpu(e2sb->s_log_block_size);
-       e2bg = __ext2_get_metablock(bdev, blksize == 1024 ? 2 : 1, blksize);
-       assert(e2bg);
-       ext2_check_sb(e2sb, e2bg, FALSE);
-
-       /* Now we build and init the VFS SB */
-       struct super_block *sb = get_sb();
-       sb->s_dev = 0;                  /* what do we really want here? */
-       sb->s_blocksize = blksize;
-       /* max file size for a 1024 blocksize FS.  good enough for now (TODO) */
-       sb->s_maxbytes = 17247252480;
-       sb->s_type = &ext2_fs_type;
-       sb->s_op = &ext2_s_op;
-       sb->s_flags = flags;    /* from the disc too?  which flags are these? */
-       sb->s_magic = EXT2_SUPER_MAGIC;
-       sb->s_mount = vmnt;     /* Kref?  also in KFS */
-       sb->s_syncing = FALSE;
-       kref_get(&bdev->b_kref, 1);
-       sb->s_bdev = bdev;
-       strlcpy(sb->s_name, "EXT2", 32);
-       sb->s_fs_info = kmalloc(sizeof(struct ext2_sb_info), 0);
-       assert(sb->s_fs_info);
-       /* store the in-memory copy of the disk SB and bg desc table */
-       ((struct ext2_sb_info*)sb->s_fs_info)->e2sb = e2sb;
-       ((struct ext2_sb_info*)sb->s_fs_info)->e2bg = e2bg;
-       /* Precompute the number of BGs */
-       num_blks = le32_to_cpu(e2sb->s_blocks_cnt);
-       blks_per_group = le32_to_cpu(e2sb->s_blocks_per_group);
-       ((struct ext2_sb_info*)sb->s_fs_info)->nr_bgs = num_blks / blks_per_group +
-                                              (num_blks % blks_per_group ? 1 : 0);
-
-       /* Final stages of initializing the sb, mostly FS-independent */
-       init_sb(sb, vmnt, &ext2_d_op, EXT2_ROOT_INO, 0);
-
-       printk("EXT2 superblock loaded\n");
-       kref_put(&bdev->b_kref);
-       return sb;
-}
-
-void ext2_kill_sb(struct super_block *sb)
-{
-       /* don't forget to kfree the s_fs_info and its two members */
-       panic("Killing an EXT2 SB is not supported!");
-}
-
-/* Every FS must have a static FS Type, with which the VFS code can bootstrap */
-struct fs_type ext2_fs_type = {"EXT2", 0, ext2_get_sb, ext2_kill_sb, {0, 0},
-                               TAILQ_HEAD_INITIALIZER(ext2_fs_type.fs_supers)};
-
-/* Page Map Operations */
-
-/* Sets up the bidirectional mapping between the page and its buffer heads.  As
- * a future optimization, we could try and detect if all of the blocks are
- * contiguous (either before or after making them) and compact them to one BH.
- * Note there is an assumption that the file has at least one block in it. */
-int ext2_mappage(struct page_map *pm, struct page *page)
-{
-       struct buffer_head *bh;
-       struct inode *inode = (struct inode*)pm->pm_host;
-       assert(!page->pg_private);              /* double check that we aren't bh-mapped */
-       assert(inode->i_mapping == pm); /* double check we are the inode for pm */
-       struct block_device *bdev = inode->i_sb->s_bdev;
-       unsigned int blk_per_pg = PGSIZE / inode->i_sb->s_blocksize;
-       unsigned int sct_per_blk = inode->i_sb->s_blocksize / bdev->b_sector_sz;
-       uint32_t ino_blk_num, fs_blk_num = 0, *fs_blk_slot;
-
-       bh = kmem_cache_alloc(bh_kcache, 0);
-       page->pg_private = bh;
-       for (int i = 0; i < blk_per_pg; i++) {
-               /* free_bh() can handle having a halfway aborted mappage() */
-               if (!bh)
-                       return -ENOMEM;
-               bh->bh_page = page;                                                     /* weak ref */
-               bh->bh_buffer = page2kva(page) + i * inode->i_sb->s_blocksize;
-               bh->bh_flags = 0;                                                       /* whatever... */
-               bh->bh_bdev = bdev;                                                     /* uncounted ref */
-               /* compute the first sector of the FS block for the ith buf in the pg */
-               ino_blk_num = page->pg_index * blk_per_pg + i;
-               fs_blk_slot = ext2_lookup_inotable_slot(inode, ino_blk_num);
-               /* If there isn't a block there, lets get one.  The previous fs_blk_num
-                * is our hint (or we have to compute one). */
-               if (!*fs_blk_slot) {
-                       if (!fs_blk_num) {
-                               fs_blk_num = ext2_bgidx2block(inode->i_sb,
-                                                             ext2_inode2bg(inode), 0);
-                       }
-                       fs_blk_num = ext2_alloc_block(inode, fs_blk_num + 1);
-                       /* Link it, and dirty the inode indirect block */
-                       *fs_blk_slot = cpu_to_le32(fs_blk_num);
-                       ext2_dirty_metablock(inode->i_sb, fs_blk_slot);
-                       /* the block is still on disk, and we don't want its contents */
-                       bh->bh_flags = BH_NEEDS_ZEROED;                 /* talking to readpage */
-                       /* update our num blocks, with 512B each "block" (ext2-style) */
-                       inode->i_blocks += inode->i_sb->s_blocksize >> 9;
-               } else {        /* there is a block there already */
-                       fs_blk_num = *fs_blk_slot;
-               }
-               ext2_put_metablock(inode->i_sb, fs_blk_slot);
-               bh->bh_sector = fs_blk_num * sct_per_blk;
-               bh->bh_nr_sector = sct_per_blk;
-               /* Stop if we're the last block in the page.  We could be going beyond
-                * the end of the file, in which case the next BHs will be zeroed. */
-               if (i == blk_per_pg - 1) {
-                       bh->bh_next = 0;
-                       break;
-               } else {
-                       /* get and link to the next BH. */
-                       bh->bh_next = kmem_cache_alloc(bh_kcache, 0);
-                       bh = bh->bh_next;
-               }
-       }
-       return 0;
-}
-
-/* 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.  TODO: make this a block FS generic call. */
-int ext2_readpage(struct page_map *pm, struct page *page)
-{
-       int retval;
-       struct block_device *bdev = pm->pm_host->i_sb->s_bdev;
-       struct buffer_head *bh;
-       struct block_request *breq;
-       void *eobh;
-
-       atomic_or(&page->pg_flags, PG_BUFFER);
-       retval = ext2_mappage(pm, page);
-       if (retval)
-               return retval;
-       /* Build and submit the request */
-       breq = kmem_cache_alloc(breq_kcache, 0);
-       if (!breq)
-               return -ENOMEM;
-       breq->flags = BREQ_READ;
-       breq->callback = generic_breq_done;
-       breq->data = 0;
-       sem_init_irqsave(&breq->sem, 0);
-       breq->bhs = breq->local_bhs;
-       breq->nr_bhs = 0;
-       /* Pack the BH pointers in the block request */
-       bh = (struct buffer_head*)page->pg_private;
-       assert(bh);
-       /* Either read the block in, or zero the buffer.  If we wanted to ensure no
-        * data is leaked after a crash, we'd write a 0 block too. */
-       for (int i = 0; bh; bh = bh->bh_next) {
-               if (!(bh->bh_flags & BH_NEEDS_ZEROED)) {
-                       breq->bhs[i] = bh;
-                       breq->nr_bhs++;
-                       i++;
-               } else {
-                       memset(bh->bh_buffer, 0, pm->pm_host->i_sb->s_blocksize);
-                       bh->bh_flags |= BH_DIRTY;
-                       atomic_or(&bh->bh_page->pg_flags, PG_DIRTY);
-               }
-       }
-       retval = bdev_submit_request(bdev, breq);
-       assert(!retval);
-       sleep_on_breq(breq);
-       kmem_cache_free(breq_kcache, breq);
-       /* zero out whatever is beyond the EOF.  we could do this by figuring out
-        * where the BHs end and zeroing from there, but I'd rather zero from where
-        * the file ends (which could be in the middle of an FS block */
-       uintptr_t eof_off;
-       eof_off = (pm->pm_host->i_size - page->pg_index * PGSIZE);
-       eof_off = MIN(eof_off, PGSIZE) % PGSIZE;
-       /* at this point, eof_off is the offset into the page of the EOF, or 0 */
-       if (eof_off)
-               memset(eof_off + page2kva(page), 0, PGSIZE - eof_off);
-       /* Now the page is up to date */
-       atomic_or(&page->pg_flags, PG_UPTODATE);
-       /* Useful debugging.  Put one higher up if the page is not getting mapped */
-       //print_pageinfo(page);
-       return 0;
-}
-
-int ext2_writepage(struct page_map *pm, struct page *page)
-{
-       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 *ext2_alloc_inode(struct super_block *sb)
-{
-       struct inode *inode = kmem_cache_alloc(inode_kcache, 0);
-       memset(inode, 0, sizeof(struct inode));
-       inode->i_op = &ext2_i_op;
-       inode->i_pm.pm_op = &ext2_pm_op;
-       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 ext2_dealloc_inode(struct inode *inode)
-{
-       kmem_cache_free(ext2_i_kcache, inode->i_fs_info);
-}
-
-/* Returns a pointer within a metablock for the disk inode specified by inode.
- * Be sure to 'put' your reference (and/or dirty it). */
-struct ext2_inode *ext2_get_diskinode(struct inode *inode)
-{
-       uint32_t my_bg_idx, ino_per_blk, my_ino_blk;
-       struct ext2_sb_info *e2sbi = (struct ext2_sb_info*)inode->i_sb->s_fs_info;
-       struct ext2_block_group *my_bg;
-       struct ext2_inode *ino_tbl_chunk;
-
-       assert(inode->i_ino);                                   /* ino == 0 is a bug */
-       /* Need to compute the blockgroup and index of the requested inode */
-       ino_per_blk = inode->i_sb->s_blocksize /
-                     le16_to_cpu(e2sbi->e2sb->s_inode_size);
-       my_bg_idx = ext2_inode2bgidx(inode);
-       my_bg = ext2_inode2bg(inode);
-       /* Figure out which FS block of the inode table we want and read in that
-        * chunk */
-       my_ino_blk = le32_to_cpu(my_bg->bg_inode_table) + my_bg_idx / ino_per_blk;
-       ino_tbl_chunk = ext2_get_metablock(inode->i_sb, my_ino_blk);
-       return &ino_tbl_chunk[my_bg_idx % ino_per_blk];
-}
-
-/* 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 ext2_read_inode(struct inode *inode)
-{
-       struct ext2_inode *my_ino;
-       my_ino = ext2_get_diskinode(inode);
-
-       /* Have the disk inode now, let's put its info into the VFS inode: */
-       inode->i_mode = le16_to_cpu(my_ino->i_mode);
-       switch (inode->i_mode & __S_IFMT) {
-               case (__S_IFDIR):
-                       inode->i_fop = &ext2_f_op_dir;
-                       break;
-               case (__S_IFREG):
-                       inode->i_fop = &ext2_f_op_file;
-                       break;
-               case (__S_IFLNK):
-                       inode->i_fop = &ext2_f_op_sym;
-                       break;
-               case (__S_IFCHR):
-               case (__S_IFBLK):
-               default:
-                       inode->i_fop = &ext2_f_op_file;
-                       warn("[Calm British Accent] Look around you.  Unhandled filetype.");
-       }
-       inode->i_nlink = le16_to_cpu(my_ino->i_links_cnt);
-       inode->i_uid = le16_to_cpu(my_ino->i_uid);
-       inode->i_gid = le16_to_cpu(my_ino->i_gid);
-       /* technically, for large F_REG, we should | with i_dir_acl */
-       inode->i_size = le32_to_cpu(my_ino->i_size);
-       inode->i_atime.tv_sec = le32_to_cpu(my_ino->i_atime);
-       inode->i_atime.tv_nsec = 0;
-       inode->i_mtime.tv_sec = le32_to_cpu(my_ino->i_mtime);
-       inode->i_mtime.tv_nsec = 0;
-       inode->i_ctime.tv_sec = le32_to_cpu(my_ino->i_ctime);
-       inode->i_ctime.tv_nsec = 0;
-       inode->i_blocks = le32_to_cpu(my_ino->i_blocks);
-       inode->i_flags = le32_to_cpu(my_ino->i_flags);
-       inode->i_socket = FALSE;                /* for now */
-       /* Copy over the other inode stuff that isn't in the VFS inode.  For now,
-        * it's just the block pointers */
-       inode->i_fs_info = kmem_cache_alloc(ext2_i_kcache, 0);
-       struct ext2_i_info *e2ii = (struct ext2_i_info*)inode->i_fs_info;
-       for (int i = 0; i < 15; i++)
-               e2ii->i_block[i] = le32_to_cpu(my_ino->i_block[i]);
-       /* TODO: (HASH) unused: inode->i_hash add to hash (saves on disc reading) */
-       /* TODO: we could consider saving a pointer to the disk inode and pinning
-        * its buffer in memory, but for now we'll just free it. */
-       ext2_put_metablock(inode->i_sb, my_ino);
-}
-
-/* called when an inode in memory is modified (journalling FS's care) */
-void ext2_dirty_inode(struct inode *inode)
-{
-       // presumably we'll ext2_dirty_metablock(void *buffer) here
-}
-
-/* write the inode to disk (specifically, to inode inode->i_ino), synchronously
- * if we're asked to wait */
-void ext2_write_inode(struct inode *inode, bool wait)
-{
-I_AM_HERE;
-}
-
-/* called when an inode is decref'd, to do any FS specific work */
-void ext2_put_inode(struct inode *inode)
-{
-I_AM_HERE;
-}
-
-/* Unused for now, will get rid of this if inode_release is sufficient */
-void ext2_drop_inode(struct inode *inode)
-{
-I_AM_HERE;
-}
-
-/* delete the inode from disk (all data) */
-void ext2_delete_inode(struct inode *inode)
-{
-I_AM_HERE;
-       // would remove from "disk" here
-       /* TODO: give up our i_ino */
-}
-
-/* unmount and release the super block */
-void ext2_put_super(struct super_block *sb)
-{
-       panic("Shazbot! Ext2 can't be unmounted yet!");
-}
-
-/* updates the on-disk SB with the in-memory SB */
-void ext2_write_super(struct super_block *sb)
-{
-I_AM_HERE;
-}
-
-/* syncs FS metadata with the disc, synchronously if we're waiting.  this info
- * also includes anything pointed to by s_fs_info. */
-int ext2_sync_fs(struct super_block *sb, bool wait)
-{
-I_AM_HERE;
-       return 0;
-}
-
-/* remount the FS with the new flags */
-int ext2_remount_fs(struct super_block *sb, int flags, char *data)
-{
-       warn("Ext2 will not remount.");
-       return -1; // can't remount
-}
-
-/* interrupts a mount operation - used by NFS and friends */
-void ext2_umount_begin(struct super_block *sb)
-{
-       panic("Cannot abort a Ext2 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 ext2_init_inode(struct inode *dir, struct dentry *dentry)
-{
-#if 0
-       struct inode *inode = dentry->d_inode;
-       inode->i_ino = ext2_get_free_ino();
-#endif
-}
-
-/* Initializes a new/empty disk inode, according to inode.  If you end up not
- * zeroing this stuff, be careful of endianness. */
-static void ext2_init_diskinode(struct ext2_inode *e2i, struct inode *inode)
-{
-       assert(inode->i_size == 0);
-       e2i->i_mode = cpu_to_le16(inode->i_mode);
-       e2i->i_uid = cpu_to_le16(inode->i_uid);
-       e2i->i_size = 0;
-       e2i->i_atime = cpu_to_le32(inode->i_atime.tv_sec);
-       e2i->i_ctime = cpu_to_le32(inode->i_ctime.tv_sec);
-       e2i->i_mtime = cpu_to_le32(inode->i_mtime.tv_sec);
-       e2i->i_dtime = 0;
-       e2i->i_gid = cpu_to_le16(inode->i_gid);
-       e2i->i_links_cnt = cpu_to_le16(inode->i_nlink);
-       e2i->i_blocks = 0;
-       e2i->i_flags = cpu_to_le32(inode->i_flags);
-       e2i->i_osd1 = 0;
-       e2i->i_generation = 0;
-       e2i->i_file_acl = 0;
-       e2i->i_dir_acl = 0;
-       e2i->i_faddr = 0;
-       for (int i = 0; i < 15; i++)
-               e2i->i_block[i] = 0;
-       for (int i = 0; i < 12; i++)
-               e2i->i_osd2[i] = 0;
-}
-
-/* These should return true if foreach_dirent should stop working on the
- * dirents. */
-typedef bool (*each_func_t) (struct ext2_dirent *dir_i, long a1, long a2,
-                             long a3);
-
-/* Loads the buffer and performs my_work on each dirent, stopping and returning
- * 0 if one of the calls succeeded, or returning the dir block num of what would
- * be the next dir block otherwise (aka, how many blocks we went through). */
-static uint32_t ext2_foreach_dirent(struct inode *dir, each_func_t my_work,
-                                    long a1, long a2, long a3)
-{
-       struct ext2_dirent *dir_buf, *dir_i;
-       uint32_t dir_block = 0;
-       dir_buf = ext2_get_ino_metablock(dir, dir_block++);
-       dir_i = dir_buf;
-       /* now we have the first block worth of dirents.  We'll get another block if
-        * dir_i hits a block boundary */
-       for (unsigned int bytes = 0; bytes < dir->i_size; ) {
-               /* On subsequent loops, we might need to advance to the next block.
-                * This is where a file abstraction for a dir might be easier. */
-               if ((void*)dir_i >= (void*)dir_buf + dir->i_sb->s_blocksize) {
-                       ext2_put_metablock(dir->i_sb, dir_buf);
-                       dir_buf = ext2_get_ino_metablock(dir, dir_block++);
-                       dir_i = dir_buf;
-                       assert(dir_buf);
-               }
-               if (my_work(dir_i, a1, a2, a3)) {
-                       ext2_put_metablock(dir->i_sb, dir_buf);
-                       return 0;
-               }
-               /* Get ready for the next loop */
-               bytes += dir_i->dir_reclen;
-               dir_i = (void*)dir_i + dir_i->dir_reclen;
-       }
-       ext2_put_metablock(dir->i_sb, dir_buf);
-       return dir_block;
-}
-
-/* Returns the actual length of a dirent, not just how far to the next entry.
- * If there is no inode, the entry is unused, and it has no length (as far as
- * users of this should care). */
-static unsigned int ext2_dirent_len(struct ext2_dirent *e2dir)
-{
-       /* arguably, we don't need the le32_to_cpu */
-       if (le32_to_cpu(e2dir->dir_inode))
-               return ROUNDUP(e2dir->dir_namelen + 8, 4);              /* no such le8_to_cpu */
-       else
-               return 0;
-}
-
-/* Helper for writing the contents of a dentry to a disk dirent. Zeroes the
- * contents of the dirent so that we don't write random data to disk. */
-static void ext2_write_dirent(struct ext2_dirent *e2dir, struct dentry *dentry,
-                              unsigned int rec_len)
-{
-       memset(e2dir, 0, sizeof(*e2dir));
-       e2dir->dir_inode = cpu_to_le32(dentry->d_inode->i_ino);
-       e2dir->dir_reclen = cpu_to_le16(rec_len);
-       e2dir->dir_namelen = dentry->d_name.len;
-       switch (dentry->d_inode->i_mode & __S_IFMT) {
-               case (__S_IFDIR):
-                       e2dir->dir_filetype = EXT2_FT_DIR;
-                       break;
-               case (__S_IFREG):
-                       e2dir->dir_filetype = EXT2_FT_REG_FILE;
-                       break;
-               case (__S_IFLNK):
-                       e2dir->dir_filetype = EXT2_FT_SYMLINK;
-                       break;
-               case (__S_IFCHR):
-                       e2dir->dir_filetype = EXT2_FT_CHRDEV;
-                       break;
-               case (__S_IFBLK):
-                       e2dir->dir_filetype = EXT2_FT_BLKDEV;
-                       break;
-               case (__S_IFSOCK):
-                       e2dir->dir_filetype = EXT2_FT_SOCK;
-                       break;
-               default:
-                       warn("[Calm British Accent] Look around you: Unknown filetype.");
-                       e2dir->dir_filetype = EXT2_FT_UNKNOWN;
-       }
-       assert(dentry->d_name.len <= 255);
-       strlcpy((char*)e2dir->dir_name, dentry->d_name.name,
-               sizeof(e2dir->dir_name));
-}
-
-/* Helper for ext2_create().  This tries to squeeze a dirent in the slack space
- * after an existing dirent, returning TRUE if it succeeded (to break out). */
-static bool create_each_func(struct ext2_dirent *dir_i, long a1, long a2,
-                             long a3)
-{
-       struct dentry *dentry = (struct dentry*)a1;
-       unsigned int our_rec_len = (unsigned int)a2;
-       unsigned int mode = (unsigned int)a3;
-       struct ext2_dirent *dir_new;
-       unsigned int real_len = ext2_dirent_len(dir_i);
-       /* How much room is available after this dir_i before the next one */
-       unsigned int record_slack = le16_to_cpu(dir_i->dir_reclen) - real_len;
-       /* TODO: Note that this technique will clobber any directory indexing.  They
-        * exist after the .. entry with an inode of 0.  Check the docs for
-        * specifics and think up a nice way to tell the diff between a reserved
-        * entry and an unused one, when inode == 0. */
-       if (record_slack < our_rec_len)
-               return FALSE;
-       /* At this point, there is enough room for us.  Stick our new one in right
-        * after the real len, making sure our reclen goes to the old end.  Note
-        * that it is possible to have a real_len of 0 (an unused entry).  In this
-        * case, we just end up taking over the spot in the dir_blk.  Be sure to set
-        * dir_i's reclen before dir_new's (in case they are the same). */
-       dir_new = ((void*)dir_i + real_len);
-       dir_i->dir_reclen = cpu_to_le16(real_len);
-       ext2_write_dirent(dir_new, dentry, record_slack);
-       ext2_dirty_metablock(dentry->d_sb, dir_new);
-       return TRUE;
-}
-
-/* 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 ext2_create(struct inode *dir, struct dentry *dentry, int mode,
-               struct nameidata *nd)
-{
-       struct inode *inode = dentry->d_inode;
-       struct ext2_block_group *dir_bg = ext2_inode2bg(dir);
-       struct ext2_inode *disk_inode;
-       struct ext2_i_info *e2ii;
-       uint32_t dir_block;
-       unsigned int our_rec_len;
-       struct ext2_dirent *new_dirent;
-       /* Set basic inode stuff for files, get a disk inode, etc */
-       SET_FTYPE(inode->i_mode, __S_IFREG);
-       inode->i_fop = &ext2_f_op_file;
-       inode->i_ino = ext2_alloc_diskinode(inode, dir_bg);
-       /* Initialize disk inode (this will be different for short symlinks) */
-       disk_inode = ext2_get_diskinode(inode);
-       ext2_init_diskinode(disk_inode, inode);
-       /* Initialize the e2ii (might get rid of this cache of block info) */
-       inode->i_fs_info = kmem_cache_alloc(ext2_i_kcache, 0);
-       e2ii = (struct ext2_i_info*)inode->i_fs_info;
-       for (int i = 0; i < 15; i++)
-               e2ii->i_block[i] = le32_to_cpu(disk_inode->i_block[i]);
-       /* Dirty and put the disk inode */
-       ext2_dirty_metablock(dentry->d_sb, disk_inode);
-       ext2_put_metablock(dentry->d_sb, disk_inode);
-       /* Insert it in the directory (make a dirent, might expand the dir too) */
-       /* Note the disk dir_name is not null terminated */
-       our_rec_len = ROUNDUP(8 + dentry->d_name.len, 4);
-       assert(our_rec_len <= 8 + 256);
-       /* Consider caching the start point for future dirent ops.  Or even using
-        * the indexed directory.... */
-       dir_block = ext2_foreach_dirent(dir, create_each_func, (long)dentry,
-                                       (long)our_rec_len, (long)mode);
-       /* If this returned a block number, we didn't find room in any of the
-        * existing directory blocks, so we need to make a new one, stick it in the
-        * dir inode, and stick our dirent at the beginning.  The reclen is the
-        * whole blocksize (since it's the last entry in this block) */
-       if (dir_block) {
-               new_dirent = ext2_get_ino_metablock(dir, dir_block);
-               ext2_write_dirent(new_dirent, dentry, dentry->d_sb->s_blocksize);
-               ext2_dirty_metablock(dentry->d_sb, new_dirent);
-               ext2_put_metablock(dentry->d_sb, new_dirent);
-       }
-       return 0;
-}
-
-/* If we match, this loads the inode for the dentry and returns true (so we
- * break out) */
-static bool lookup_each_func(struct ext2_dirent *dir_i, long a1, long a2,
-                             long a3)
-{
-       struct dentry *dentry = (struct dentry*)a1;
-       /* Test if we're the one (TODO: use d_compare).  Note, dir_name is not
-        * null terminated, hence the && test. */
-       if (!strncmp((char*)dir_i->dir_name, dentry->d_name.name,
-                    dir_i->dir_namelen) &&
-                   (dentry->d_name.name[dir_i->dir_namelen] == '\0')) {
-               load_inode(dentry, (long)le32_to_cpu(dir_i->dir_inode));
-               /* TODO: (HASH) add dentry to dcache (maybe the caller should) */
-               return TRUE;
-       }
-       return FALSE;
-}
-
-/* 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 (which might be the same as the one you passed in).
- * If this fails, it will return 0, but not free the memory of "dentry."
- *
- * Callers, make sure you alloc and fill out the name parts of the dentry.  We
- * don't currently use the ND.  Might remove it in the future.  */
-struct dentry *ext2_lookup(struct inode *dir, struct dentry *dentry,
-                           struct nameidata *nd)
-{
-       assert(S_ISDIR(dir->i_mode));
-       struct ext2_dirent *dir_buf, *dir_i;
-       if (!ext2_foreach_dirent(dir, lookup_each_func, (long)dentry, 0, 0))
-               return dentry;
-       printd("EXT2: 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 ext2_link(struct dentry *old_dentry, struct inode *dir,
-             struct dentry *new_dentry)
-{
-I_AM_HERE;
-       assert(new_dentry->d_op = &ext2_d_op);
-       return 0;
-}
-
-/* Removes the link from the dentry in the directory */
-int ext2_unlink(struct inode *dir, struct dentry *dentry)
-{
-I_AM_HERE;
-       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 ext2_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
-{
-I_AM_HERE;
-       #if 0
-       struct inode *inode = dentry->d_inode;
-       SET_FTYPE(inode->i_mode, __S_IFLNK);
-       inode->i_fop = &ext2_f_op_sym;
-       strlcpy(string, symname, len + 1);
-       #endif
-       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 ext2_mkdir(struct inode *dir, struct dentry *dentry, int mode)
-{
-I_AM_HERE;
-       #if 0
-       struct inode *inode = dentry->d_inode;
-       inode->i_ino = ext2_get_free_ino();
-       SET_FTYPE(inode->i_mode, __S_IFDIR);
-       inode->i_fop = &ext2_f_op_dir;
-       #endif
-       return 0;
-}
-
-/* Removes from dir the directory 'dentry.'  Ext2 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 ext2_rmdir(struct inode *dir, struct dentry *dentry)
-{
-I_AM_HERE;
-       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 ext2_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
-{
-I_AM_HERE;
-       return -1;
-}
-
-/* Moves old_dentry from old_dir to new_dentry in new_dir */
-int ext2_rename(struct inode *old_dir, struct dentry *old_dentry,
-               struct inode *new_dir, struct dentry *new_dentry)
-{
-I_AM_HERE;
-       return -1;
-}
-
-/* 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 *ext2_readlink(struct dentry *dentry)
-{
-I_AM_HERE;
-       struct inode *inode = dentry->d_inode;
-       if (!S_ISLNK(inode->i_mode))
-               return 0;
-       return 0;
-}
-
-/* Modifies the size of the file of inode to whatever its i_size is set to */
-void ext2_truncate(struct inode *inode)
-{
-}
-
-/* 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 ext2_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 ext2_d_revalidate(struct dentry *dir, struct nameidata *nd)
-{ // default, nothing
-       return -1;
-}
-
-/* Compares name1 and name2.  name1 should be a member of dir. */
-int ext2_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 ext2_d_delete(struct dentry *dentry)
-{ // default, nothin
-       return -1;
-}
-
-/* Called when it's about to be slab-freed */
-int ext2_d_release(struct dentry *dentry)
-{
-       return -1;
-}
-
-/* Called when the dentry loses it's inode (becomes "negative") */
-void ext2_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, and putting this in the
- * VFS. */
-#include <syscall.h>   /* just for set_errno, may go away later */
-int ext2_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.  Like with
- * read and write, there will be issues with userspace and the *dirent buf.
- * TODO: (UMEM) */
-int ext2_readdir(struct file *dir, struct kdirent *dirent)
-{
-       void *blk_buf;
-       /* Not enough data at the end of the directory */
-       if (dir->f_dentry->d_inode->i_size < dirent->d_off + 8)
-               return -ENOENT;
-       /* Figure out which block we need to read in for dirent->d_off */
-       int block = dirent->d_off / dir->f_dentry->d_sb->s_blocksize;
-       blk_buf = ext2_get_ino_metablock(dir->f_dentry->d_inode, block);
-       assert(blk_buf);
-       off64_t f_off = dirent->d_off % dir->f_dentry->d_sb->s_blocksize;
-       /* Copy out the dirent info */
-       struct ext2_dirent *e2dir = (struct ext2_dirent*)(blk_buf + f_off);
-       dirent->d_ino = le32_to_cpu(e2dir->dir_inode);
-       dirent->d_off += le16_to_cpu(e2dir->dir_reclen);
-       if (dir->f_dentry->d_inode->i_size < dirent->d_off)
-               panic("Something is jacked with the dirent going beyond the dir/file");
-       /* note, dir_namelen doesn't include the \0 */
-       dirent->d_reclen = e2dir->dir_namelen;
-       assert(e2dir->dir_namelen <= MAX_FILENAME_SZ);
-       strlcpy(dirent->d_name, (char*)e2dir->dir_name, e2dir->dir_namelen + 1);
-       ext2_put_metablock(dir->f_dentry->d_sb, blk_buf);
-
-       /* At the end of the directory, sort of.  ext2 often preallocates blocks, so
-        * this will cause us to walk along til the end, which isn't quite right. */
-       if (dir->f_dentry->d_inode->i_size == dirent->d_off)
-               return 0;
-       if (dir->f_dentry->d_inode->i_size < dirent->d_off) {
-               warn("Issues reaching the end of an ext2 directory!");
-               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 ext2_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 ext2_open(struct inode *inode, struct file *file)
-{
-       /* TODO: check to make sure the file is openable, and maybe do some checks
-        * for the open mode (like did we want to truncate, append, etc) */
-       return 0;
-}
-
-/* Called when a file descriptor is closed. */
-int ext2_flush(struct file *file)
-{
-I_AM_HERE;
-       return -1;
-}
-
-/* Called when the file is about to be closed (file obj freed) */
-int ext2_release(struct inode *inode, struct file *file)
-{
-       return 0;
-}
-
-/* Flushes the file's dirty contents to disc */
-int ext2_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 ext2_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 ext2_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 ext2_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 ext2_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 ext2_check_flags(int flags)
-{ // default, nothing
-       return -1;
-}
-
-/* Redeclaration and initialization of the FS ops structures */
-struct page_map_operations ext2_pm_op = {
-       ext2_readpage,
-       ext2_writepage,
-};
-
-struct super_operations ext2_s_op = {
-       ext2_alloc_inode,
-       ext2_dealloc_inode,
-       ext2_read_inode,
-       ext2_dirty_inode,
-       ext2_write_inode,
-       ext2_put_inode,
-       ext2_drop_inode,
-       ext2_delete_inode,
-       ext2_put_super,
-       ext2_write_super,
-       ext2_sync_fs,
-       ext2_remount_fs,
-       ext2_umount_begin,
-};
-
-struct inode_operations ext2_i_op = {
-       ext2_create,
-       ext2_lookup,
-       ext2_link,
-       ext2_unlink,
-       ext2_symlink,
-       ext2_mkdir,
-       ext2_rmdir,
-       ext2_mknod,
-       ext2_rename,
-       ext2_readlink,
-       ext2_truncate,
-       ext2_permission,
-};
-
-struct dentry_operations ext2_d_op = {
-       ext2_d_revalidate,
-       generic_dentry_hash,
-       ext2_d_compare,
-       ext2_d_delete,
-       ext2_d_release,
-       ext2_d_iput,
-};
-
-struct file_operations ext2_f_op_file = {
-       ext2_llseek,
-       generic_file_read,
-       generic_file_write,
-       ext2_readdir,
-       ext2_mmap,
-       ext2_open,
-       ext2_flush,
-       ext2_release,
-       ext2_fsync,
-       ext2_poll,
-       ext2_readv,
-       ext2_writev,
-       ext2_sendpage,
-       ext2_check_flags,
-};
-
-struct file_operations ext2_f_op_dir = {
-       ext2_llseek,
-       generic_dir_read,
-       0,
-       ext2_readdir,
-       ext2_mmap,
-       ext2_open,
-       ext2_flush,
-       ext2_release,
-       ext2_fsync,
-       ext2_poll,
-       ext2_readv,
-       ext2_writev,
-       ext2_sendpage,
-       ext2_check_flags,
-};
-
-struct file_operations ext2_f_op_sym = {
-       ext2_llseek,
-       generic_file_read,
-       generic_file_write,
-       ext2_readdir,
-       ext2_mmap,
-       ext2_open,
-       ext2_flush,
-       ext2_release,
-       ext2_fsync,
-       ext2_poll,
-       ext2_readv,
-       ext2_writev,
-       ext2_sendpage,
-       ext2_check_flags,
-};
index 1304f28..62bfdff 100644 (file)
@@ -37,7 +37,6 @@
 #include <vfs.h>
 #include <devfs.h>
 #include <blockdev.h>
-#include <ext2fs.h>
 #include <kthread.h>
 #include <linker_func.h>
 #include <net/ip.h>
@@ -170,9 +169,6 @@ static void __kernel_init_part_deux(void *arg)
        devtabreset();
        devtabinit();
 
-#ifdef CONFIG_EXT2FS
-       mount_fs(&ext2_fs_type, "/dev_vfs/ramdisk", "/mnt", 0);
-#endif /* CONFIG_EXT2FS */
 #ifdef CONFIG_ETH_AUDIO
        eth_audio_init();
 #endif /* CONFIG_ETH_AUDIO */
index 6fe67c9..f704a2e 100644 (file)
@@ -13,7 +13,6 @@
 #include <slab.h>
 #include <kmalloc.h>
 #include <kfs.h>
-#include <ext2fs.h>
 #include <pmap.h>
 #include <umem.h>
 #include <smp.h>
@@ -131,9 +130,6 @@ 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);
-#ifdef CONFIG_EXT2FS
-       TAILQ_INSERT_TAIL(&file_systems, &ext2_fs_type, list);
-#endif
        TAILQ_FOREACH(fs, &file_systems, list)
                printk("Supports the %s Filesystem\n", fs->name);