- fs/ext3/Makefile | 18
- fs/ext3/super.c | 1779 +++++++++++++++++++++++++++++++++++++++++++++++++++++
- include/linux/fs.h | 1680 ++++++++++++++++++++++++++++++++++++++++++++++++++
- kernel/ksyms.c | 632 ++++++++++++++++++
- 4 files changed, 4109 insertions(+)
---- /dev/null Fri Aug 30 17:31:37 2002
-+++ linux-rh-2.4.20-6-braam/fs/ext3/Makefile Mon Mar 31 23:43:54 2003
-@@ -0,0 +1,18 @@
-+#
-+# Makefile for the linux ext2-filesystem routines.
-+#
-+# Note! Dependencies are done automagically by 'make dep', which also
-+# removes any old dependencies. DON'T put your own dependencies here
-+# unless it's something special (ie not a .c file).
-+#
-+# Note 2! The CFLAGS definitions are now in the main makefile...
-+
-+O_TARGET := ext3.o
-+
+
+
+ fs/ext3/Makefile | 2 ++
+ fs/ext3/super.c | 2 +-
+ include/linux/fs.h | 1 +
+ kernel/ksyms.c | 4 ++++
+ 4 files changed, 8 insertions(+), 1 deletion(-)
+
+--- linux-2.4.20-hp4_pnnl1/fs/ext3/Makefile~exports_hp Tue Apr 1 20:36:07 2003
++++ linux-2.4.20-hp4_pnnl1-braam/fs/ext3/Makefile Tue Apr 1 20:36:07 2003
+@@ -9,6 +9,8 @@
+
+ O_TARGET := ext3.o
+
+export-objs := super.o
+
-+obj-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
-+ ioctl.o namei.o super.o symlink.o
-+obj-m := $(O_TARGET)
-+
-+include $(TOPDIR)/Rules.make
---- /dev/null Fri Aug 30 17:31:37 2002
-+++ linux-rh-2.4.20-6-braam/fs/ext3/super.c Mon Mar 31 23:43:54 2003
-@@ -0,0 +1,1779 @@
-+/*
-+ * linux/fs/ext3/super.c
-+ *
-+ * Copyright (C) 1992, 1993, 1994, 1995
-+ * Remy Card (card@masi.ibp.fr)
-+ * Laboratoire MASI - Institut Blaise Pascal
-+ * Universite Pierre et Marie Curie (Paris VI)
-+ *
-+ * from
-+ *
-+ * linux/fs/minix/inode.c
-+ *
-+ * Copyright (C) 1991, 1992 Linus Torvalds
-+ *
-+ * Big-endian to little-endian byte-swapping/bitmaps by
-+ * David S. Miller (davem@caip.rutgers.edu), 1995
-+ */
-+
-+#include <linux/config.h>
-+#include <linux/module.h>
-+#include <linux/string.h>
-+#include <linux/fs.h>
-+#include <linux/sched.h>
-+#include <linux/jbd.h>
-+#include <linux/ext3_fs.h>
-+#include <linux/ext3_jbd.h>
-+#include <linux/slab.h>
-+#include <linux/init.h>
-+#include <linux/locks.h>
-+#include <linux/blkdev.h>
-+#include <linux/smp_lock.h>
-+#include <linux/random.h>
-+#include <asm/uaccess.h>
-+
-+#ifdef CONFIG_JBD_DEBUG
-+static int ext3_ro_after; /* Make fs read-only after this many jiffies */
-+#endif
-+
-+static int ext3_load_journal(struct super_block *, struct ext3_super_block *);
-+static int ext3_create_journal(struct super_block *, struct ext3_super_block *,
-+ int);
-+static void ext3_commit_super (struct super_block * sb,
-+ struct ext3_super_block * es,
-+ int sync);
-+static void ext3_mark_recovery_complete(struct super_block * sb,
-+ struct ext3_super_block * es);
-+static void ext3_clear_journal_err(struct super_block * sb,
-+ struct ext3_super_block * es);
-+
-+static int ext3_sync_fs(struct super_block * sb);
-+
-+#ifdef CONFIG_JBD_DEBUG
-+int journal_no_write[2];
-+
-+/*
-+ * Debug code for turning filesystems "read-only" after a specified
-+ * amount of time. This is for crash/recovery testing.
-+ */
-+
-+static void make_rdonly(kdev_t dev, int *no_write)
-+{
-+ if (dev) {
-+ printk(KERN_WARNING "Turning device %s read-only\n",
-+ bdevname(dev));
-+ *no_write = 0xdead0000 + dev;
-+ }
-+}
-+
-+static void turn_fs_readonly(unsigned long arg)
-+{
-+ struct super_block *sb = (struct super_block *)arg;
-+
-+ make_rdonly(sb->s_dev, &journal_no_write[0]);
-+ make_rdonly(EXT3_SB(sb)->s_journal->j_dev, &journal_no_write[1]);
-+ wake_up(&EXT3_SB(sb)->ro_wait_queue);
-+}
-+
-+static void setup_ro_after(struct super_block *sb)
-+{
-+ struct ext3_sb_info *sbi = EXT3_SB(sb);
-+ init_timer(&sbi->turn_ro_timer);
-+ if (ext3_ro_after) {
-+ printk(KERN_DEBUG "fs will go read-only in %d jiffies\n",
-+ ext3_ro_after);
-+ init_waitqueue_head(&sbi->ro_wait_queue);
-+ journal_no_write[0] = 0;
-+ journal_no_write[1] = 0;
-+ sbi->turn_ro_timer.function = turn_fs_readonly;
-+ sbi->turn_ro_timer.data = (unsigned long)sb;
-+ sbi->turn_ro_timer.expires = jiffies + ext3_ro_after;
-+ ext3_ro_after = 0;
-+ add_timer(&sbi->turn_ro_timer);
-+ }
-+}
-+
-+static void clear_ro_after(struct super_block *sb)
-+{
-+ del_timer_sync(&EXT3_SB(sb)->turn_ro_timer);
-+ journal_no_write[0] = 0;
-+ journal_no_write[1] = 0;
-+ ext3_ro_after = 0;
-+}
-+#else
-+#define setup_ro_after(sb) do {} while (0)
-+#define clear_ro_after(sb) do {} while (0)
-+#endif
-+
-+
-+static char error_buf[1024];
-+
-+/* Determine the appropriate response to ext3_error on a given filesystem */
-+
-+static int ext3_error_behaviour(struct super_block *sb)
-+{
-+ /* First check for mount-time options */
-+ if (test_opt (sb, ERRORS_PANIC))
-+ return EXT3_ERRORS_PANIC;
-+ if (test_opt (sb, ERRORS_RO))
-+ return EXT3_ERRORS_RO;
-+ if (test_opt (sb, ERRORS_CONT))
-+ return EXT3_ERRORS_CONTINUE;
-+
-+ /* If no overrides were specified on the mount, then fall back
-+ * to the default behaviour set in the filesystem's superblock
-+ * on disk. */
-+ switch (le16_to_cpu(sb->u.ext3_sb.s_es->s_errors)) {
-+ case EXT3_ERRORS_PANIC:
-+ return EXT3_ERRORS_PANIC;
-+ case EXT3_ERRORS_RO:
-+ return EXT3_ERRORS_RO;
-+ default:
-+ break;
-+ }
-+ return EXT3_ERRORS_CONTINUE;
-+}
-+
-+/* Deal with the reporting of failure conditions on a filesystem such as
-+ * inconsistencies detected or read IO failures.
-+ *
-+ * On ext2, we can store the error state of the filesystem in the
-+ * superblock. That is not possible on ext3, because we may have other
-+ * write ordering constraints on the superblock which prevent us from
-+ * writing it out straight away; and given that the journal is about to
-+ * be aborted, we can't rely on the current, or future, transactions to
-+ * write out the superblock safely.
-+ *
-+ * We'll just use the journal_abort() error code to record an error in
-+ * the journal instead. On recovery, the journal will compain about
-+ * that error until we've noted it down and cleared it.
-+ */
-+
-+static void ext3_handle_error(struct super_block *sb)
-+{
-+ struct ext3_super_block *es = EXT3_SB(sb)->s_es;
-+
-+ EXT3_SB(sb)->s_mount_state |= EXT3_ERROR_FS;
-+ es->s_state |= cpu_to_le32(EXT3_ERROR_FS);
-+
-+ if (sb->s_flags & MS_RDONLY)
-+ return;
-+
-+ if (ext3_error_behaviour(sb) != EXT3_ERRORS_CONTINUE) {
-+ EXT3_SB(sb)->s_mount_opt |= EXT3_MOUNT_ABORT;
-+ journal_abort(EXT3_SB(sb)->s_journal, -EIO);
-+ }
-+
-+ if (ext3_error_behaviour(sb) == EXT3_ERRORS_PANIC)
-+ panic ("EXT3-fs (device %s): panic forced after error\n",
-+ bdevname(sb->s_dev));
-+
-+ if (ext3_error_behaviour(sb) == EXT3_ERRORS_RO) {
-+ printk (KERN_CRIT "Remounting filesystem read-only\n");
-+ sb->s_flags |= MS_RDONLY;
-+ }
-+
-+ ext3_commit_super(sb, es, 1);
-+}
-+
-+void ext3_error (struct super_block * sb, const char * function,
-+ const char * fmt, ...)
-+{
-+ va_list args;
-+
-+ va_start (args, fmt);
-+ vsprintf (error_buf, fmt, args);
-+ va_end (args);
-+
-+ printk (KERN_CRIT "EXT3-fs error (device %s): %s: %s\n",
-+ bdevname(sb->s_dev), function, error_buf);
-+
-+ ext3_handle_error(sb);
-+}
-+
-+const char *ext3_decode_error(struct super_block * sb, int errno, char nbuf[16])
-+{
-+ char *errstr = NULL;
-+
-+ switch (errno) {
-+ case -EIO:
-+ errstr = "IO failure";
-+ break;
-+ case -ENOMEM:
-+ errstr = "Out of memory";
-+ break;
-+ case -EROFS:
-+ if (!sb || EXT3_SB(sb)->s_journal->j_flags & JFS_ABORT)
-+ errstr = "Journal has aborted";
-+ else
-+ errstr = "Readonly filesystem";
-+ break;
-+ default:
-+ /* If the caller passed in an extra buffer for unknown
-+ * errors, textualise them now. Else we just return
-+ * NULL. */
-+ if (nbuf) {
-+ /* Check for truncated error codes... */
-+ if (snprintf(nbuf, 16, "error %d", -errno) >= 0)
-+ errstr = nbuf;
-+ }
-+
-+ break;
-+ }
-+
-+ return errstr;
-+}
-+
-+/* __ext3_std_error decodes expected errors from journaling functions
-+ * automatically and invokes the appropriate error response. */
-+
-+void __ext3_std_error (struct super_block * sb, const char * function,
-+ int errno)
-+{
-+ char nbuf[16];
-+ const char *errstr = ext3_decode_error(sb, errno, nbuf);
-+
-+ printk (KERN_CRIT "EXT3-fs error (device %s) in %s: %s\n",
-+ bdevname(sb->s_dev), function, errstr);
-+
-+ ext3_handle_error(sb);
-+}
-+
-+/*
-+ * ext3_abort is a much stronger failure handler than ext3_error. The
-+ * abort function may be used to deal with unrecoverable failures such
-+ * as journal IO errors or ENOMEM at a critical moment in log management.
-+ *
-+ * We unconditionally force the filesystem into an ABORT|READONLY state,
-+ * unless the error response on the fs has been set to panic in which
-+ * case we take the easy way out and panic immediately.
-+ */
-+
-+void ext3_abort (struct super_block * sb, const char * function,
-+ const char * fmt, ...)
-+{
-+ va_list args;
-+
-+ printk (KERN_CRIT "ext3_abort called.\n");
-+
-+ va_start (args, fmt);
-+ vsprintf (error_buf, fmt, args);
-+ va_end (args);
-+
-+ if (ext3_error_behaviour(sb) == EXT3_ERRORS_PANIC)
-+ panic ("EXT3-fs panic (device %s): %s: %s\n",
-+ bdevname(sb->s_dev), function, error_buf);
-+
-+ printk (KERN_CRIT "EXT3-fs abort (device %s): %s: %s\n",
-+ bdevname(sb->s_dev), function, error_buf);
-+
-+ if (sb->s_flags & MS_RDONLY)
-+ return;
-+
-+ printk (KERN_CRIT "Remounting filesystem read-only\n");
-+ sb->u.ext3_sb.s_mount_state |= EXT3_ERROR_FS;
-+ sb->s_flags |= MS_RDONLY;
-+ sb->u.ext3_sb.s_mount_opt |= EXT3_MOUNT_ABORT;
-+ journal_abort(EXT3_SB(sb)->s_journal, -EIO);
-+}
-+
-+/* Deal with the reporting of failure conditions while running, such as
-+ * inconsistencies in operation or invalid system states.
-+ *
-+ * Use ext3_error() for cases of invalid filesystem states, as that will
-+ * record an error on disk and force a filesystem check on the next boot.
-+ */
-+NORET_TYPE void ext3_panic (struct super_block * sb, const char * function,
-+ const char * fmt, ...)
-+{
-+ va_list args;
-+
-+ va_start (args, fmt);
-+ vsprintf (error_buf, fmt, args);
-+ va_end (args);
-+
-+ /* this is to prevent panic from syncing this filesystem */
-+ /* AKPM: is this sufficient? */
-+ sb->s_flags |= MS_RDONLY;
-+ panic ("EXT3-fs panic (device %s): %s: %s\n",
-+ bdevname(sb->s_dev), function, error_buf);
-+}
-+
-+void ext3_warning (struct super_block * sb, const char * function,
-+ const char * fmt, ...)
-+{
-+ va_list args;
-+
-+ va_start (args, fmt);
-+ vsprintf (error_buf, fmt, args);
-+ va_end (args);
-+ printk (KERN_WARNING "EXT3-fs warning (device %s): %s: %s\n",
-+ bdevname(sb->s_dev), function, error_buf);
-+}
-+
-+void ext3_update_dynamic_rev(struct super_block *sb)
-+{
-+ struct ext3_super_block *es = EXT3_SB(sb)->s_es;
-+
-+ if (le32_to_cpu(es->s_rev_level) > EXT3_GOOD_OLD_REV)
-+ return;
-+
-+ ext3_warning(sb, __FUNCTION__,
-+ "updating to rev %d because of new feature flag, "
-+ "running e2fsck is recommended",
-+ EXT3_DYNAMIC_REV);
-+
-+ es->s_first_ino = cpu_to_le32(EXT3_GOOD_OLD_FIRST_INO);
-+ es->s_inode_size = cpu_to_le16(EXT3_GOOD_OLD_INODE_SIZE);
-+ es->s_rev_level = cpu_to_le32(EXT3_DYNAMIC_REV);
-+ /* leave es->s_feature_*compat flags alone */
-+ /* es->s_uuid will be set by e2fsck if empty */
-+
-+ /*
-+ * The rest of the superblock fields should be zero, and if not it
-+ * means they are likely already in use, so leave them alone. We
-+ * can leave it up to e2fsck to clean up any inconsistencies there.
-+ */
-+}
-+
-+/*
-+ * Open the external journal device
-+ */
-+static struct block_device *ext3_blkdev_get(kdev_t dev)
-+{
-+ struct block_device *bdev;
-+ int err = -ENODEV;
-+
-+ bdev = bdget(kdev_t_to_nr(dev));
-+ if (bdev == NULL)
-+ goto fail;
-+ err = blkdev_get(bdev, FMODE_READ|FMODE_WRITE, 0, BDEV_FS);
-+ if (err < 0)
-+ goto fail;
-+ return bdev;
-+
-+fail:
-+ printk(KERN_ERR "EXT3: failed to open journal device %s: %d\n",
-+ bdevname(dev), err);
-+ return NULL;
-+}
-+
-+/*
-+ * Release the journal device
-+ */
-+static int ext3_blkdev_put(struct block_device *bdev)
-+{
-+ return blkdev_put(bdev, BDEV_FS);
-+}
-+
-+static int ext3_blkdev_remove(struct ext3_sb_info *sbi)
-+{
-+ struct block_device *bdev;
-+ int ret = -ENODEV;
-+
-+ bdev = sbi->journal_bdev;
-+ if (bdev) {
-+ ret = ext3_blkdev_put(bdev);
-+ sbi->journal_bdev = 0;
-+ }
-+ return ret;
-+}
-+
-+#define orphan_list_entry(l) list_entry((l), struct inode, u.ext3_i.i_orphan)
-+
-+static void dump_orphan_list(struct super_block *sb, struct ext3_sb_info *sbi)
-+{
-+ struct list_head *l;
-+
-+ printk(KERN_ERR "sb orphan head is %d\n",
-+ le32_to_cpu(sbi->s_es->s_last_orphan));
-+
-+ printk(KERN_ERR "sb_info orphan list:\n");
-+ list_for_each(l, &sbi->s_orphan) {
-+ struct inode *inode = orphan_list_entry(l);
-+ printk(KERN_ERR " "
-+ "inode 0x%04x:%ld at %p: mode %o, nlink %d, next %d\n",
-+ inode->i_dev, inode->i_ino, inode,
-+ inode->i_mode, inode->i_nlink,
-+ le32_to_cpu(NEXT_ORPHAN(inode)));
-+ }
-+}
-+
-+void ext3_put_super (struct super_block * sb)
-+{
-+ struct ext3_sb_info *sbi = EXT3_SB(sb);
-+ struct ext3_super_block *es = sbi->s_es;
-+ kdev_t j_dev = sbi->s_journal->j_dev;
-+ int i;
-+
-+ journal_destroy(sbi->s_journal);
-+ if (!(sb->s_flags & MS_RDONLY)) {
-+ EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
-+ es->s_state = le16_to_cpu(sbi->s_mount_state);
-+ BUFFER_TRACE(sbi->s_sbh, "marking dirty");
-+ mark_buffer_dirty(sbi->s_sbh);
-+ ext3_commit_super(sb, es, 1);
-+ }
-+
-+ for (i = 0; i < sbi->s_gdb_count; i++)
-+ brelse(sbi->s_group_desc[i]);
-+ kfree(sbi->s_group_desc);
-+ for (i = 0; i < EXT3_MAX_GROUP_LOADED; i++)
-+ brelse(sbi->s_inode_bitmap[i]);
-+ for (i = 0; i < EXT3_MAX_GROUP_LOADED; i++)
-+ brelse(sbi->s_block_bitmap[i]);
-+ brelse(sbi->s_sbh);
-+
-+ /* Debugging code just in case the in-memory inode orphan list
-+ * isn't empty. The on-disk one can be non-empty if we've
-+ * detected an error and taken the fs readonly, but the
-+ * in-memory list had better be clean by this point. */
-+ if (!list_empty(&sbi->s_orphan))
-+ dump_orphan_list(sb, sbi);
-+ J_ASSERT(list_empty(&sbi->s_orphan));
-+
-+ invalidate_buffers(sb->s_dev);
-+ if (j_dev != sb->s_dev) {
-+ /*
-+ * Invalidate the journal device's buffers. We don't want them
-+ * floating about in memory - the physical journal device may
-+ * hotswapped, and it breaks the `ro-after' testing code.
-+ */
-+ fsync_no_super(j_dev);
-+ invalidate_buffers(j_dev);
-+ ext3_blkdev_remove(sbi);
-+ }
-+ clear_ro_after(sb);
-+
-+ return;
-+}
-+
-+static struct super_operations ext3_sops = {
-+ read_inode: ext3_read_inode, /* BKL held */
-+ write_inode: ext3_write_inode, /* BKL not held. Don't need */
-+ dirty_inode: ext3_dirty_inode, /* BKL not held. We take it */
-+ put_inode: ext3_put_inode, /* BKL not held. Don't need */
-+ delete_inode: ext3_delete_inode, /* BKL not held. We take it */
-+ put_super: ext3_put_super, /* BKL held */
-+ write_super: ext3_write_super, /* BKL held */
-+ sync_fs: ext3_sync_fs,
-+ write_super_lockfs: ext3_write_super_lockfs, /* BKL not held. Take it */
-+ unlockfs: ext3_unlockfs, /* BKL not held. We take it */
-+ statfs: ext3_statfs, /* BKL held */
-+ remount_fs: ext3_remount, /* BKL held */
-+};
-+
-+static int want_value(char *value, char *option)
-+{
-+ if (!value || !*value) {
-+ printk(KERN_NOTICE "EXT3-fs: the %s option needs an argument\n",
-+ option);
-+ return -1;
-+ }
-+ return 0;
-+}
-+
-+static int want_null_value(char *value, char *option)
-+{
-+ if (*value) {
-+ printk(KERN_NOTICE "EXT3-fs: Invalid %s argument: %s\n",
-+ option, value);
-+ return -1;
-+ }
-+ return 0;
-+}
-+
-+static int want_numeric(char *value, char *option, unsigned long *number)
-+{
-+ if (want_value(value, option))
-+ return -1;
-+ *number = simple_strtoul(value, &value, 0);
-+ if (want_null_value(value, option))
-+ return -1;
-+ return 0;
-+}
-+
-+/*
-+ * This function has been shamelessly adapted from the msdos fs
-+ */
-+static int parse_options (char * options, unsigned long * sb_block,
-+ struct ext3_sb_info *sbi,
-+ unsigned long * inum,
-+ int is_remount)
-+{
-+ unsigned long *mount_options = &sbi->s_mount_opt;
-+ uid_t *resuid = &sbi->s_resuid;
-+ gid_t *resgid = &sbi->s_resgid;
-+ char * this_char;
-+ char * value;
-+
-+ if (!options)
-+ return 1;
-+ for (this_char = strtok (options, ",");
-+ this_char != NULL;
-+ this_char = strtok (NULL, ",")) {
-+ if ((value = strchr (this_char, '=')) != NULL)
-+ *value++ = 0;
-+ if (!strcmp (this_char, "bsddf"))
-+ clear_opt (*mount_options, MINIX_DF);
-+ else if (!strcmp (this_char, "nouid32")) {
-+ set_opt (*mount_options, NO_UID32);
-+ }
-+ else if (!strcmp (this_char, "abort"))
-+ set_opt (*mount_options, ABORT);
-+ else if (!strcmp (this_char, "check")) {
-+ if (!value || !*value || !strcmp (value, "none"))
-+ clear_opt (*mount_options, CHECK);
-+ else
-+#ifdef CONFIG_EXT3_CHECK
-+ set_opt (*mount_options, CHECK);
-+#else
-+ printk(KERN_ERR
-+ "EXT3 Check option not supported\n");
-+#endif
-+ }
-+ else if (!strcmp (this_char, "debug"))
-+ set_opt (*mount_options, DEBUG);
-+ else if (!strcmp (this_char, "errors")) {
-+ if (want_value(value, "errors"))
-+ return 0;
-+ if (!strcmp (value, "continue")) {
-+ clear_opt (*mount_options, ERRORS_RO);
-+ clear_opt (*mount_options, ERRORS_PANIC);
-+ set_opt (*mount_options, ERRORS_CONT);
-+ }
-+ else if (!strcmp (value, "remount-ro")) {
-+ clear_opt (*mount_options, ERRORS_CONT);
-+ clear_opt (*mount_options, ERRORS_PANIC);
-+ set_opt (*mount_options, ERRORS_RO);
-+ }
-+ else if (!strcmp (value, "panic")) {
-+ clear_opt (*mount_options, ERRORS_CONT);
-+ clear_opt (*mount_options, ERRORS_RO);
-+ set_opt (*mount_options, ERRORS_PANIC);
-+ }
-+ else {
-+ printk (KERN_ERR
-+ "EXT3-fs: Invalid errors option: %s\n",
-+ value);
-+ return 0;
-+ }
-+ }
-+ else if (!strcmp (this_char, "grpid") ||
-+ !strcmp (this_char, "bsdgroups"))
-+ set_opt (*mount_options, GRPID);
-+ else if (!strcmp (this_char, "minixdf"))
-+ set_opt (*mount_options, MINIX_DF);
-+ else if (!strcmp (this_char, "nocheck"))
-+ clear_opt (*mount_options, CHECK);
-+ else if (!strcmp (this_char, "nogrpid") ||
-+ !strcmp (this_char, "sysvgroups"))
-+ clear_opt (*mount_options, GRPID);
-+ else if (!strcmp (this_char, "resgid")) {
-+ unsigned long v;
-+ if (want_numeric(value, "resgid", &v))
-+ return 0;
-+ *resgid = v;
-+ }
-+ else if (!strcmp (this_char, "resuid")) {
-+ unsigned long v;
-+ if (want_numeric(value, "resuid", &v))
-+ return 0;
-+ *resuid = v;
-+ }
-+ else if (!strcmp (this_char, "sb")) {
-+ if (want_numeric(value, "sb", sb_block))
-+ return 0;
-+ }
-+#ifdef CONFIG_JBD_DEBUG
-+ else if (!strcmp (this_char, "ro-after")) {
-+ unsigned long v;
-+ if (want_numeric(value, "ro-after", &v))
-+ return 0;
-+ ext3_ro_after = v;
-+ }
-+#endif
-+ /* Silently ignore the quota options */
-+ else if (!strcmp (this_char, "grpquota")
-+ || !strcmp (this_char, "noquota")
-+ || !strcmp (this_char, "quota")
-+ || !strcmp (this_char, "usrquota"))
-+ /* Don't do anything ;-) */ ;
-+ else if (!strcmp (this_char, "journal")) {
-+ /* @@@ FIXME */
-+ /* Eventually we will want to be able to create
-+ a journal file here. For now, only allow the
-+ user to specify an existing inode to be the
-+ journal file. */
-+ if (is_remount) {
-+ printk(KERN_ERR "EXT3-fs: cannot specify "
-+ "journal on remount\n");
-+ return 0;
-+ }
-+
-+ if (want_value(value, "journal"))
-+ return 0;
-+ if (!strcmp (value, "update"))
-+ set_opt (*mount_options, UPDATE_JOURNAL);
-+ else if (want_numeric(value, "journal", inum))
-+ return 0;
-+ }
-+ else if (!strcmp (this_char, "noload"))
-+ set_opt (*mount_options, NOLOAD);
-+ else if (!strcmp (this_char, "data")) {
-+ int data_opt = 0;
-+
-+ if (want_value(value, "data"))
-+ return 0;
-+ if (!strcmp (value, "journal"))
-+ data_opt = EXT3_MOUNT_JOURNAL_DATA;
-+ else if (!strcmp (value, "ordered"))
-+ data_opt = EXT3_MOUNT_ORDERED_DATA;
-+ else if (!strcmp (value, "writeback"))
-+ data_opt = EXT3_MOUNT_WRITEBACK_DATA;
-+ else {
-+ printk (KERN_ERR
-+ "EXT3-fs: Invalid data option: %s\n",
-+ value);
-+ return 0;
-+ }
-+ if (is_remount) {
-+ if ((*mount_options & EXT3_MOUNT_DATA_FLAGS) !=
-+ data_opt) {
-+ printk(KERN_ERR
-+ "EXT3-fs: cannot change data "
-+ "mode on remount\n");
-+ return 0;
-+ }
-+ } else {
-+ *mount_options &= ~EXT3_MOUNT_DATA_FLAGS;
-+ *mount_options |= data_opt;
-+ }
-+ } else if (!strcmp (this_char, "commit")) {
-+ unsigned long v;
-+ if (want_numeric(value, "commit", &v))
-+ return 0;
-+ sbi->s_commit_interval = (HZ * v);
-+ } else {
-+ printk (KERN_ERR
-+ "EXT3-fs: Unrecognized mount option %s\n",
-+ this_char);
-+ return 0;
-+ }
-+ }
-+ return 1;
-+}
-+
-+static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
-+ int read_only)
-+{
-+ struct ext3_sb_info *sbi = EXT3_SB(sb);
-+ int res = 0;
-+
-+ if (le32_to_cpu(es->s_rev_level) > EXT3_MAX_SUPP_REV) {
-+ printk (KERN_ERR "EXT3-fs warning: revision level too high, "
-+ "forcing read-only mode\n");
-+ res = MS_RDONLY;
-+ }
-+ if (read_only)
-+ return res;
-+ if (!(sbi->s_mount_state & EXT3_VALID_FS))
-+ printk (KERN_WARNING "EXT3-fs warning: mounting unchecked fs, "
-+ "running e2fsck is recommended\n");
-+ else if ((sbi->s_mount_state & EXT3_ERROR_FS))
-+ printk (KERN_WARNING
-+ "EXT3-fs warning: mounting fs with errors, "
-+ "running e2fsck is recommended\n");
-+ else if ((__s16) le16_to_cpu(es->s_max_mnt_count) >= 0 &&
-+ le16_to_cpu(es->s_mnt_count) >=
-+ (unsigned short) (__s16) le16_to_cpu(es->s_max_mnt_count))
-+ printk (KERN_WARNING
-+ "EXT3-fs warning: maximal mount count reached, "
-+ "running e2fsck is recommended\n");
-+ else if (le32_to_cpu(es->s_checkinterval) &&
-+ (le32_to_cpu(es->s_lastcheck) +
-+ le32_to_cpu(es->s_checkinterval) <= CURRENT_TIME))
-+ printk (KERN_WARNING
-+ "EXT3-fs warning: checktime reached, "
-+ "running e2fsck is recommended\n");
-+#if 0
-+ /* @@@ We _will_ want to clear the valid bit if we find
-+ inconsistencies, to force a fsck at reboot. But for
-+ a plain journaled filesystem we can keep it set as
-+ valid forever! :) */
-+ es->s_state = cpu_to_le16(le16_to_cpu(es->s_state) & ~EXT3_VALID_FS);
-+#endif
-+ if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
-+ es->s_max_mnt_count =
-+ (__s16) cpu_to_le16(EXT3_DFL_MAX_MNT_COUNT);
-+ es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
-+ es->s_mtime = cpu_to_le32(CURRENT_TIME);
-+ ext3_update_dynamic_rev(sb);
-+ EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
-+ ext3_commit_super (sb, es, 1);
-+ if (test_opt (sb, DEBUG))
-+ printk (KERN_INFO
-+ "[EXT3 FS %s, %s, bs=%lu, gc=%lu, "
-+ "bpg=%lu, ipg=%lu, mo=%04lx]\n",
-+ EXT3FS_VERSION, EXT3FS_DATE, sb->s_blocksize,
-+ sbi->s_groups_count,
-+ EXT3_BLOCKS_PER_GROUP(sb),
-+ EXT3_INODES_PER_GROUP(sb),
-+ sbi->s_mount_opt);
-+ printk(KERN_INFO "EXT3 FS " EXT3FS_VERSION ", " EXT3FS_DATE " on %s, ",
-+ bdevname(sb->s_dev));
-+ if (EXT3_SB(sb)->s_journal->j_inode == NULL) {
-+ printk("external journal on %s\n",
-+ bdevname(EXT3_SB(sb)->s_journal->j_dev));
-+ } else {
-+ printk("internal journal\n");
-+ }
-+#ifdef CONFIG_EXT3_CHECK
-+ if (test_opt (sb, CHECK)) {
-+ ext3_check_blocks_bitmap (sb);
-+ ext3_check_inodes_bitmap (sb);
-+ }
-+#endif
-+ setup_ro_after(sb);
-+ return res;
-+}
-+
-+static int ext3_check_descriptors (struct super_block * sb)
-+{
-+ struct ext3_sb_info *sbi = EXT3_SB(sb);
-+ unsigned long block = le32_to_cpu(sbi->s_es->s_first_data_block);
-+ struct ext3_group_desc * gdp = NULL;
-+ int desc_block = 0;
-+ int i;
-+
-+ ext3_debug ("Checking group descriptors");
-+
-+ for (i = 0; i < sbi->s_groups_count; i++)
-+ {
-+ if ((i % EXT3_DESC_PER_BLOCK(sb)) == 0)
-+ gdp = (struct ext3_group_desc *)
-+ sbi->s_group_desc[desc_block++]->b_data;
-+ if (le32_to_cpu(gdp->bg_block_bitmap) < block ||
-+ le32_to_cpu(gdp->bg_block_bitmap) >=
-+ block + EXT3_BLOCKS_PER_GROUP(sb))
-+ {
-+ ext3_error (sb, "ext3_check_descriptors",
-+ "Block bitmap for group %d"
-+ " not in group (block %lu)!",
-+ i, (unsigned long)
-+ le32_to_cpu(gdp->bg_block_bitmap));
-+ return 0;
-+ }
-+ if (le32_to_cpu(gdp->bg_inode_bitmap) < block ||
-+ le32_to_cpu(gdp->bg_inode_bitmap) >=
-+ block + EXT3_BLOCKS_PER_GROUP(sb))
-+ {
-+ ext3_error (sb, "ext3_check_descriptors",
-+ "Inode bitmap for group %d"
-+ " not in group (block %lu)!",
-+ i, (unsigned long)
-+ le32_to_cpu(gdp->bg_inode_bitmap));
-+ return 0;
-+ }
-+ if (le32_to_cpu(gdp->bg_inode_table) < block ||
-+ le32_to_cpu(gdp->bg_inode_table) + sbi->s_itb_per_group >=
-+ block + EXT3_BLOCKS_PER_GROUP(sb))
-+ {
-+ ext3_error (sb, "ext3_check_descriptors",
-+ "Inode table for group %d"
-+ " not in group (block %lu)!",
-+ i, (unsigned long)
-+ le32_to_cpu(gdp->bg_inode_table));
-+ return 0;
-+ }
-+ block += EXT3_BLOCKS_PER_GROUP(sb);
-+ gdp++;
-+ }
-+ return 1;
-+}
-+
-+
-+/* ext3_orphan_cleanup() walks a singly-linked list of inodes (starting at
-+ * the superblock) which were deleted from all directories, but held open by
-+ * a process at the time of a crash. We walk the list and try to delete these
-+ * inodes at recovery time (only with a read-write filesystem).
-+ *
-+ * In order to keep the orphan inode chain consistent during traversal (in
-+ * case of crash during recovery), we link each inode into the superblock
-+ * orphan list_head and handle it the same way as an inode deletion during
-+ * normal operation (which journals the operations for us).
-+ *
-+ * We only do an iget() and an iput() on each inode, which is very safe if we
-+ * accidentally point at an in-use or already deleted inode. The worst that
-+ * can happen in this case is that we get a "bit already cleared" message from
-+ * ext3_free_inode(). The only reason we would point at a wrong inode is if
-+ * e2fsck was run on this filesystem, and it must have already done the orphan
-+ * inode cleanup for us, so we can safely abort without any further action.
-+ */
-+static void ext3_orphan_cleanup (struct super_block * sb,
-+ struct ext3_super_block * es)
-+{
-+ unsigned int s_flags = sb->s_flags;
-+ int nr_orphans = 0, nr_truncates = 0;
-+ if (!es->s_last_orphan) {
-+ jbd_debug(4, "no orphan inodes to clean up\n");
-+ return;
-+ }
-+
-+ if (s_flags & MS_RDONLY) {
-+ printk(KERN_INFO "EXT3-fs: %s: orphan cleanup on readonly fs\n",
-+ bdevname(sb->s_dev));
-+ sb->s_flags &= ~MS_RDONLY;
-+ }
-+
-+ if (sb->u.ext3_sb.s_mount_state & EXT3_ERROR_FS) {
-+ if (es->s_last_orphan)
-+ jbd_debug(1, "Errors on filesystem, "
-+ "clearing orphan list.\n");
-+ es->s_last_orphan = 0;
-+ jbd_debug(1, "Skipping orphan recovery on fs with errors.\n");
-+ return;
-+ }
-+
-+ while (es->s_last_orphan) {
-+ struct inode *inode;
-+
-+ if (!(inode =
-+ ext3_orphan_get(sb, le32_to_cpu(es->s_last_orphan)))) {
-+ es->s_last_orphan = 0;
-+ break;
-+ }
-+
-+ list_add(&EXT3_I(inode)->i_orphan, &EXT3_SB(sb)->s_orphan);
-+ if (inode->i_nlink) {
-+ printk(KERN_DEBUG "%s: truncating inode %ld to %Ld "
-+ "bytes\n", __FUNCTION__, inode->i_ino,
-+ inode->i_size);
-+ jbd_debug(2, "truncating inode %ld to %Ld bytes\n",
-+ inode->i_ino, inode->i_size);
-+ ext3_truncate(inode);
-+ nr_truncates++;
-+ } else {
-+ printk(KERN_DEBUG "%s: deleting unreferenced "
-+ "inode %ld\n", __FUNCTION__, inode->i_ino);
-+ jbd_debug(2, "deleting unreferenced inode %ld\n",
-+ inode->i_ino);
-+ nr_orphans++;
-+ }
-+ iput(inode); /* The delete magic happens here! */
-+ }
-+
-+#define PLURAL(x) (x), ((x)==1) ? "" : "s"
-+
-+ if (nr_orphans)
-+ printk(KERN_INFO "EXT3-fs: %s: %d orphan inode%s deleted\n",
-+ bdevname(sb->s_dev), PLURAL(nr_orphans));
-+ if (nr_truncates)
-+ printk(KERN_INFO "EXT3-fs: %s: %d truncate%s cleaned up\n",
-+ bdevname(sb->s_dev), PLURAL(nr_truncates));
-+ sb->s_flags = s_flags; /* Restore MS_RDONLY status */
-+}
-+
-+#define log2(n) ffz(~(n))
-+
-+/*
-+ * Maximal file size. There is a direct, and {,double-,triple-}indirect
-+ * block limit, and also a limit of (2^32 - 1) 512-byte sectors in i_blocks.
-+ * We need to be 1 filesystem block less than the 2^32 sector limit.
-+ */
-+static loff_t ext3_max_size(int bits)
-+{
-+ loff_t res = EXT3_NDIR_BLOCKS;
-+ res += 1LL << (bits-2);
-+ res += 1LL << (2*(bits-2));
-+ res += 1LL << (3*(bits-2));
-+ res <<= bits;
-+ if (res > (512LL << 32) - (1 << bits))
-+ res = (512LL << 32) - (1 << bits);
-+ return res;
-+}
-+
-+struct super_block * ext3_read_super (struct super_block * sb, void * data,
-+ int silent)
-+{
-+ struct buffer_head * bh;
-+ struct ext3_super_block *es = 0;
-+ struct ext3_sb_info *sbi = EXT3_SB(sb);
-+ unsigned long sb_block = 1;
-+ unsigned long logic_sb_block = 1;
-+ unsigned long offset = 0;
-+ unsigned long journal_inum = 0;
-+ kdev_t dev = sb->s_dev;
-+ int blocksize;
-+ int hblock;
-+ int db_count;
-+ int i;
-+ int needs_recovery;
-+
-+#ifdef CONFIG_JBD_DEBUG
-+ ext3_ro_after = 0;
-+#endif
-+ /*
-+ * See what the current blocksize for the device is, and
-+ * use that as the blocksize. Otherwise (or if the blocksize
-+ * is smaller than the default) use the default.
-+ * This is important for devices that have a hardware
-+ * sectorsize that is larger than the default.
-+ */
-+ blocksize = EXT3_MIN_BLOCK_SIZE;
-+ hblock = get_hardsect_size(dev);
-+ if (blocksize < hblock)
-+ blocksize = hblock;
-+
-+ sbi->s_mount_opt = 0;
-+ sbi->s_resuid = EXT3_DEF_RESUID;
-+ sbi->s_resgid = EXT3_DEF_RESGID;
-+ if (!parse_options ((char *) data, &sb_block, sbi, &journal_inum, 0)) {
-+ sb->s_dev = 0;
-+ goto out_fail;
-+ }
-+
-+ sb->s_blocksize = blocksize;
-+ set_blocksize (dev, blocksize);
-+
-+ /*
-+ * The ext3 superblock will not be buffer aligned for other than 1kB
-+ * block sizes. We need to calculate the offset from buffer start.
-+ */
-+ if (blocksize != EXT3_MIN_BLOCK_SIZE) {
-+ logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
-+ offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
-+ }
-+
-+ if (!(bh = sb_bread(sb, logic_sb_block))) {
-+ printk (KERN_ERR "EXT3-fs: unable to read superblock\n");
-+ goto out_fail;
-+ }
-+ /*
-+ * Note: s_es must be initialized as soon as possible because
-+ * some ext3 macro-instructions depend on its value
-+ */
-+ es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
-+ sbi->s_es = es;
-+ sb->s_magic = le16_to_cpu(es->s_magic);
-+ if (sb->s_magic != EXT3_SUPER_MAGIC) {
-+ if (!silent)
-+ printk(KERN_ERR
-+ "VFS: Can't find ext3 filesystem on dev %s.\n",
-+ bdevname(dev));
-+ goto failed_mount;
-+ }
-+ if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV &&
-+ (EXT3_HAS_COMPAT_FEATURE(sb, ~0U) ||
-+ EXT3_HAS_RO_COMPAT_FEATURE(sb, ~0U) ||
-+ EXT3_HAS_INCOMPAT_FEATURE(sb, ~0U)))
-+ printk(KERN_WARNING
-+ "EXT3-fs warning: feature flags set on rev 0 fs, "
-+ "running e2fsck is recommended\n");
-+ /*
-+ * Check feature flags regardless of the revision level, since we
-+ * previously didn't change the revision level when setting the flags,
-+ * so there is a chance incompat flags are set on a rev 0 filesystem.
-+ */
-+ if ((i = EXT3_HAS_INCOMPAT_FEATURE(sb, ~EXT3_FEATURE_INCOMPAT_SUPP))) {
-+ printk(KERN_ERR "EXT3-fs: %s: couldn't mount because of "
-+ "unsupported optional features (%x).\n",
-+ bdevname(dev), i);
-+ goto failed_mount;
-+ }
-+ if (!(sb->s_flags & MS_RDONLY) &&
-+ (i = EXT3_HAS_RO_COMPAT_FEATURE(sb, ~EXT3_FEATURE_RO_COMPAT_SUPP))){
-+ printk(KERN_ERR "EXT3-fs: %s: couldn't mount RDWR because of "
-+ "unsupported optional features (%x).\n",
-+ bdevname(dev), i);
-+ goto failed_mount;
-+ }
-+ sb->s_blocksize_bits = le32_to_cpu(es->s_log_block_size) + 10;
-+ sb->s_blocksize = 1 << sb->s_blocksize_bits;
-+
-+ if (sb->s_blocksize < EXT3_MIN_BLOCK_SIZE ||
-+ sb->s_blocksize > EXT3_MAX_BLOCK_SIZE) {
-+ printk(KERN_ERR
-+ "EXT3-fs: Unsupported filesystem blocksize %d on %s.\n",
-+ blocksize, bdevname(dev));
-+ goto failed_mount;
-+ }
-+
-+ sb->s_maxbytes = ext3_max_size(sb->s_blocksize_bits);
-+
-+ if (sb->s_blocksize != blocksize) {
-+ blocksize = sb->s_blocksize;
-+
-+ /*
-+ * Make sure the blocksize for the filesystem is larger
-+ * than the hardware sectorsize for the machine.
-+ */
-+ if (sb->s_blocksize < hblock) {
-+ printk(KERN_ERR "EXT3-fs: blocksize %d too small for "
-+ "device blocksize %d.\n", blocksize, hblock);
-+ goto failed_mount;
-+ }
-+
-+ brelse (bh);
-+ set_blocksize (dev, sb->s_blocksize);
-+ logic_sb_block = (sb_block * EXT3_MIN_BLOCK_SIZE) / blocksize;
-+ offset = (sb_block * EXT3_MIN_BLOCK_SIZE) % blocksize;
-+ bh = sb_bread(sb, logic_sb_block);
-+ if (!bh) {
-+ printk(KERN_ERR
-+ "EXT3-fs: Can't read superblock on 2nd try.\n");
-+ return NULL;
-+ }
-+ es = (struct ext3_super_block *)(((char *)bh->b_data) + offset);
-+ sbi->s_es = es;
-+ if (es->s_magic != le16_to_cpu(EXT3_SUPER_MAGIC)) {
-+ printk (KERN_ERR
-+ "EXT3-fs: Magic mismatch, very weird !\n");
-+ goto failed_mount;
-+ }
-+ }
-+
-+ if (le32_to_cpu(es->s_rev_level) == EXT3_GOOD_OLD_REV) {
-+ sbi->s_inode_size = EXT3_GOOD_OLD_INODE_SIZE;
-+ sbi->s_first_ino = EXT3_GOOD_OLD_FIRST_INO;
-+ } else {
-+ sbi->s_inode_size = le16_to_cpu(es->s_inode_size);
-+ sbi->s_first_ino = le32_to_cpu(es->s_first_ino);
-+ if (sbi->s_inode_size != EXT3_GOOD_OLD_INODE_SIZE) {
-+ printk (KERN_ERR
-+ "EXT3-fs: unsupported inode size: %d\n",
-+ sbi->s_inode_size);
-+ goto failed_mount;
-+ }
-+ }
-+ sbi->s_frag_size = EXT3_MIN_FRAG_SIZE <<
-+ le32_to_cpu(es->s_log_frag_size);
-+ if (blocksize != sbi->s_frag_size) {
-+ printk(KERN_ERR
-+ "EXT3-fs: fragsize %lu != blocksize %u (unsupported)\n",
-+ sbi->s_frag_size, blocksize);
-+ goto failed_mount;
-+ }
-+ sbi->s_frags_per_block = 1;
-+ sbi->s_blocks_per_group = le32_to_cpu(es->s_blocks_per_group);
-+ sbi->s_frags_per_group = le32_to_cpu(es->s_frags_per_group);
-+ sbi->s_inodes_per_group = le32_to_cpu(es->s_inodes_per_group);
-+ sbi->s_inodes_per_block = blocksize / EXT3_INODE_SIZE(sb);
-+ sbi->s_itb_per_group = sbi->s_inodes_per_group /sbi->s_inodes_per_block;
-+ sbi->s_desc_per_block = blocksize / sizeof(struct ext3_group_desc);
-+ sbi->s_sbh = bh;
-+ if (sbi->s_resuid == EXT3_DEF_RESUID)
-+ sbi->s_resuid = le16_to_cpu(es->s_def_resuid);
-+ if (sbi->s_resgid == EXT3_DEF_RESGID)
-+ sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
-+ sbi->s_mount_state = le16_to_cpu(es->s_state);
-+ sbi->s_addr_per_block_bits = log2(EXT3_ADDR_PER_BLOCK(sb));
-+ sbi->s_desc_per_block_bits = log2(EXT3_DESC_PER_BLOCK(sb));
-+
-+ if (sbi->s_blocks_per_group > blocksize * 8) {
-+ printk (KERN_ERR
-+ "EXT3-fs: #blocks per group too big: %lu\n",
-+ sbi->s_blocks_per_group);
-+ goto failed_mount;
-+ }
-+ if (sbi->s_frags_per_group > blocksize * 8) {
-+ printk (KERN_ERR
-+ "EXT3-fs: #fragments per group too big: %lu\n",
-+ sbi->s_frags_per_group);
-+ goto failed_mount;
-+ }
-+ if (sbi->s_inodes_per_group > blocksize * 8) {
-+ printk (KERN_ERR
-+ "EXT3-fs: #inodes per group too big: %lu\n",
-+ sbi->s_inodes_per_group);
-+ goto failed_mount;
-+ }
-+
-+ sbi->s_groups_count = (le32_to_cpu(es->s_blocks_count) -
-+ le32_to_cpu(es->s_first_data_block) +
-+ EXT3_BLOCKS_PER_GROUP(sb) - 1) /
-+ EXT3_BLOCKS_PER_GROUP(sb);
-+ db_count = (sbi->s_groups_count + EXT3_DESC_PER_BLOCK(sb) - 1) /
-+ EXT3_DESC_PER_BLOCK(sb);
-+ sbi->s_group_desc = kmalloc(db_count * sizeof (struct buffer_head *),
-+ GFP_KERNEL);
-+ if (sbi->s_group_desc == NULL) {
-+ printk (KERN_ERR "EXT3-fs: not enough memory\n");
-+ goto failed_mount;
-+ }
-+ for (i = 0; i < db_count; i++) {
-+ sbi->s_group_desc[i] = sb_bread(sb, logic_sb_block + i + 1);
-+ if (!sbi->s_group_desc[i]) {
-+ printk (KERN_ERR "EXT3-fs: "
-+ "can't read group descriptor %d\n", i);
-+ db_count = i;
-+ goto failed_mount2;
-+ }
-+ }
-+ if (!ext3_check_descriptors (sb)) {
-+ printk (KERN_ERR "EXT3-fs: group descriptors corrupted !\n");
-+ goto failed_mount2;
-+ }
-+ for (i = 0; i < EXT3_MAX_GROUP_LOADED; i++) {
-+ sbi->s_inode_bitmap_number[i] = 0;
-+ sbi->s_inode_bitmap[i] = NULL;
-+ sbi->s_block_bitmap_number[i] = 0;
-+ sbi->s_block_bitmap[i] = NULL;
-+ }
-+ sbi->s_loaded_inode_bitmaps = 0;
-+ sbi->s_loaded_block_bitmaps = 0;
-+ sbi->s_gdb_count = db_count;
-+ get_random_bytes(&sbi->s_next_generation, sizeof(u32));
-+ /*
-+ * set up enough so that it can read an inode
-+ */
-+ sb->s_op = &ext3_sops;
-+ INIT_LIST_HEAD(&sbi->s_orphan); /* unlinked but open files */
-+
-+ sb->s_root = 0;
-+
-+ needs_recovery = (es->s_last_orphan != 0 ||
-+ EXT3_HAS_INCOMPAT_FEATURE(sb,
-+ EXT3_FEATURE_INCOMPAT_RECOVER));
-+
-+ /*
-+ * The first inode we look at is the journal inode. Don't try
-+ * root first: it may be modified in the journal!
-+ */
-+ if (!test_opt(sb, NOLOAD) &&
-+ EXT3_HAS_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL)) {
-+ if (ext3_load_journal(sb, es))
-+ goto failed_mount2;
-+ } else if (journal_inum) {
-+ if (ext3_create_journal(sb, es, journal_inum))
-+ goto failed_mount2;
-+ } else {
-+ if (!silent)
-+ printk (KERN_ERR
-+ "ext3: No journal on filesystem on %s\n",
-+ bdevname(dev));
-+ goto failed_mount2;
-+ }
-+
-+ /* We have now updated the journal if required, so we can
-+ * validate the data journaling mode. */
-+ switch (test_opt(sb, DATA_FLAGS)) {
-+ case 0:
-+ /* No mode set, assume a default based on the journal
-+ capabilities: ORDERED_DATA if the journal can
-+ cope, else JOURNAL_DATA */
-+ if (journal_check_available_features
-+ (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE))
-+ set_opt(sbi->s_mount_opt, ORDERED_DATA);
-+ else
-+ set_opt(sbi->s_mount_opt, JOURNAL_DATA);
-+ break;
-+
-+ case EXT3_MOUNT_ORDERED_DATA:
-+ case EXT3_MOUNT_WRITEBACK_DATA:
-+ if (!journal_check_available_features
-+ (sbi->s_journal, 0, 0, JFS_FEATURE_INCOMPAT_REVOKE)) {
-+ printk(KERN_ERR "EXT3-fs: Journal does not support "
-+ "requested data journaling mode\n");
-+ goto failed_mount3;
-+ }
-+ default:
-+ break;
-+ }
-+
-+ /*
-+ * The journal_load will have done any necessary log recovery,
-+ * so we can safely mount the rest of the filesystem now.
-+ */
-+
-+ sb->s_root = d_alloc_root(iget(sb, EXT3_ROOT_INO));
-+ if (!sb->s_root || !S_ISDIR(sb->s_root->d_inode->i_mode) ||
-+ !sb->s_root->d_inode->i_blocks || !sb->s_root->d_inode->i_size) {
-+ if (sb->s_root) {
-+ dput(sb->s_root);
-+ sb->s_root = NULL;
-+ printk(KERN_ERR
-+ "EXT3-fs: corrupt root inode, run e2fsck\n");
-+ } else
-+ printk(KERN_ERR "EXT3-fs: get root inode failed\n");
-+ goto failed_mount3;
-+ }
-+
-+ ext3_setup_super (sb, es, sb->s_flags & MS_RDONLY);
-+ /*
-+ * akpm: core read_super() calls in here with the superblock locked.
-+ * That deadlocks, because orphan cleanup needs to lock the superblock
-+ * in numerous places. Here we just pop the lock - it's relatively
-+ * harmless, because we are now ready to accept write_super() requests,
-+ * and aviro says that's the only reason for hanging onto the
-+ * superblock lock.
-+ */
-+ EXT3_SB(sb)->s_mount_state |= EXT3_ORPHAN_FS;
-+ unlock_super(sb); /* akpm: sigh */
-+ ext3_orphan_cleanup(sb, es);
-+ lock_super(sb);
-+ EXT3_SB(sb)->s_mount_state &= ~EXT3_ORPHAN_FS;
-+ if (needs_recovery)
-+ printk (KERN_INFO "EXT3-fs: recovery complete.\n");
-+ ext3_mark_recovery_complete(sb, es);
-+ printk (KERN_INFO "EXT3-fs: mounted filesystem with %s data mode.\n",
-+ test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_JOURNAL_DATA ? "journal":
-+ test_opt(sb,DATA_FLAGS) == EXT3_MOUNT_ORDERED_DATA ? "ordered":
-+ "writeback");
-+
-+ return sb;
-+
-+failed_mount3:
-+ journal_destroy(sbi->s_journal);
-+failed_mount2:
-+ for (i = 0; i < db_count; i++)
-+ brelse(sbi->s_group_desc[i]);
-+ kfree(sbi->s_group_desc);
-+failed_mount:
-+ ext3_blkdev_remove(sbi);
-+ brelse(bh);
-+out_fail:
-+ return NULL;
-+}
-+
-+/*
-+ * Setup any per-fs journal parameters now. We'll do this both on
-+ * initial mount, once the journal has been initialised but before we've
-+ * done any recovery; and again on any subsequent remount.
-+ */
-+static void ext3_init_journal_params(struct ext3_sb_info *sbi,
-+ journal_t *journal)
-+{
-+ if (sbi->s_commit_interval)
-+ journal->j_commit_interval = sbi->s_commit_interval;
-+ /* We could also set up an ext3-specific default for the commit
-+ * interval here, but for now we'll just fall back to the jbd
-+ * default. */
-+}
-+
-+
-+static journal_t *ext3_get_journal(struct super_block *sb, int journal_inum)
-+{
-+ struct inode *journal_inode;
-+ journal_t *journal;
-+
-+ /* First, test for the existence of a valid inode on disk. Bad
-+ * things happen if we iget() an unused inode, as the subsequent
-+ * iput() will try to delete it. */
-+
-+ journal_inode = iget(sb, journal_inum);
-+ if (!journal_inode) {
-+ printk(KERN_ERR "EXT3-fs: no journal found.\n");
-+ return NULL;
-+ }
-+ if (!journal_inode->i_nlink) {
-+ make_bad_inode(journal_inode);
-+ iput(journal_inode);
-+ printk(KERN_ERR "EXT3-fs: journal inode is deleted.\n");
-+ return NULL;
-+ }
-+
-+ jbd_debug(2, "Journal inode found at %p: %Ld bytes\n",
-+ journal_inode, journal_inode->i_size);
-+ if (is_bad_inode(journal_inode) || !S_ISREG(journal_inode->i_mode)) {
-+ printk(KERN_ERR "EXT3-fs: invalid journal inode.\n");
-+ iput(journal_inode);
-+ return NULL;
-+ }
-+
-+ journal = journal_init_inode(journal_inode);
-+ if (!journal) {
-+ printk(KERN_ERR "EXT3-fs: Could not load journal inode\n");
-+ iput(journal_inode);
-+ }
-+ ext3_init_journal_params(EXT3_SB(sb), journal);
-+ return journal;
-+}
-+
-+static journal_t *ext3_get_dev_journal(struct super_block *sb,
-+ int dev)
-+{
-+ struct buffer_head * bh;
-+ journal_t *journal;
-+ int start;
-+ int len;
-+ int hblock, blocksize;
-+ unsigned long sb_block;
-+ unsigned long offset;
-+ kdev_t journal_dev = to_kdev_t(dev);
-+ struct ext3_super_block * es;
-+ struct block_device *bdev;
-+
-+ bdev = ext3_blkdev_get(journal_dev);
-+ if (bdev == NULL)
-+ return NULL;
-+
-+ blocksize = sb->s_blocksize;
-+ hblock = get_hardsect_size(journal_dev);
-+ if (blocksize < hblock) {
-+ printk(KERN_ERR
-+ "EXT3-fs: blocksize too small for journal device.\n");
-+ goto out_bdev;
-+ }
-+
-+ sb_block = EXT3_MIN_BLOCK_SIZE / blocksize;
-+ offset = EXT3_MIN_BLOCK_SIZE % blocksize;
-+ set_blocksize(dev, blocksize);
-+ if (!(bh = bread(dev, sb_block, blocksize))) {
-+ printk(KERN_ERR "EXT3-fs: couldn't read superblock of "
-+ "external journal\n");
-+ goto out_bdev;
-+ }
-+
-+ es = (struct ext3_super_block *) (((char *)bh->b_data) + offset);
-+ if ((le16_to_cpu(es->s_magic) != EXT3_SUPER_MAGIC) ||
-+ !(le32_to_cpu(es->s_feature_incompat) &
-+ EXT3_FEATURE_INCOMPAT_JOURNAL_DEV)) {
-+ printk(KERN_ERR "EXT3-fs: external journal has "
-+ "bad superblock\n");
-+ brelse(bh);
-+ goto out_bdev;
-+ }
-+
-+ if (memcmp(EXT3_SB(sb)->s_es->s_journal_uuid, es->s_uuid, 16)) {
-+ printk(KERN_ERR "EXT3-fs: journal UUID does not match\n");
-+ brelse(bh);
-+ goto out_bdev;
-+ }
-+
-+ len = le32_to_cpu(es->s_blocks_count);
-+ start = sb_block + 1;
-+ brelse(bh); /* we're done with the superblock */
-+
-+ journal = journal_init_dev(journal_dev, sb->s_dev,
-+ start, len, blocksize);
-+ if (!journal) {
-+ printk(KERN_ERR "EXT3-fs: failed to create device journal\n");
-+ goto out_bdev;
-+ }
-+ ll_rw_block(READ, 1, &journal->j_sb_buffer);
-+ wait_on_buffer(journal->j_sb_buffer);
-+ if (!buffer_uptodate(journal->j_sb_buffer)) {
-+ printk(KERN_ERR "EXT3-fs: I/O error on journal device\n");
-+ goto out_journal;
-+ }
-+ if (ntohl(journal->j_superblock->s_nr_users) != 1) {
-+ printk(KERN_ERR "EXT3-fs: External journal has more than one "
-+ "user (unsupported) - %d\n",
-+ ntohl(journal->j_superblock->s_nr_users));
-+ goto out_journal;
-+ }
-+ EXT3_SB(sb)->journal_bdev = bdev;
-+ ext3_init_journal_params(EXT3_SB(sb), journal);
-+ return journal;
-+out_journal:
-+ journal_destroy(journal);
-+out_bdev:
-+ ext3_blkdev_put(bdev);
-+ return NULL;
-+}
-+
-+static int ext3_load_journal(struct super_block * sb,
-+ struct ext3_super_block * es)
-+{
-+ journal_t *journal;
-+ int journal_inum = le32_to_cpu(es->s_journal_inum);
-+ int journal_dev = le32_to_cpu(es->s_journal_dev);
-+ int err = 0;
-+ int really_read_only;
-+
-+ really_read_only = is_read_only(sb->s_dev);
-+
-+ /*
-+ * Are we loading a blank journal or performing recovery after a
-+ * crash? For recovery, we need to check in advance whether we
-+ * can get read-write access to the device.
-+ */
-+
-+ if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER)) {
-+ if (sb->s_flags & MS_RDONLY) {
-+ printk(KERN_INFO "EXT3-fs: INFO: recovery "
-+ "required on readonly filesystem.\n");
-+ if (really_read_only) {
-+ printk(KERN_ERR "EXT3-fs: write access "
-+ "unavailable, cannot proceed.\n");
-+ return -EROFS;
-+ }
-+ printk (KERN_INFO "EXT3-fs: write access will "
-+ "be enabled during recovery.\n");
-+ }
-+ }
-+
-+ if (journal_inum && journal_dev) {
-+ printk(KERN_ERR "EXT3-fs: filesystem has both journal "
-+ "and inode journals!\n");
-+ return -EINVAL;
-+ }
-+
-+ if (journal_inum) {
-+ if (!(journal = ext3_get_journal(sb, journal_inum)))
-+ return -EINVAL;
-+ } else {
-+ if (!(journal = ext3_get_dev_journal(sb, journal_dev)))
-+ return -EINVAL;
-+ }
-+
-+
-+ if (!really_read_only && test_opt(sb, UPDATE_JOURNAL)) {
-+ err = journal_update_format(journal);
-+ if (err) {
-+ printk(KERN_ERR "EXT3-fs: error updating journal.\n");
-+ journal_destroy(journal);
-+ return err;
-+ }
-+ }
-+
-+ if (!EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER))
-+ err = journal_wipe(journal, !really_read_only);
-+ if (!err)
-+ err = journal_load(journal);
-+
-+ if (err) {
-+ printk(KERN_ERR "EXT3-fs: error loading journal.\n");
-+ journal_destroy(journal);
-+ return err;
-+ }
-+
-+ EXT3_SB(sb)->s_journal = journal;
-+ ext3_clear_journal_err(sb, es);
-+ return 0;
-+}
-+
-+static int ext3_create_journal(struct super_block * sb,
-+ struct ext3_super_block * es,
-+ int journal_inum)
-+{
-+ journal_t *journal;
-+
-+ if (sb->s_flags & MS_RDONLY) {
-+ printk(KERN_ERR "EXT3-fs: readonly filesystem when trying to "
-+ "create journal.\n");
-+ return -EROFS;
-+ }
-+
-+ if (!(journal = ext3_get_journal(sb, journal_inum)))
-+ return -EINVAL;
-+
-+ printk(KERN_INFO "EXT3-fs: creating new journal on inode %d\n",
-+ journal_inum);
-+
-+ if (journal_create(journal)) {
-+ printk(KERN_ERR "EXT3-fs: error creating journal.\n");
-+ journal_destroy(journal);
-+ return -EIO;
-+ }
-+
-+ EXT3_SB(sb)->s_journal = journal;
-+
-+ ext3_update_dynamic_rev(sb);
-+ EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
-+ EXT3_SET_COMPAT_FEATURE(sb, EXT3_FEATURE_COMPAT_HAS_JOURNAL);
-+
-+ es->s_journal_inum = cpu_to_le32(journal_inum);
-+ sb->s_dirt = 1;
-+
-+ /* Make sure we flush the recovery flag to disk. */
-+ ext3_commit_super(sb, es, 1);
-+
-+ return 0;
-+}
-+
-+static void ext3_commit_super (struct super_block * sb,
-+ struct ext3_super_block * es,
-+ int sync)
-+{
-+ es->s_wtime = cpu_to_le32(CURRENT_TIME);
-+ BUFFER_TRACE(sb->u.ext3_sb.s_sbh, "marking dirty");
-+ mark_buffer_dirty(sb->u.ext3_sb.s_sbh);
-+ if (sync) {
-+ ll_rw_block(WRITE, 1, &sb->u.ext3_sb.s_sbh);
-+ wait_on_buffer(sb->u.ext3_sb.s_sbh);
-+ }
-+}
-+
-+
-+/*
-+ * Have we just finished recovery? If so, and if we are mounting (or
-+ * remounting) the filesystem readonly, then we will end up with a
-+ * consistent fs on disk. Record that fact.
-+ */
-+static void ext3_mark_recovery_complete(struct super_block * sb,
-+ struct ext3_super_block * es)
-+{
-+ journal_flush(EXT3_SB(sb)->s_journal);
-+ if (EXT3_HAS_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER) &&
-+ sb->s_flags & MS_RDONLY) {
-+ EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
-+ sb->s_dirt = 0;
-+ ext3_commit_super(sb, es, 1);
-+ }
-+}
-+
-+/*
-+ * If we are mounting (or read-write remounting) a filesystem whose journal
-+ * has recorded an error from a previous lifetime, move that error to the
-+ * main filesystem now.
-+ */
-+static void ext3_clear_journal_err(struct super_block * sb,
-+ struct ext3_super_block * es)
-+{
-+ journal_t *journal;
-+ int j_errno;
-+ const char *errstr;
-+
-+ journal = EXT3_SB(sb)->s_journal;
-+
-+ /*
-+ * Now check for any error status which may have been recorded in the
-+ * journal by a prior ext3_error() or ext3_abort()
-+ */
-+
-+ j_errno = journal_errno(journal);
-+ if (j_errno) {
-+ char nbuf[16];
-+
-+ errstr = ext3_decode_error(sb, j_errno, nbuf);
-+ ext3_warning(sb, __FUNCTION__, "Filesystem error recorded "
-+ "from previous mount: %s", errstr);
-+ ext3_warning(sb, __FUNCTION__, "Marking fs in need of "
-+ "filesystem check.");
-+
-+ sb->u.ext3_sb.s_mount_state |= EXT3_ERROR_FS;
-+ es->s_state |= cpu_to_le16(EXT3_ERROR_FS);
-+ ext3_commit_super (sb, es, 1);
-+
-+ journal_clear_err(journal);
-+ }
-+}
-+
-+/*
-+ * Force the running and committing transactions to commit,
-+ * and wait on the commit.
-+ */
-+int ext3_force_commit(struct super_block *sb)
-+{
-+ journal_t *journal;
-+ int ret;
-+
-+ if (sb->s_flags & MS_RDONLY)
-+ return 0;
-+
-+ journal = EXT3_SB(sb)->s_journal;
-+ sb->s_dirt = 0;
-+ lock_kernel(); /* important: lock down j_running_transaction */
-+ ret = ext3_journal_force_commit(journal);
-+ unlock_kernel();
-+ return ret;
-+}
-+
-+/*
-+ * Ext3 always journals updates to the superblock itself, so we don't
-+ * have to propagate any other updates to the superblock on disk at this
-+ * point. Just start an async writeback to get the buffers on their way
-+ * to the disk.
-+ *
-+ * This implicitly triggers the writebehind on sync().
-+ */
-+
-+void ext3_write_super (struct super_block * sb)
-+{
-+ if (down_trylock(&sb->s_lock) == 0)
-+ BUG();
-+ sb->s_dirt = 0;
-+ log_start_commit(EXT3_SB(sb)->s_journal, NULL);
-+}
-+
-+static int ext3_sync_fs(struct super_block *sb)
-+{
-+ tid_t target;
-+
-+ sb->s_dirt = 0;
-+ target = log_start_commit(EXT3_SB(sb)->s_journal, NULL);
-+ log_wait_commit(EXT3_SB(sb)->s_journal, target);
-+ return 0;
-+}
-+
-+/*
-+ * LVM calls this function before a (read-only) snapshot is created. This
-+ * gives us a chance to flush the journal completely and mark the fs clean.
-+ */
-+void ext3_write_super_lockfs(struct super_block *sb)
-+{
-+ sb->s_dirt = 0;
-+
-+ lock_kernel(); /* 2.4.5 forgot to do this for us */
-+ if (!(sb->s_flags & MS_RDONLY)) {
-+ journal_t *journal = EXT3_SB(sb)->s_journal;
-+
-+ /* Now we set up the journal barrier. */
-+ unlock_super(sb);
-+ journal_lock_updates(journal);
-+ journal_flush(journal);
-+ lock_super(sb);
-+
-+ /* Journal blocked and flushed, clear needs_recovery flag. */
-+ EXT3_CLEAR_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
-+ ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
-+ }
-+ unlock_kernel();
-+}
-+
-+/*
-+ * Called by LVM after the snapshot is done. We need to reset the RECOVER
-+ * flag here, even though the filesystem is not technically dirty yet.
-+ */
-+void ext3_unlockfs(struct super_block *sb)
-+{
-+ if (!(sb->s_flags & MS_RDONLY)) {
-+ lock_kernel();
-+ lock_super(sb);
-+ /* Reser the needs_recovery flag before the fs is unlocked. */
-+ EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
-+ ext3_commit_super(sb, EXT3_SB(sb)->s_es, 1);
-+ unlock_super(sb);
-+ journal_unlock_updates(EXT3_SB(sb)->s_journal);
-+ unlock_kernel();
-+ }
-+}
-+
-+int ext3_remount (struct super_block * sb, int * flags, char * data)
-+{
-+ struct ext3_super_block * es;
-+ struct ext3_sb_info *sbi = EXT3_SB(sb);
-+ unsigned long tmp;
-+
-+ clear_ro_after(sb);
-+
-+ /*
-+ * Allow the "check" option to be passed as a remount option.
-+ */
-+ if (!parse_options(data, &tmp, sbi, &tmp, 1))
-+ return -EINVAL;
-+
-+ if (sbi->s_mount_opt & EXT3_MOUNT_ABORT)
-+ ext3_abort(sb, __FUNCTION__, "Abort forced by user");
-+
-+ es = sbi->s_es;
-+
-+ ext3_init_journal_params(sbi, sbi->s_journal);
-+
-+ if ((*flags & MS_RDONLY) != (sb->s_flags & MS_RDONLY)) {
-+ if (sbi->s_mount_opt & EXT3_MOUNT_ABORT)
-+ return -EROFS;
-+
-+ if (*flags & MS_RDONLY) {
-+ /*
-+ * First of all, the unconditional stuff we have to do
-+ * to disable replay of the journal when we next remount
-+ */
-+ sb->s_flags |= MS_RDONLY;
-+
-+ /*
-+ * OK, test if we are remounting a valid rw partition
-+ * readonly, and if so set the rdonly flag and then
-+ * mark the partition as valid again.
-+ */
-+ if (!(es->s_state & cpu_to_le16(EXT3_VALID_FS)) &&
-+ (sbi->s_mount_state & EXT3_VALID_FS))
-+ es->s_state = cpu_to_le16(sbi->s_mount_state);
-+
-+ ext3_mark_recovery_complete(sb, es);
-+ } else {
-+ int ret;
-+ if ((ret = EXT3_HAS_RO_COMPAT_FEATURE(sb,
-+ ~EXT3_FEATURE_RO_COMPAT_SUPP))) {
-+ printk(KERN_WARNING "EXT3-fs: %s: couldn't "
-+ "remount RDWR because of unsupported "
-+ "optional features (%x).\n",
-+ bdevname(sb->s_dev), ret);
-+ return -EROFS;
-+ }
-+ /*
-+ * Mounting a RDONLY partition read-write, so reread
-+ * and store the current valid flag. (It may have
-+ * been changed by e2fsck since we originally mounted
-+ * the partition.)
-+ */
-+ ext3_clear_journal_err(sb, es);
-+ sbi->s_mount_state = le16_to_cpu(es->s_state);
-+ if (!ext3_setup_super (sb, es, 0))
-+ sb->s_flags &= ~MS_RDONLY;
-+ }
-+ }
-+ setup_ro_after(sb);
-+ return 0;
-+}
-+
-+int ext3_statfs (struct super_block * sb, struct statfs * buf)
-+{
-+ struct ext3_super_block *es = EXT3_SB(sb)->s_es;
-+ unsigned long overhead;
-+ int i;
-+
-+ if (test_opt (sb, MINIX_DF))
-+ overhead = 0;
-+ else {
-+ /*
-+ * Compute the overhead (FS structures)
-+ */
-+
-+ /*
-+ * All of the blocks before first_data_block are
-+ * overhead
-+ */
-+ overhead = le32_to_cpu(es->s_first_data_block);
-+
-+ /*
-+ * Add the overhead attributed to the superblock and
-+ * block group descriptors. If the sparse superblocks
-+ * feature is turned on, then not all groups have this.
-+ */
-+ for (i = 0; i < EXT3_SB(sb)->s_groups_count; i++)
-+ overhead += ext3_bg_has_super(sb, i) +
-+ ext3_bg_num_gdb(sb, i);
-+
-+ /*
-+ * Every block group has an inode bitmap, a block
-+ * bitmap, and an inode table.
-+ */
-+ overhead += (EXT3_SB(sb)->s_groups_count *
-+ (2 + EXT3_SB(sb)->s_itb_per_group));
-+ }
-+
-+ buf->f_type = EXT3_SUPER_MAGIC;
-+ buf->f_bsize = sb->s_blocksize;
-+ buf->f_blocks = le32_to_cpu(es->s_blocks_count) - overhead;
-+ buf->f_bfree = ext3_count_free_blocks (sb);
-+ buf->f_bavail = buf->f_bfree - le32_to_cpu(es->s_r_blocks_count);
-+ if (buf->f_bfree < le32_to_cpu(es->s_r_blocks_count))
-+ buf->f_bavail = 0;
-+ buf->f_files = le32_to_cpu(es->s_inodes_count);
-+ buf->f_ffree = ext3_count_free_inodes (sb);
-+ buf->f_namelen = EXT3_NAME_LEN;
-+ return 0;
-+}
-+
-+static DECLARE_FSTYPE_DEV(ext3_fs_type, "ext3", ext3_read_super);
-+
-+static int __init init_ext3_fs(void)
-+{
-+ return register_filesystem(&ext3_fs_type);
-+}
-+
-+static void __exit exit_ext3_fs(void)
-+{
-+ unregister_filesystem(&ext3_fs_type);
-+}
-+
+ obj-y := balloc.o bitmap.o dir.o file.o fsync.o ialloc.o inode.o \
+ ioctl.o namei.o super.o symlink.o
+ obj-m := $(O_TARGET)
+--- linux-2.4.20-hp4_pnnl1/fs/ext3/super.c~exports_hp Tue Apr 1 20:36:07 2003
++++ linux-2.4.20-hp4_pnnl1-braam/fs/ext3/super.c Tue Apr 1 20:36:07 2003
+@@ -1769,7 +1769,7 @@
+ unregister_filesystem(&ext3_fs_type);
+ }
+
+-EXPORT_NO_SYMBOLS;
+EXPORT_SYMBOL(ext3_bread);
-+
-+MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
-+MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
-+MODULE_LICENSE("GPL");
-+module_init(init_ext3_fs)
-+module_exit(exit_ext3_fs)
---- /dev/null Fri Aug 30 17:31:37 2002
-+++ linux-rh-2.4.20-6-braam/include/linux/fs.h Mon Mar 31 23:46:17 2003
-@@ -0,0 +1,1680 @@
-+#ifndef _LINUX_FS_H
-+#define _LINUX_FS_H
-+
-+/*
-+ * This file has definitions for some important file table
-+ * structures etc.
-+ */
-+
-+#include <linux/config.h>
-+#include <linux/linkage.h>
-+#include <linux/limits.h>
-+#include <linux/wait.h>
-+#include <linux/types.h>
-+#include <linux/vfs.h>
-+#include <linux/net.h>
-+#include <linux/kdev_t.h>
-+#include <linux/ioctl.h>
-+#include <linux/list.h>
-+#include <linux/dcache.h>
-+#include <linux/stat.h>
-+#include <linux/cache.h>
-+#include <linux/stddef.h>
-+#include <linux/string.h>
-+
-+#include <asm/atomic.h>
-+#include <asm/bitops.h>
-+
-+struct poll_table_struct;
-+
-+
-+/*
-+ * It's silly to have NR_OPEN bigger than NR_FILE, but you can change
-+ * the file limit at runtime and only root can increase the per-process
-+ * nr_file rlimit, so it's safe to set up a ridiculously high absolute
-+ * upper limit on files-per-process.
-+ *
-+ * Some programs (notably those using select()) may have to be
-+ * recompiled to take full advantage of the new limits..
-+ */
-+
-+/* Fixed constants first: */
-+#undef NR_OPEN
-+#define NR_OPEN (1024*1024) /* Absolute upper limit on fd num */
-+#define INR_OPEN 1024 /* Initial setting for nfile rlimits */
-+
-+#define BLOCK_SIZE_BITS 10
-+#define BLOCK_SIZE (1<<BLOCK_SIZE_BITS)
-+
-+/* And dynamically-tunable limits and defaults: */
-+struct files_stat_struct {
-+ int nr_files; /* read only */
-+ int nr_free_files; /* read only */
-+ int max_files; /* tunable */
-+};
-+extern struct files_stat_struct files_stat;
-+
-+struct inodes_stat_t {
-+ int nr_inodes;
-+ int nr_unused;
-+ int dummy[5];
-+};
-+extern struct inodes_stat_t inodes_stat;
-+
-+extern int leases_enable, dir_notify_enable, lease_break_time;
-+
-+#define NR_FILE 8192 /* this can well be larger on a larger system */
-+#define NR_RESERVED_FILES 10 /* reserved for root */
-+#define NR_SUPER 256
-+
-+#define MAY_EXEC 1
-+#define MAY_WRITE 2
-+#define MAY_READ 4
-+
-+#define FMODE_READ 1
-+#define FMODE_WRITE 2
-+
-+#define READ 0
-+#define WRITE 1
-+#define READA 2 /* read-ahead - don't block if no resources */
-+#define SPECIAL 4 /* For non-blockdevice requests in request queue */
-+
-+#define SEL_IN 1
-+#define SEL_OUT 2
-+#define SEL_EX 4
-+
-+/* public flags for file_system_type */
-+#define FS_REQUIRES_DEV 1
-+#define FS_NO_DCACHE 2 /* Only dcache the necessary things. */
-+#define FS_NO_PRELIM 4 /* prevent preloading of dentries, even if
-+ * FS_NO_DCACHE is not set.
-+ */
-+#define FS_SINGLE 8 /* Filesystem that can have only one superblock */
-+#define FS_NOMOUNT 16 /* Never mount from userland */
-+#define FS_LITTER 32 /* Keeps the tree in dcache */
-+#define FS_ODD_RENAME 32768 /* Temporary stuff; will go away as soon
-+ * as nfs_rename() will be cleaned up
-+ */
-+/*
-+ * These are the fs-independent mount-flags: up to 32 flags are supported
-+ */
-+#define MS_RDONLY 1 /* Mount read-only */
-+#define MS_NOSUID 2 /* Ignore suid and sgid bits */
-+#define MS_NODEV 4 /* Disallow access to device special files */
-+#define MS_NOEXEC 8 /* Disallow program execution */
-+#define MS_SYNCHRONOUS 16 /* Writes are synced at once */
-+#define MS_REMOUNT 32 /* Alter flags of a mounted FS */
-+#define MS_MANDLOCK 64 /* Allow mandatory locks on an FS */
-+#define MS_NOATIME 1024 /* Do not update access times. */
-+#define MS_NODIRATIME 2048 /* Do not update directory access times */
-+#define MS_BIND 4096
-+#define MS_MOVE 8192
-+#define MS_REC 16384
-+#define MS_VERBOSE 32768
-+#define MS_ACTIVE (1<<30)
-+#define MS_NOUSER (1<<31)
-+
-+/*
-+ * Superblock flags that can be altered by MS_REMOUNT
-+ */
-+#define MS_RMT_MASK (MS_RDONLY|MS_SYNCHRONOUS|MS_MANDLOCK|MS_NOATIME|\
-+ MS_NODIRATIME)
-+
-+/*
-+ * Old magic mount flag and mask
-+ */
-+#define MS_MGC_VAL 0xC0ED0000
-+#define MS_MGC_MSK 0xffff0000
-+
-+/* Inode flags - they have nothing to superblock flags now */
-+
-+#define S_SYNC 1 /* Writes are synced at once */
-+#define S_NOATIME 2 /* Do not update access times */
-+#define S_QUOTA 4 /* Quota initialized for file */
-+#define S_APPEND 8 /* Append-only file */
-+#define S_IMMUTABLE 16 /* Immutable file */
-+#define S_DEAD 32 /* removed, but still open directory */
-+#define S_NOQUOTA 64 /* Inode is not counted to quota */
-+
-+/*
-+ * Note that nosuid etc flags are inode-specific: setting some file-system
-+ * flags just means all the inodes inherit those flags by default. It might be
-+ * possible to override it selectively if you really wanted to with some
-+ * ioctl() that is not currently implemented.
-+ *
-+ * Exception: MS_RDONLY is always applied to the entire file system.
-+ *
-+ * Unfortunately, it is possible to change a filesystems flags with it mounted
-+ * with files in use. This means that all of the inodes will not have their
-+ * i_flags updated. Hence, i_flags no longer inherit the superblock mount
-+ * flags, so these have to be checked separately. -- rmk@arm.uk.linux.org
-+ */
-+#define __IS_FLG(inode,flg) ((inode)->i_sb->s_flags & (flg))
-+
-+#define IS_RDONLY(inode) ((inode)->i_sb->s_flags & MS_RDONLY)
-+#define IS_SYNC(inode) (__IS_FLG(inode, MS_SYNCHRONOUS) || ((inode)->i_flags & S_SYNC))
-+#define IS_MANDLOCK(inode) __IS_FLG(inode, MS_MANDLOCK)
-+
-+#define IS_QUOTAINIT(inode) ((inode)->i_flags & S_QUOTA)
-+#define IS_NOQUOTA(inode) ((inode)->i_flags & S_NOQUOTA)
-+#define IS_APPEND(inode) ((inode)->i_flags & S_APPEND)
-+#define IS_IMMUTABLE(inode) ((inode)->i_flags & S_IMMUTABLE)
-+#define IS_NOATIME(inode) (__IS_FLG(inode, MS_NOATIME) || ((inode)->i_flags & S_NOATIME))
-+#define IS_NODIRATIME(inode) __IS_FLG(inode, MS_NODIRATIME)
-+
-+#define IS_DEADDIR(inode) ((inode)->i_flags & S_DEAD)
-+
-+/* the read-only stuff doesn't really belong here, but any other place is
-+ probably as bad and I don't want to create yet another include file. */
-+
-+#define BLKROSET _IO(0x12,93) /* set device read-only (0 = read-write) */
-+#define BLKROGET _IO(0x12,94) /* get read-only status (0 = read_write) */
-+#define BLKRRPART _IO(0x12,95) /* re-read partition table */
-+#define BLKGETSIZE _IO(0x12,96) /* return device size /512 (long *arg) */
-+#define BLKFLSBUF _IO(0x12,97) /* flush buffer cache */
-+#define BLKRASET _IO(0x12,98) /* Set read ahead for block device */
-+#define BLKRAGET _IO(0x12,99) /* get current read ahead setting */
-+#define BLKFRASET _IO(0x12,100)/* set filesystem (mm/filemap.c) read-ahead */
-+#define BLKFRAGET _IO(0x12,101)/* get filesystem (mm/filemap.c) read-ahead */
-+#define BLKSECTSET _IO(0x12,102)/* set max sectors per request (ll_rw_blk.c) */
-+#define BLKSECTGET _IO(0x12,103)/* get max sectors per request (ll_rw_blk.c) */
-+#define BLKSSZGET _IO(0x12,104)/* get block device sector size */
-+#if 0
-+#define BLKPG _IO(0x12,105)/* See blkpg.h */
-+#define BLKELVGET _IOR(0x12,106,sizeof(blkelv_ioctl_arg_t))/* elevator get */
-+#define BLKELVSET _IOW(0x12,107,sizeof(blkelv_ioctl_arg_t))/* elevator set */
-+/* This was here just to show that the number is taken -
-+ probably all these _IO(0x12,*) ioctls should be moved to blkpg.h. */
-+#endif
-+/* A jump here: 108-111 have been used for various private purposes. */
-+#define BLKBSZGET _IOR(0x12,112,sizeof(int))
-+#define BLKBSZSET _IOW(0x12,113,sizeof(int))
-+#define BLKGETSIZE64 _IOR(0x12,114,sizeof(u64)) /* return device size in bytes (u64 *arg) */
-+
-+#define BMAP_IOCTL 1 /* obsolete - kept for compatibility */
-+#define FIBMAP _IO(0x00,1) /* bmap access */
-+#define FIGETBSZ _IO(0x00,2) /* get the block size used for bmap */
-+
-+#ifdef __KERNEL__
-+
-+#include <asm/semaphore.h>
-+#include <asm/byteorder.h>
-+
-+extern void update_atime (struct inode *);
-+#define UPDATE_ATIME(inode) update_atime (inode)
-+
-+extern void buffer_init(unsigned long);
-+extern void inode_init(unsigned long);
-+extern void mnt_init(unsigned long);
-+extern void files_init(unsigned long mempages);
-+extern void majorhog_init(void);
-+
-+/* bh state bits */
-+enum bh_state_bits {
-+ BH_Uptodate, /* 1 if the buffer contains valid data */
-+ BH_Dirty, /* 1 if the buffer is dirty */
-+ BH_Lock, /* 1 if the buffer is locked */
-+ BH_Req, /* 0 if the buffer has been invalidated */
-+ BH_Mapped, /* 1 if the buffer has a disk mapping */
-+ BH_New, /* 1 if the buffer is new and not yet written out */
-+ BH_Async, /* 1 if the buffer is under end_buffer_io_async I/O */
-+ BH_Wait_IO, /* 1 if we should write out this buffer */
-+ BH_Launder, /* 1 if we can throttle on this buffer */
-+ BH_Attached, /* 1 if b_inode_buffers is linked into a list */
-+ BH_JBD, /* 1 if it has an attached journal_head */
-+
-+ BH_PrivateStart,/* not a state bit, but the first bit available
-+ * for private allocation by other entities
-+ */
-+};
-+
-+#define MAX_BUF_PER_PAGE (PAGE_CACHE_SIZE / 512)
-+
-+/*
-+ * Try to keep the most commonly used fields in single cache lines (16
-+ * bytes) to improve performance. This ordering should be
-+ * particularly beneficial on 32-bit processors.
-+ *
-+ * We use the first 16 bytes for the data which is used in searches
-+ * over the block hash lists (ie. getblk() and friends).
-+ *
-+ * The second 16 bytes we use for lru buffer scans, as used by
-+ * sync_buffers() and refill_freelist(). -- sct
-+ */
-+struct buffer_head {
-+ /* First cache line: */
-+ struct buffer_head *b_next; /* Hash queue list */
-+ unsigned long b_blocknr; /* block number */
-+ unsigned short b_size; /* block size */
-+ unsigned short b_list; /* List that this buffer appears */
-+ kdev_t b_dev; /* device (B_FREE = free) */
-+
-+ atomic_t b_count; /* users using this block */
-+ kdev_t b_rdev; /* Real device */
-+ unsigned long b_state; /* buffer state bitmap (see above) */
-+ unsigned long b_flushtime; /* Time when (dirty) buffer should be written */
-+
-+ struct buffer_head *b_next_free;/* lru/free list linkage */
-+ struct buffer_head *b_prev_free;/* doubly linked list of buffers */
-+ struct buffer_head *b_this_page;/* circular list of buffers in one page */
-+ struct buffer_head *b_reqnext; /* request queue */
-+
-+ struct buffer_head **b_pprev; /* doubly linked list of hash-queue */
-+ char * b_data; /* pointer to data block */
-+ struct page *b_page; /* the page this bh is mapped to */
-+ void (*b_end_io)(struct buffer_head *bh, int uptodate); /* I/O completion */
-+ void *b_private; /* reserved for b_end_io */
-+ void *b_journal_head; /* ext3 journal_heads */
-+ unsigned long b_rsector; /* Real buffer location on disk */
-+ wait_queue_head_t b_wait;
-+
-+ struct list_head b_inode_buffers; /* doubly linked list of inode dirty buffers */
-+};
-+
-+typedef void (bh_end_io_t)(struct buffer_head *bh, int uptodate);
-+void init_buffer(struct buffer_head *, bh_end_io_t *, void *);
-+
-+#define __buffer_state(bh, state) (((bh)->b_state & (1UL << BH_##state)) != 0)
-+
-+#define buffer_uptodate(bh) __buffer_state(bh,Uptodate)
-+#define buffer_dirty(bh) __buffer_state(bh,Dirty)
-+#define buffer_locked(bh) __buffer_state(bh,Lock)
-+#define buffer_req(bh) __buffer_state(bh,Req)
-+#define buffer_mapped(bh) __buffer_state(bh,Mapped)
-+#define buffer_new(bh) __buffer_state(bh,New)
-+#define buffer_async(bh) __buffer_state(bh,Async)
-+#define buffer_launder(bh) __buffer_state(bh,Launder)
-+
-+#define bh_offset(bh) ((unsigned long)(bh)->b_data & ~PAGE_MASK)
-+
-+extern void set_bh_page(struct buffer_head *bh, struct page *page, unsigned long offset);
-+
-+#define touch_buffer(bh) mark_page_accessed(bh->b_page)
-+
-+
-+#include <linux/pipe_fs_i.h>
-+#include <linux/minix_fs_i.h>
-+#include <linux/ext2_fs_i.h>
-+#include <linux/ext3_fs_i.h>
-+#include <linux/hpfs_fs_i.h>
-+#include <linux/ntfs_fs_i.h>
-+#include <linux/msdos_fs_i.h>
-+#include <linux/umsdos_fs_i.h>
-+#include <linux/iso_fs_i.h>
-+#include <linux/nfs_fs_i.h>
-+#include <linux/sysv_fs_i.h>
-+#include <linux/affs_fs_i.h>
-+#include <linux/ufs_fs_i.h>
-+#include <linux/efs_fs_i.h>
-+#include <linux/coda_fs_i.h>
-+#include <linux/romfs_fs_i.h>
-+#include <linux/shmem_fs.h>
-+#include <linux/smb_fs_i.h>
-+#include <linux/hfs_fs_i.h>
-+#include <linux/adfs_fs_i.h>
-+#include <linux/qnx4_fs_i.h>
-+#include <linux/reiserfs_fs_i.h>
-+#include <linux/bfs_fs_i.h>
-+#include <linux/udf_fs_i.h>
-+#include <linux/ncp_fs_i.h>
-+#include <linux/proc_fs_i.h>
-+#include <linux/usbdev_fs_i.h>
-+#include <linux/jffs2_fs_i.h>
-+#include <linux/cramfs_fs_sb.h>
-+
-+/*
-+ * Attribute flags. These should be or-ed together to figure out what
-+ * has been changed!
-+ */
-+#define ATTR_MODE 1
-+#define ATTR_UID 2
-+#define ATTR_GID 4
-+#define ATTR_SIZE 8
-+#define ATTR_ATIME 16
-+#define ATTR_MTIME 32
-+#define ATTR_CTIME 64
-+#define ATTR_ATIME_SET 128
-+#define ATTR_MTIME_SET 256
-+#define ATTR_FORCE 512 /* Not a change, but a change it */
-+#define ATTR_ATTR_FLAG 1024
-+
-+/*
-+ * This is the Inode Attributes structure, used for notify_change(). It
-+ * uses the above definitions as flags, to know which values have changed.
-+ * Also, in this manner, a Filesystem can look at only the values it cares
-+ * about. Basically, these are the attributes that the VFS layer can
-+ * request to change from the FS layer.
-+ *
-+ * Derek Atkins <warlord@MIT.EDU> 94-10-20
-+ */
-+struct iattr {
-+ unsigned int ia_valid;
-+ umode_t ia_mode;
-+ uid_t ia_uid;
-+ gid_t ia_gid;
-+ loff_t ia_size;
-+ time_t ia_atime;
-+ time_t ia_mtime;
-+ time_t ia_ctime;
-+ unsigned int ia_attr_flags;
-+};
-+
-+/*
-+ * This is the inode attributes flag definitions
-+ */
-+#define ATTR_FLAG_SYNCRONOUS 1 /* Syncronous write */
-+#define ATTR_FLAG_NOATIME 2 /* Don't update atime */
-+#define ATTR_FLAG_APPEND 4 /* Append-only file */
-+#define ATTR_FLAG_IMMUTABLE 8 /* Immutable file */
-+#define ATTR_FLAG_NODIRATIME 16 /* Don't update atime for directory */
-+
-+/*
-+ * Includes for diskquotas and mount structures.
-+ */
-+#include <linux/quota.h>
-+#include <linux/mount.h>
-+
-+/*
-+ * oh the beauties of C type declarations.
-+ */
-+struct page;
-+struct address_space;
-+struct kiobuf;
-+
-+struct address_space_operations {
-+ int (*writepage)(struct page *);
-+ int (*readpage)(struct file *, struct page *);
-+ int (*sync_page)(struct page *);
-+ /*
-+ * ext3 requires that a successful prepare_write() call be followed
-+ * by a commit_write() call - they must be balanced
-+ */
-+ int (*prepare_write)(struct file *, struct page *, unsigned, unsigned);
-+ int (*commit_write)(struct file *, struct page *, unsigned, unsigned);
-+ /* Unfortunately this kludge is needed for FIBMAP. Don't use it */
-+ int (*bmap)(struct address_space *, long);
-+ int (*flushpage) (struct page *, unsigned long);
-+ int (*releasepage) (struct page *, int);
-+#define KERNEL_HAS_O_DIRECT /* this is for modules out of the kernel */
-+ int (*direct_IO)(int, struct inode *, struct kiobuf *, unsigned long, int);
-+ void (*removepage)(struct page *); /* called when page gets removed from the inode */
-+};
-+
-+struct address_space {
-+ struct list_head clean_pages; /* list of clean pages */
-+ struct list_head dirty_pages; /* list of dirty pages */
-+ struct list_head locked_pages; /* list of locked pages */
-+ unsigned long nrpages; /* number of total pages */
-+ struct address_space_operations *a_ops; /* methods */
-+ struct inode *host; /* owner: inode, block_device */
-+ struct vm_area_struct *i_mmap; /* list of private mappings */
-+ struct vm_area_struct *i_mmap_shared; /* list of shared mappings */
-+ spinlock_t i_shared_lock; /* and spinlock protecting it */
-+ int gfp_mask; /* how to allocate the pages */
-+};
-+
-+struct char_device {
-+ struct list_head hash;
-+ atomic_t count;
-+ dev_t dev;
-+ atomic_t openers;
-+ struct semaphore sem;
-+};
-+
-+struct block_device {
-+ struct list_head bd_hash;
-+ atomic_t bd_count;
-+ struct inode * bd_inode;
-+ dev_t bd_dev; /* not a kdev_t - it's a search key */
-+ int bd_openers;
-+ const struct block_device_operations *bd_op;
-+ struct semaphore bd_sem; /* open/close mutex */
-+ struct list_head bd_inodes;
-+};
-+
-+struct inode {
-+ struct list_head i_hash;
-+ struct list_head i_list;
-+ struct list_head i_dentry;
-+
-+ struct list_head i_dirty_buffers;
-+ struct list_head i_dirty_data_buffers;
-+
-+ unsigned long i_ino;
-+ atomic_t i_count;
-+ kdev_t i_dev;
-+ umode_t i_mode;
-+ unsigned int i_nlink;
-+ uid_t i_uid;
-+ gid_t i_gid;
-+ kdev_t i_rdev;
-+ loff_t i_size;
-+ time_t i_atime;
-+ time_t i_mtime;
-+ time_t i_ctime;
-+ unsigned int i_blkbits;
-+ unsigned long i_blksize;
-+ unsigned long i_blocks;
-+ unsigned long i_version;
-+ unsigned short i_bytes;
-+ struct semaphore i_sem;
-+ struct semaphore i_zombie;
-+ struct inode_operations *i_op;
-+ struct file_operations *i_fop; /* former ->i_op->default_file_ops */
-+ struct super_block *i_sb;
-+ wait_queue_head_t i_wait;
-+ struct file_lock *i_flock;
-+ struct address_space *i_mapping;
-+ struct address_space i_data;
-+ struct dquot *i_dquot[MAXQUOTAS];
-+ /* These three should probably be a union */
-+ struct list_head i_devices;
-+ struct pipe_inode_info *i_pipe;
-+ struct block_device *i_bdev;
-+ struct char_device *i_cdev;
-+
-+ unsigned long i_dnotify_mask; /* Directory notify events */
-+ struct dnotify_struct *i_dnotify; /* for directory notifications */
-+
-+ unsigned long i_state;
-+
-+ unsigned int i_flags;
-+ unsigned char i_sock;
-+
-+ atomic_t i_writecount;
-+ unsigned int i_attr_flags;
-+ __u32 i_generation;
-+ union {
-+ struct minix_inode_info minix_i;
-+ struct ext2_inode_info ext2_i;
-+ struct ext3_inode_info ext3_i;
-+ struct hpfs_inode_info hpfs_i;
-+ struct ntfs_inode_info ntfs_i;
-+ struct msdos_inode_info msdos_i;
-+ struct umsdos_inode_info umsdos_i;
-+ struct iso_inode_info isofs_i;
-+ struct nfs_inode_info nfs_i;
-+ struct sysv_inode_info sysv_i;
-+ struct affs_inode_info affs_i;
-+ struct ufs_inode_info ufs_i;
-+ struct efs_inode_info efs_i;
-+ struct romfs_inode_info romfs_i;
-+ struct shmem_inode_info shmem_i;
-+ struct coda_inode_info coda_i;
-+ struct smb_inode_info smbfs_i;
-+ struct hfs_inode_info hfs_i;
-+ struct adfs_inode_info adfs_i;
-+ struct qnx4_inode_info qnx4_i;
-+ struct reiserfs_inode_info reiserfs_i;
-+ struct bfs_inode_info bfs_i;
-+ struct udf_inode_info udf_i;
-+ struct ncp_inode_info ncpfs_i;
-+ struct proc_inode_info proc_i;
-+ struct socket socket_i;
-+ struct usbdev_inode_info usbdev_i;
-+ struct jffs2_inode_info jffs2_i;
-+ void *generic_ip;
-+ } u;
-+};
-+
-+static inline void inode_add_bytes(struct inode *inode, loff_t bytes)
-+{
-+ inode->i_blocks += bytes >> 9;
-+ bytes &= 511;
-+ inode->i_bytes += bytes;
-+ if (inode->i_bytes >= 512) {
-+ inode->i_blocks++;
-+ inode->i_bytes -= 512;
-+ }
-+}
-+
-+static inline void inode_sub_bytes(struct inode *inode, loff_t bytes)
-+{
-+ inode->i_blocks -= bytes >> 9;
-+ bytes &= 511;
-+ if (inode->i_bytes < bytes) {
-+ inode->i_blocks--;
-+ inode->i_bytes += 512;
-+ }
-+ inode->i_bytes -= bytes;
-+}
-+
-+static inline loff_t inode_get_bytes(struct inode *inode)
-+{
-+ return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
-+}
-+
-+static inline void inode_set_bytes(struct inode *inode, loff_t bytes)
-+{
-+ inode->i_blocks = bytes >> 9;
-+ inode->i_bytes = bytes & 511;
-+}
-+
-+struct fown_struct {
-+ int pid; /* pid or -pgrp where SIGIO should be sent */
-+ uid_t uid, euid; /* uid/euid of process setting the owner */
-+ int signum; /* posix.1b rt signal to be delivered on IO */
-+};
-+
-+struct file {
-+ struct list_head f_list;
-+ struct dentry *f_dentry;
-+ struct vfsmount *f_vfsmnt;
-+ struct file_operations *f_op;
-+ atomic_t f_count;
-+ unsigned int f_flags;
-+ mode_t f_mode;
-+ loff_t f_pos;
-+ unsigned long f_reada, f_ramax, f_raend, f_ralen, f_rawin;
-+ struct fown_struct f_owner;
-+ unsigned int f_uid, f_gid;
-+ int f_error;
-+
-+ unsigned long f_version;
-+
-+ /* needed for tty driver, and maybe others */
-+ void *private_data;
-+
-+ /* preallocated helper kiobuf to speedup O_DIRECT */
-+ struct kiobuf *f_iobuf;
-+ long f_iobuf_lock;
-+};
-+extern spinlock_t files_lock;
-+#define file_list_lock() spin_lock(&files_lock);
-+#define file_list_unlock() spin_unlock(&files_lock);
-+
-+#define get_file(x) atomic_inc(&(x)->f_count)
-+#define file_count(x) atomic_read(&(x)->f_count)
-+
-+extern int init_private_file(struct file *, struct dentry *, int);
-+
-+#define MAX_NON_LFS ((1UL<<31) - 1)
-+
-+/* Page cache limit. The filesystems should put that into their s_maxbytes
-+ limits, otherwise bad things can happen in VM. */
-+#if BITS_PER_LONG==32
-+#define MAX_LFS_FILESIZE (((u64)PAGE_CACHE_SIZE << (BITS_PER_LONG-1))-1)
-+#elif BITS_PER_LONG==64
-+#define MAX_LFS_FILESIZE 0x7fffffffffffffff
-+#endif
-+
-+#define FL_POSIX 1
-+#define FL_FLOCK 2
-+#define FL_BROKEN 4 /* broken flock() emulation */
-+#define FL_ACCESS 8 /* for processes suspended by mandatory locking */
-+#define FL_LOCKD 16 /* lock held by rpc.lockd */
-+#define FL_LEASE 32 /* lease held on this file */
-+
-+/*
-+ * The POSIX file lock owner is determined by
-+ * the "struct files_struct" in the thread group
-+ * (or NULL for no owner - BSD locks).
-+ *
-+ * Lockd stuffs a "host" pointer into this.
-+ */
-+typedef struct files_struct *fl_owner_t;
-+
-+struct file_lock {
-+ struct file_lock *fl_next; /* singly linked list for this inode */
-+ struct list_head fl_link; /* doubly linked list of all locks */
-+ struct list_head fl_block; /* circular list of blocked processes */
-+ fl_owner_t fl_owner;
-+ unsigned int fl_pid;
-+ wait_queue_head_t fl_wait;
-+ struct file *fl_file;
-+ unsigned char fl_flags;
-+ unsigned char fl_type;
-+ loff_t fl_start;
-+ loff_t fl_end;
-+
-+ void (*fl_notify)(struct file_lock *); /* unblock callback */
-+ void (*fl_insert)(struct file_lock *); /* lock insertion callback */
-+ void (*fl_remove)(struct file_lock *); /* lock removal callback */
-+
-+ struct fasync_struct * fl_fasync; /* for lease break notifications */
-+ unsigned long fl_break_time; /* for nonblocking lease breaks */
-+
-+ union {
-+ struct nfs_lock_info nfs_fl;
-+ } fl_u;
-+};
-+
-+/* The following constant reflects the upper bound of the file/locking space */
-+#ifndef OFFSET_MAX
-+#define INT_LIMIT(x) (~((x)1 << (sizeof(x)*8 - 1)))
-+#define OFFSET_MAX INT_LIMIT(loff_t)
-+#define OFFT_OFFSET_MAX INT_LIMIT(off_t)
-+#endif
-+
-+extern struct list_head file_lock_list;
-+
-+#include <linux/fcntl.h>
-+
-+extern int fcntl_getlk(unsigned int, struct flock *);
-+extern int fcntl_setlk(unsigned int, unsigned int, struct flock *);
-+extern asmlinkage long sys_fcntl(unsigned int fd, unsigned int cmd, unsigned long arg);
-+extern asmlinkage long sys_dup(unsigned int fildes);
-+extern asmlinkage long sys_dup2(unsigned int oldfd, unsigned int newfd);
-+extern asmlinkage ssize_t sys_read(unsigned int fd, char * buf, size_t count);
-+extern asmlinkage ssize_t sys_write(unsigned int fd, const char * buf, size_t count);
-+extern asmlinkage long sys_chroot(const char * filename);
-+extern asmlinkage long sys_chdir(const char * filename);
-+
-+
-+extern int fcntl_getlk64(unsigned int, struct flock64 *);
-+extern int fcntl_setlk64(unsigned int, unsigned int, struct flock64 *);
-+
-+/* fs/locks.c */
-+extern void locks_init_lock(struct file_lock *);
-+extern void locks_copy_lock(struct file_lock *, struct file_lock *);
-+extern void locks_remove_posix(struct file *, fl_owner_t);
-+extern void locks_remove_flock(struct file *);
-+extern struct file_lock *posix_test_lock(struct file *, struct file_lock *);
-+extern int posix_lock_file(struct file *, struct file_lock *, unsigned int);
-+extern void posix_block_lock(struct file_lock *, struct file_lock *);
-+extern void posix_unblock_lock(struct file_lock *);
-+extern int posix_locks_deadlock(struct file_lock *, struct file_lock *);
-+extern int __get_lease(struct inode *inode, unsigned int flags);
-+extern time_t lease_get_mtime(struct inode *);
-+extern int lock_may_read(struct inode *, loff_t start, unsigned long count);
-+extern int lock_may_write(struct inode *, loff_t start, unsigned long count);
-+
-+struct fasync_struct {
-+ int magic;
-+ int fa_fd;
-+ struct fasync_struct *fa_next; /* singly linked list */
-+ struct file *fa_file;
-+};
-+
-+#define FASYNC_MAGIC 0x4601
-+
-+/* SMP safe fasync helpers: */
-+extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
-+/* can be called from interrupts */
-+extern void kill_fasync(struct fasync_struct **, int, int);
-+/* only for net: no internal synchronization */
-+extern void __kill_fasync(struct fasync_struct *, int, int);
-+
-+struct nameidata {
-+ struct dentry *dentry;
-+ struct vfsmount *mnt;
-+ struct qstr last;
-+ unsigned int flags;
-+ int last_type;
-+};
-+
-+/*
-+ * Umount options
-+ */
-+
-+#define MNT_FORCE 0x00000001 /* Attempt to forcibily umount */
-+#define MNT_DETACH 0x00000002 /* Just detach from the tree */
-+
-+#include <linux/minix_fs_sb.h>
-+#include <linux/ext2_fs_sb.h>
-+#include <linux/ext3_fs_sb.h>
-+#include <linux/hpfs_fs_sb.h>
-+#include <linux/ntfs_fs_sb.h>
-+#include <linux/msdos_fs_sb.h>
-+#include <linux/iso_fs_sb.h>
-+#include <linux/nfs_fs_sb.h>
-+#include <linux/sysv_fs_sb.h>
-+#include <linux/affs_fs_sb.h>
-+#include <linux/ufs_fs_sb.h>
-+#include <linux/efs_fs_sb.h>
-+#include <linux/romfs_fs_sb.h>
-+#include <linux/smb_fs_sb.h>
-+#include <linux/hfs_fs_sb.h>
-+#include <linux/adfs_fs_sb.h>
-+#include <linux/qnx4_fs_sb.h>
-+#include <linux/reiserfs_fs_sb.h>
-+#include <linux/bfs_fs_sb.h>
-+#include <linux/udf_fs_sb.h>
-+#include <linux/ncp_fs_sb.h>
-+#include <linux/usbdev_fs_sb.h>
-+#include <linux/cramfs_fs_sb.h>
-+#include <linux/jffs2_fs_sb.h>
-+
-+extern struct list_head super_blocks;
-+extern spinlock_t sb_lock;
-+
-+#define sb_entry(list) list_entry((list), struct super_block, s_list)
-+#define S_BIAS (1<<30)
-+struct super_block {
-+ struct list_head s_list; /* Keep this first */
-+ kdev_t s_dev;
-+ unsigned long s_blocksize;
-+ unsigned char s_blocksize_bits;
-+ unsigned char s_dirt;
-+ unsigned long long s_maxbytes; /* Max file size */
-+ struct file_system_type *s_type;
-+ struct super_operations *s_op;
-+ struct dquot_operations *dq_op;
-+ struct quotactl_ops *s_qcop;
-+ unsigned long s_flags;
-+ unsigned long s_magic;
-+ struct dentry *s_root;
-+ struct rw_semaphore s_umount;
-+ struct semaphore s_lock;
-+ int s_count;
-+ atomic_t s_active;
-+
-+ struct list_head s_dirty; /* dirty inodes */
-+ struct list_head s_locked_inodes;/* inodes being synced */
-+ struct list_head s_files;
-+
-+ struct block_device *s_bdev;
-+ struct list_head s_instances;
-+ struct quota_info s_dquot; /* Diskquota specific options */
-+
-+ union {
-+ struct minix_sb_info minix_sb;
-+ struct ext2_sb_info ext2_sb;
-+ struct ext3_sb_info ext3_sb;
-+ struct hpfs_sb_info hpfs_sb;
-+ struct ntfs_sb_info ntfs_sb;
-+ struct msdos_sb_info msdos_sb;
-+ struct isofs_sb_info isofs_sb;
-+ struct nfs_sb_info nfs_sb;
-+ struct sysv_sb_info sysv_sb;
-+ struct affs_sb_info affs_sb;
-+ struct ufs_sb_info ufs_sb;
-+ struct efs_sb_info efs_sb;
-+ struct shmem_sb_info shmem_sb;
-+ struct romfs_sb_info romfs_sb;
-+ struct smb_sb_info smbfs_sb;
-+ struct hfs_sb_info hfs_sb;
-+ struct adfs_sb_info adfs_sb;
-+ struct qnx4_sb_info qnx4_sb;
-+ struct reiserfs_sb_info reiserfs_sb;
-+ struct bfs_sb_info bfs_sb;
-+ struct udf_sb_info udf_sb;
-+ struct ncp_sb_info ncpfs_sb;
-+ struct usbdev_sb_info usbdevfs_sb;
-+ struct jffs2_sb_info jffs2_sb;
-+ struct cramfs_sb_info cramfs_sb;
-+ void *generic_sbp;
-+ } u;
-+ /*
-+ * The next field is for VFS *only*. No filesystems have any business
-+ * even looking at it. You had been warned.
-+ */
-+ struct semaphore s_vfs_rename_sem; /* Kludge */
-+
-+ /* The next field is used by knfsd when converting a (inode number based)
-+ * file handle into a dentry. As it builds a path in the dcache tree from
-+ * the bottom up, there may for a time be a subpath of dentrys which is not
-+ * connected to the main tree. This semaphore ensure that there is only ever
-+ * one such free path per filesystem. Note that unconnected files (or other
-+ * non-directories) are allowed, but not unconnected diretories.
-+ */
-+ struct semaphore s_nfsd_free_path_sem;
-+};
-+
-+/*
-+ * VFS helper functions..
-+ */
-+extern int vfs_create(struct inode *, struct dentry *, int);
-+extern int vfs_mkdir(struct inode *, struct dentry *, int);
-+extern int vfs_mknod(struct inode *, struct dentry *, int, dev_t);
-+extern int vfs_symlink(struct inode *, struct dentry *, const char *);
-+extern int vfs_link(struct dentry *, struct inode *, struct dentry *);
-+extern int vfs_rmdir(struct inode *, struct dentry *);
-+extern int vfs_unlink(struct inode *, struct dentry *);
-+extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *);
-+
-+/*
-+ * File types
-+ */
-+#define DT_UNKNOWN 0
-+#define DT_FIFO 1
-+#define DT_CHR 2
-+#define DT_DIR 4
-+#define DT_BLK 6
-+#define DT_REG 8
-+#define DT_LNK 10
-+#define DT_SOCK 12
-+#define DT_WHT 14
-+
-+/*
-+ * This is the "filldir" function type, used by readdir() to let
-+ * the kernel specify what kind of dirent layout it wants to have.
-+ * This allows the kernel to read directories into kernel space or
-+ * to have different dirent layouts depending on the binary type.
-+ */
-+typedef int (*filldir_t)(void *, const char *, int, loff_t, ino_t, unsigned);
-+
-+struct block_device_operations {
-+ int (*open) (struct inode *, struct file *);
-+ int (*release) (struct inode *, struct file *);
-+ int (*ioctl) (struct inode *, struct file *, unsigned, unsigned long);
-+ int (*check_media_change) (kdev_t);
-+ int (*revalidate) (kdev_t);
-+ struct module *owner;
-+};
-+
-+/*
-+ * NOTE:
-+ * read, write, poll, fsync, readv, writev can be called
-+ * without the big kernel lock held in all filesystems.
-+ */
-+struct file_operations {
-+ struct module *owner;
-+ loff_t (*llseek) (struct file *, loff_t, int);
-+ ssize_t (*read) (struct file *, char *, size_t, loff_t *);
-+ ssize_t (*write) (struct file *, const char *, size_t, loff_t *);
-+ int (*readdir) (struct file *, void *, filldir_t);
-+ unsigned int (*poll) (struct file *, struct poll_table_struct *);
-+ int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
-+ int (*mmap) (struct file *, struct vm_area_struct *);
-+ int (*open) (struct inode *, struct file *);
-+ int (*flush) (struct file *);
-+ int (*release) (struct inode *, struct file *);
-+ int (*fsync) (struct file *, struct dentry *, int datasync);
-+ int (*fasync) (int, struct file *, int);
-+ int (*lock) (struct file *, int, struct file_lock *);
-+ ssize_t (*readv) (struct file *, const struct iovec *, unsigned long, loff_t *);
-+ ssize_t (*writev) (struct file *, const struct iovec *, unsigned long, loff_t *);
-+ ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
-+ unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
-+};
-+
-+struct inode_operations {
-+ int (*create) (struct inode *,struct dentry *,int);
-+ struct dentry * (*lookup) (struct inode *,struct dentry *);
-+ int (*link) (struct dentry *,struct inode *,struct dentry *);
-+ int (*unlink) (struct inode *,struct dentry *);
-+ int (*symlink) (struct inode *,struct dentry *,const char *);
-+ int (*mkdir) (struct inode *,struct dentry *,int);
-+ int (*rmdir) (struct inode *,struct dentry *);
-+ int (*mknod) (struct inode *,struct dentry *,int,int);
-+ int (*rename) (struct inode *, struct dentry *,
-+ struct inode *, struct dentry *);
-+ int (*readlink) (struct dentry *, char *,int);
-+ int (*follow_link) (struct dentry *, struct nameidata *);
-+ void (*truncate) (struct inode *);
-+ int (*permission) (struct inode *, int);
-+ int (*revalidate) (struct dentry *);
-+ int (*setattr) (struct dentry *, struct iattr *);
-+ int (*getattr) (struct dentry *, struct iattr *);
-+ int (*setxattr) (struct dentry *, const char *, void *, size_t, int);
-+ ssize_t (*getxattr) (struct dentry *, const char *, void *, size_t);
-+ ssize_t (*listxattr) (struct dentry *, char *, size_t);
-+ int (*removexattr) (struct dentry *, const char *);
-+};
-+
-+struct seq_file;
-+
-+/*
-+ * NOTE: write_inode, delete_inode, clear_inode, put_inode can be called
-+ * without the big kernel lock held in all filesystems.
-+ */
-+struct super_operations {
-+ struct inode *(*alloc_inode)(struct super_block *sb);
-+ void (*destroy_inode)(struct inode *);
-+
-+ void (*read_inode) (struct inode *);
-+
-+ /* reiserfs kludge. reiserfs needs 64 bits of information to
-+ ** find an inode. We are using the read_inode2 call to get
-+ ** that information. We don't like this, and are waiting on some
-+ ** VFS changes for the real solution.
-+ ** iget4 calls read_inode2, iff it is defined
-+ */
-+ void (*read_inode2) (struct inode *, void *) ;
-+ void (*dirty_inode) (struct inode *);
-+ void (*write_inode) (struct inode *, int);
-+ void (*put_inode) (struct inode *);
-+ void (*delete_inode) (struct inode *);
-+ void (*put_super) (struct super_block *);
-+ void (*write_super) (struct super_block *);
-+ int (*sync_fs) (struct super_block *);
-+ void (*write_super_lockfs) (struct super_block *);
-+ void (*unlockfs) (struct super_block *);
-+ int (*statfs) (struct super_block *, struct statfs *);
-+ int (*remount_fs) (struct super_block *, int *, char *);
-+ void (*clear_inode) (struct inode *);
-+ void (*umount_begin) (struct super_block *);
-+
-+ /* Following are for knfsd to interact with "interesting" filesystems
-+ * Currently just reiserfs, but possibly FAT and others later
-+ *
-+ * fh_to_dentry is given a filehandle fragement with length, and a type flag
-+ * and must return a dentry for the referenced object or, if "parent" is
-+ * set, a dentry for the parent of the object.
-+ * If a dentry cannot be found, a "root" dentry should be created and
-+ * flaged as DCACHE_NFSD_DISCONNECTED. nfsd_iget is an example implementation.
-+ *
-+ * dentry_to_fh is given a dentry and must generate the filesys specific
-+ * part of the file handle. Available length is passed in *lenp and used
-+ * length should be returned therein.
-+ * If need_parent is set, then dentry_to_fh should encode sufficient information
-+ * to find the (current) parent.
-+ * dentry_to_fh should return a 1byte "type" which will be passed back in
-+ * the fhtype arguement to fh_to_dentry. Type of 0 is reserved.
-+ * If filesystem was exportable before the introduction of fh_to_dentry,
-+ * types 1 and 2 should be used is that same way as the generic code.
-+ * Type 255 means error.
-+ *
-+ * Lengths are in units of 4bytes, not bytes.
-+ */
-+ struct dentry * (*fh_to_dentry)(struct super_block *sb, __u32 *fh, int len, int fhtype, int parent);
-+ int (*dentry_to_fh)(struct dentry *, __u32 *fh, int *lenp, int need_parent);
-+ int (*show_options)(struct seq_file *, struct vfsmount *);
-+};
-+
-+/* Inode state bits.. */
-+#define I_DIRTY_SYNC 1 /* Not dirty enough for O_DATASYNC */
-+#define I_DIRTY_DATASYNC 2 /* Data-related inode changes pending */
-+#define I_DIRTY_PAGES 4 /* Data-related inode changes pending */
-+#define I_LOCK 8
-+#define I_FREEING 16
-+#define I_CLEAR 32
-+
-+#define I_DIRTY (I_DIRTY_SYNC | I_DIRTY_DATASYNC | I_DIRTY_PAGES)
-+
-+extern void __mark_inode_dirty(struct inode *, int);
-+static inline void mark_inode_dirty(struct inode *inode)
-+{
-+ __mark_inode_dirty(inode, I_DIRTY);
-+}
-+
-+static inline void mark_inode_dirty_sync(struct inode *inode)
-+{
-+ __mark_inode_dirty(inode, I_DIRTY_SYNC);
-+}
-+
-+static inline void mark_inode_dirty_pages(struct inode *inode)
-+{
-+ __mark_inode_dirty(inode, I_DIRTY_PAGES);
-+}
-+
-+struct file_system_type {
-+ const char *name;
-+ int fs_flags;
-+ struct super_block *(*read_super) (struct super_block *, void *, int);
-+ struct module *owner;
-+ struct file_system_type * next;
-+ struct list_head fs_supers;
-+};
-+
-+#define DECLARE_FSTYPE(var,type,read,flags) \
-+struct file_system_type var = { \
-+ name: type, \
-+ read_super: read, \
-+ fs_flags: flags, \
-+ owner: THIS_MODULE, \
-+}
-+
-+#define DECLARE_FSTYPE_DEV(var,type,read) \
-+ DECLARE_FSTYPE(var,type,read,FS_REQUIRES_DEV)
-+
-+/* Alas, no aliases. Too much hassle with bringing module.h everywhere */
-+#define fops_get(fops) \
-+ (((fops) && (fops)->owner) \
-+ ? ( try_inc_mod_count((fops)->owner) ? (fops) : NULL ) \
-+ : (fops))
-+
-+#define fops_put(fops) \
-+do { \
-+ if ((fops) && (fops)->owner) \
-+ __MOD_DEC_USE_COUNT((fops)->owner); \
-+} while(0)
-+
-+extern int register_filesystem(struct file_system_type *);
-+extern int unregister_filesystem(struct file_system_type *);
-+extern struct vfsmount *kern_mount(struct file_system_type *);
-+extern int may_umount(struct vfsmount *);
+
+ MODULE_AUTHOR("Remy Card, Stephen Tweedie, Andrew Morton, Andreas Dilger, Theodore Ts'o and others");
+ MODULE_DESCRIPTION("Second Extended Filesystem with journaling extensions");
+--- linux-2.4.20-hp4_pnnl1/include/linux/fs.h~exports_hp Tue Apr 1 20:36:07 2003
++++ linux-2.4.20-hp4_pnnl1-braam/include/linux/fs.h Tue Apr 1 20:36:52 2003
+@@ -1020,6 +1020,7 @@
+ extern struct vfsmount *kern_mount(struct file_system_type *);
+ extern int may_umount(struct vfsmount *);
+ extern long do_mount(char *, char *, char *, unsigned long, void *);
+struct vfsmount *do_kern_mount(const char *type, int flags, char *name, void *data);
-+extern long do_mount(char *, char *, char *, unsigned long, void *);
-+
-+#define kern_umount mntput
-+
-+extern int vfs_statfs(struct super_block *, struct statfs *);
-+
-+/* Return value for VFS lock functions - tells locks.c to lock conventionally
-+ * REALLY kosha for root NFS and nfs_lock
-+ */
-+#define LOCK_USE_CLNT 1
-+
-+#define FLOCK_VERIFY_READ 1
-+#define FLOCK_VERIFY_WRITE 2
-+
-+extern int locks_mandatory_locked(struct inode *);
-+extern int locks_mandatory_area(int, struct inode *, struct file *, loff_t, size_t);
-+
-+/*
-+ * Candidates for mandatory locking have the setgid bit set
-+ * but no group execute bit - an otherwise meaningless combination.
-+ */
-+#define MANDATORY_LOCK(inode) \
-+ (IS_MANDLOCK(inode) && ((inode)->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
-+
-+static inline int locks_verify_locked(struct inode *inode)
-+{
-+ if (MANDATORY_LOCK(inode))
-+ return locks_mandatory_locked(inode);
-+ return 0;
-+}
-+
-+static inline int locks_verify_area(int read_write, struct inode *inode,
-+ struct file *filp, loff_t offset,
-+ size_t count)
-+{
-+ if (inode->i_flock && MANDATORY_LOCK(inode))
-+ return locks_mandatory_area(read_write, inode, filp, offset, count);
-+ return 0;
-+}
-+
-+static inline int locks_verify_truncate(struct inode *inode,
-+ struct file *filp,
-+ loff_t size)
-+{
-+ if (inode->i_flock && MANDATORY_LOCK(inode))
-+ return locks_mandatory_area(
-+ FLOCK_VERIFY_WRITE, inode, filp,
-+ size < inode->i_size ? size : inode->i_size,
-+ (size < inode->i_size ? inode->i_size - size
-+ : size - inode->i_size)
-+ );
-+ return 0;
-+}
-+
-+static inline int get_lease(struct inode *inode, unsigned int mode)
-+{
-+ if (inode->i_flock)
-+ return __get_lease(inode, mode);
-+ return 0;
-+}
-+
-+/* fs/open.c */
-+
-+asmlinkage long sys_open(const char *, int, int);
-+asmlinkage long sys_close(unsigned int); /* yes, it's really unsigned */
-+extern int do_truncate(struct dentry *, loff_t start);
-+
-+extern struct file *filp_open(const char *, int, int);
-+extern struct file * dentry_open(struct dentry *, struct vfsmount *, int);
-+extern int filp_close(struct file *, fl_owner_t id);
-+extern char * getname(const char *);
-+
-+/* fs/dcache.c */
-+extern void vfs_caches_init(unsigned long);
-+
-+#define __getname() kmem_cache_alloc(names_cachep, SLAB_KERNEL)
-+#define putname(name) kmem_cache_free(names_cachep, (void *)(name))
-+
-+enum {BDEV_FILE, BDEV_SWAP, BDEV_FS, BDEV_RAW};
-+extern int register_blkdev(unsigned int, const char *, struct block_device_operations *);
-+extern int unregister_blkdev(unsigned int, const char *);
-+extern struct block_device *bdget(dev_t);
-+extern int bd_acquire(struct inode *inode);
-+extern void bd_forget(struct inode *inode);
-+extern void bdput(struct block_device *);
-+extern struct char_device *cdget(dev_t);
-+extern void cdput(struct char_device *);
-+extern int blkdev_open(struct inode *, struct file *);
-+extern int blkdev_close(struct inode *, struct file *);
-+extern struct file_operations def_blk_fops;
-+extern struct address_space_operations def_blk_aops;
-+extern struct file_operations def_fifo_fops;
-+extern int ioctl_by_bdev(struct block_device *, unsigned, unsigned long);
-+extern int blkdev_get(struct block_device *, mode_t, unsigned, int);
-+extern int blkdev_put(struct block_device *, int);
-+
-+/* fs/devices.c */
-+extern const struct block_device_operations *get_blkfops(unsigned int);
-+extern int register_chrdev(unsigned int, const char *, struct file_operations *);
-+extern int unregister_chrdev(unsigned int, const char *);
-+extern int chrdev_open(struct inode *, struct file *);
-+extern const char * bdevname(kdev_t);
-+extern const char * cdevname(kdev_t);
-+extern const char * kdevname(kdev_t);
-+extern void init_special_inode(struct inode *, umode_t, int);
-+
-+/* Invalid inode operations -- fs/bad_inode.c */
-+extern void make_bad_inode(struct inode *);
-+extern int is_bad_inode(struct inode *);
-+
-+extern struct file_operations read_fifo_fops;
-+extern struct file_operations write_fifo_fops;
-+extern struct file_operations rdwr_fifo_fops;
-+extern struct file_operations read_pipe_fops;
-+extern struct file_operations write_pipe_fops;
-+extern struct file_operations rdwr_pipe_fops;
-+
-+extern int fs_may_remount_ro(struct super_block *);
-+
-+extern int FASTCALL(try_to_free_buffers(struct page *, unsigned int));
-+extern void refile_buffer(struct buffer_head * buf);
-+extern void create_empty_buffers(struct page *, kdev_t, unsigned long);
-+extern void end_buffer_io_sync(struct buffer_head *bh, int uptodate);
-+
-+/* reiserfs_writepage needs this */
-+extern void set_buffer_async_io(struct buffer_head *bh) ;
-+
-+#define BUF_CLEAN 0
-+#define BUF_LOCKED 1 /* Buffers scheduled for write */
-+#define BUF_DIRTY 2 /* Dirty buffers, not yet scheduled for write */
-+#define NR_LIST 3
-+
-+static inline void get_bh(struct buffer_head * bh)
-+{
-+ atomic_inc(&(bh)->b_count);
-+}
-+
-+static inline void put_bh(struct buffer_head *bh)
-+{
-+ smp_mb__before_atomic_dec();
-+ atomic_dec(&bh->b_count);
-+}
-+
-+/*
-+ * This is called by bh->b_end_io() handlers when I/O has completed.
-+ */
-+static inline void mark_buffer_uptodate(struct buffer_head * bh, int on)
-+{
-+ if (on)
-+ set_bit(BH_Uptodate, &bh->b_state);
-+ else
-+ clear_bit(BH_Uptodate, &bh->b_state);
-+}
-+
-+#define atomic_set_buffer_clean(bh) test_and_clear_bit(BH_Dirty, &(bh)->b_state)
-+
-+static inline void __mark_buffer_clean(struct buffer_head *bh)
-+{
-+ refile_buffer(bh);
-+}
-+
-+static inline void mark_buffer_clean(struct buffer_head * bh)
-+{
-+ if (atomic_set_buffer_clean(bh))
-+ __mark_buffer_clean(bh);
-+}
-+
-+extern void FASTCALL(__mark_dirty(struct buffer_head *bh));
-+extern void FASTCALL(__mark_buffer_dirty(struct buffer_head *bh));
-+extern void FASTCALL(mark_buffer_dirty(struct buffer_head *bh));
-+
-+extern void FASTCALL(buffer_insert_list(struct buffer_head *, struct list_head *));
-+
-+static inline void buffer_insert_inode_queue(struct buffer_head *bh, struct inode *inode)
-+{
-+ buffer_insert_list(bh, &inode->i_dirty_buffers);
-+}
-+
-+static inline void buffer_insert_inode_data_queue(struct buffer_head *bh, struct inode *inode)
-+{
-+ buffer_insert_list(bh, &inode->i_dirty_data_buffers);
-+}
-+
-+static inline int atomic_set_buffer_dirty(struct buffer_head *bh)
-+{
-+ return test_and_set_bit(BH_Dirty, &bh->b_state);
-+}
-+
-+static inline void mark_buffer_async(struct buffer_head * bh, int on)
-+{
-+ if (on)
-+ set_bit(BH_Async, &bh->b_state);
-+ else
-+ clear_bit(BH_Async, &bh->b_state);
-+}
-+
-+static inline void set_buffer_attached(struct buffer_head *bh)
-+{
-+ set_bit(BH_Attached, &bh->b_state);
-+}
-+
-+static inline void clear_buffer_attached(struct buffer_head *bh)
-+{
-+ clear_bit(BH_Attached, &bh->b_state);
-+}
-+
-+static inline int buffer_attached(struct buffer_head *bh)
-+{
-+ return test_bit(BH_Attached, &bh->b_state);
-+}
-+
-+/*
-+ * If an error happens during the make_request, this function
-+ * has to be recalled. It marks the buffer as clean and not
-+ * uptodate, and it notifys the upper layer about the end
-+ * of the I/O.
-+ */
-+static inline void buffer_IO_error(struct buffer_head * bh)
-+{
-+ mark_buffer_clean(bh);
-+ /*
-+ * b_end_io has to clear the BH_Uptodate bitflag in the error case!
-+ */
-+ bh->b_end_io(bh, 0);
-+}
-+
-+static inline void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
-+{
-+ mark_buffer_dirty(bh);
-+ buffer_insert_inode_queue(bh, inode);
-+}
-+
-+extern void set_buffer_flushtime(struct buffer_head *);
-+extern void balance_dirty(void);
-+extern int check_disk_change(kdev_t);
-+extern int invalidate_inodes(struct super_block *);
-+extern int invalidate_device(kdev_t, int);
-+extern void invalidate_inode_pages(struct inode *);
-+extern void invalidate_inode_pages2(struct address_space *);
-+extern void invalidate_inode_buffers(struct inode *);
-+#define invalidate_buffers(dev) __invalidate_buffers((dev), 0)
-+#define destroy_buffers(dev) __invalidate_buffers((dev), 1)
-+extern void invalidate_bdev(struct block_device *, int);
-+extern void __invalidate_buffers(kdev_t dev, int);
-+extern void sync_inodes(kdev_t);
-+extern void sync_unlocked_inodes(void);
-+extern void write_inode_now(struct inode *, int);
-+extern int sync_buffers(kdev_t, int);
-+extern void sync_dev(kdev_t);
-+extern int fsync_dev(kdev_t);
-+extern int fsync_dev_lockfs(kdev_t);
-+extern int fsync_super(struct super_block *);
-+extern int fsync_no_super(kdev_t);
-+extern void sync_inodes_sb(struct super_block *);
-+extern int fsync_buffers_list(struct list_head *);
-+static inline int fsync_inode_buffers(struct inode *inode)
-+{
-+ return fsync_buffers_list(&inode->i_dirty_buffers);
-+}
-+static inline int fsync_inode_data_buffers(struct inode *inode)
-+{
-+ return fsync_buffers_list(&inode->i_dirty_data_buffers);
-+}
-+extern int inode_has_buffers(struct inode *);
-+extern int filemap_fdatasync(struct address_space *);
-+extern int filemap_fdatawait(struct address_space *);
-+extern void sync_supers(kdev_t dev, int wait);
-+extern void sync_supers_lockfs(kdev_t);
-+extern void unlockfs(kdev_t);
-+extern int bmap(struct inode *, int);
-+extern int notify_change(struct dentry *, struct iattr *);
-+extern int permission(struct inode *, int);
-+extern int vfs_permission(struct inode *, int);
-+extern int get_write_access(struct inode *);
-+extern int deny_write_access(struct file *);
-+static inline void put_write_access(struct inode * inode)
-+{
-+ atomic_dec(&inode->i_writecount);
-+}
-+static inline void allow_write_access(struct file *file)
-+{
-+ if (file)
-+ atomic_inc(&file->f_dentry->d_inode->i_writecount);
-+}
-+extern int do_pipe(int *);
-+
-+extern int open_namei(const char *, int, int, struct nameidata *);
-+
-+extern int kernel_read(struct file *, unsigned long, char *, unsigned long);
-+extern struct file * open_exec(const char *);
-+
-+/* fs/dcache.c -- generic fs support functions */
-+extern int is_subdir(struct dentry *, struct dentry *);
-+extern ino_t find_inode_number(struct dentry *, struct qstr *);
-+
-+/*
-+ * Kernel pointers have redundant information, so we can use a
-+ * scheme where we can return either an error code or a dentry
-+ * pointer with the same return value.
-+ *
-+ * This should be a per-architecture thing, to allow different
-+ * error and pointer decisions.
-+ */
-+static inline void *ERR_PTR(long error)
-+{
-+ return (void *) error;
-+}
-+
-+static inline long PTR_ERR(const void *ptr)
-+{
-+ return (long) ptr;
-+}
-+
-+static inline long IS_ERR(const void *ptr)
-+{
-+ return (unsigned long)ptr > (unsigned long)-1000L;
-+}
-+
-+/*
-+ * The bitmask for a lookup event:
-+ * - follow links at the end
-+ * - require a directory
-+ * - ending slashes ok even for nonexistent files
-+ * - internal "there are more path compnents" flag
-+ */
-+#define LOOKUP_FOLLOW (1)
-+#define LOOKUP_DIRECTORY (2)
-+#define LOOKUP_CONTINUE (4)
-+#define LOOKUP_POSITIVE (8)
-+#define LOOKUP_PARENT (16)
-+#define LOOKUP_NOALT (32)
-+#define LOOKUP_ATOMIC (64)
-+/*
-+ * Type of the last component on LOOKUP_PARENT
-+ */
-+enum {LAST_NORM, LAST_ROOT, LAST_DOT, LAST_DOTDOT, LAST_BIND};
-+
-+/*
-+ * "descriptor" for what we're up to with a read for sendfile().
-+ * This allows us to use the same read code yet
-+ * have multiple different users of the data that
-+ * we read from a file.
-+ *
-+ * The simplest case just copies the data to user
-+ * mode.
-+ */
-+typedef struct {
-+ size_t written;
-+ size_t count;
-+ char * buf;
-+ int error;
-+} read_descriptor_t;
-+
-+typedef int (*read_actor_t)(read_descriptor_t *, struct page *, unsigned long, unsigned long);
-+
-+/* needed for stackable file system support */
-+extern loff_t default_llseek(struct file *file, loff_t offset, int origin);
-+
-+extern int FASTCALL(__user_walk(const char *, unsigned, struct nameidata *));
-+extern int FASTCALL(path_init(const char *, unsigned, struct nameidata *));
-+extern int FASTCALL(path_walk(const char *, struct nameidata *));
-+extern int FASTCALL(path_lookup(const char *, unsigned, struct nameidata *));
-+extern int FASTCALL(link_path_walk(const char *, struct nameidata *));
-+extern void path_release(struct nameidata *);
-+extern int follow_down(struct vfsmount **, struct dentry **);
-+extern int follow_up(struct vfsmount **, struct dentry **);
-+extern struct dentry * lookup_one_len(const char *, struct dentry *, int);
-+extern struct dentry * lookup_hash(struct qstr *, struct dentry *);
-+#define user_path_walk(name,nd) __user_walk(name, LOOKUP_FOLLOW|LOOKUP_POSITIVE, nd)
-+#define user_path_walk_link(name,nd) __user_walk(name, LOOKUP_POSITIVE, nd)
-+
-+extern void inode_init_once(struct inode *);
-+extern void iput(struct inode *);
-+extern void force_delete(struct inode *);
-+extern struct inode * igrab(struct inode *);
-+extern ino_t iunique(struct super_block *, ino_t);
-+
-+typedef int (*find_inode_t)(struct inode *, unsigned long, void *);
-+extern struct inode * iget4(struct super_block *, unsigned long, find_inode_t, void *);
-+static inline struct inode *iget(struct super_block *sb, unsigned long ino)
-+{
-+ return iget4(sb, ino, NULL, NULL);
-+}
-+
-+extern void clear_inode(struct inode *);
-+extern struct inode *new_inode(struct super_block *sb);
-+extern void remove_suid(struct inode *inode);
-+
-+extern void insert_inode_hash(struct inode *);
-+extern void remove_inode_hash(struct inode *);
-+extern struct file * get_empty_filp(void);
-+extern void file_move(struct file *f, struct list_head *list);
-+extern struct buffer_head * get_hash_table(kdev_t, int, int);
-+extern struct buffer_head * getblk(kdev_t, int, int);
-+extern void ll_rw_block(int, int, struct buffer_head * bh[]);
-+extern void submit_bh(int, struct buffer_head *);
-+extern int is_read_only(kdev_t);
-+extern void __brelse(struct buffer_head *);
-+static inline void brelse(struct buffer_head *buf)
-+{
-+ if (buf)
-+ __brelse(buf);
-+}
-+extern void __bforget(struct buffer_head *);
-+static inline void bforget(struct buffer_head *buf)
-+{
-+ if (buf)
-+ __bforget(buf);
-+}
-+extern int set_blocksize(kdev_t, int);
-+extern int sb_set_blocksize(struct super_block *, int);
-+extern int sb_min_blocksize(struct super_block *, int);
-+extern struct buffer_head * bread(kdev_t, int, int);
-+static inline struct buffer_head * sb_bread(struct super_block *sb, int block)
-+{
-+ return bread(sb->s_dev, block, sb->s_blocksize);
-+}
-+static inline struct buffer_head * sb_getblk(struct super_block *sb, int block)
-+{
-+ return getblk(sb->s_dev, block, sb->s_blocksize);
-+}
-+static inline struct buffer_head * sb_get_hash_table(struct super_block *sb, int block)
-+{
-+ return get_hash_table(sb->s_dev, block, sb->s_blocksize);
-+}
-+extern void wakeup_bdflush(void);
-+extern void put_unused_buffer_head(struct buffer_head * bh);
-+extern struct buffer_head * get_unused_buffer_head(int async);
-+
-+extern int brw_page(int, struct page *, kdev_t, int [], int);
-+
-+typedef int (get_block_t)(struct inode*,long,struct buffer_head*,int);
-+
-+/* Generic buffer handling for block filesystems.. */
-+extern int try_to_release_page(struct page * page, int gfp_mask);
-+extern int discard_bh_page(struct page *, unsigned long, int);
-+#define block_flushpage(page, offset) discard_bh_page(page, offset, 1)
-+#define block_invalidate_page(page) discard_bh_page(page, 0, 0)
-+extern int block_symlink(struct inode *, const char *, int);
-+extern int block_write_full_page(struct page*, get_block_t*);
-+extern int block_read_full_page(struct page*, get_block_t*);
-+extern int block_prepare_write(struct page*, unsigned, unsigned, get_block_t*);
-+extern int cont_prepare_write(struct page*, unsigned, unsigned, get_block_t*,
-+ unsigned long *);
-+extern int generic_cont_expand(struct inode *inode, loff_t size) ;
-+extern int block_commit_write(struct page *page, unsigned from, unsigned to);
-+extern int block_sync_page(struct page *);
-+
-+int generic_block_bmap(struct address_space *, long, get_block_t *);
-+int generic_commit_write(struct file *, struct page *, unsigned, unsigned);
-+int block_truncate_page(struct address_space *, loff_t, get_block_t *);
-+extern int generic_direct_IO(int, struct inode *, struct kiobuf *, unsigned long, int, get_block_t *);
-+extern int waitfor_one_page(struct page *);
-+extern int writeout_one_page(struct page *);
-+
-+extern int generic_file_mmap(struct file *, struct vm_area_struct *);
-+extern int file_read_actor(read_descriptor_t * desc, struct page *page, unsigned long offset, unsigned long size);
-+extern ssize_t generic_file_read(struct file *, char *, size_t, loff_t *);
-+extern ssize_t generic_file_write(struct file *, const char *, size_t, loff_t *);
-+extern void do_generic_file_read(struct file *, loff_t *, read_descriptor_t *, read_actor_t, int);
-+extern loff_t no_llseek(struct file *file, loff_t offset, int origin);
-+extern loff_t generic_file_llseek(struct file *file, loff_t offset, int origin);
-+extern ssize_t generic_read_dir(struct file *, char *, size_t, loff_t *);
-+extern int generic_file_open(struct inode * inode, struct file * filp);
-+
-+extern struct file_operations generic_ro_fops;
-+
-+extern int vfs_readlink(struct dentry *, char *, int, const char *);
-+extern int vfs_follow_link(struct nameidata *, const char *);
-+extern int page_readlink(struct dentry *, char *, int);
-+extern int page_follow_link(struct dentry *, struct nameidata *);
-+extern struct inode_operations page_symlink_inode_operations;
-+
-+extern int vfs_readdir(struct file *, filldir_t, void *);
-+extern int dcache_dir_open(struct inode *, struct file *);
-+extern int dcache_dir_close(struct inode *, struct file *);
-+extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
-+extern int dcache_dir_fsync(struct file *, struct dentry *, int);
-+extern int dcache_readdir(struct file *, void *, filldir_t);
-+extern struct file_operations dcache_dir_ops;
-+
-+extern int vfs_stat(char *, struct kstat *);
-+extern int vfs_lstat(char *, struct kstat *);
-+extern int vfs_fstat(unsigned int, struct kstat *);
-+
-+extern struct file_system_type *get_fs_type(const char *name);
-+extern struct super_block *get_super(kdev_t);
-+extern void drop_super(struct super_block *sb);
-+static inline int is_mounted(kdev_t dev)
-+{
-+ struct super_block *sb = get_super(dev);
-+ if (sb) {
-+ drop_super(sb);
-+ return 1;
-+ }
-+ return 0;
-+}
-+extern kdev_t ROOT_DEV;
-+extern char root_device_name[];
-+
-+
-+extern void show_buffers(void);
-+
-+#ifdef CONFIG_BLK_DEV_INITRD
-+extern unsigned int real_root_dev;
-+#endif
-+
-+extern ssize_t char_read(struct file *, char *, size_t, loff_t *);
-+extern ssize_t block_read(struct file *, char *, size_t, loff_t *);
-+extern int read_ahead[];
-+
-+extern ssize_t char_write(struct file *, const char *, size_t, loff_t *);
-+extern ssize_t block_write(struct file *, const char *, size_t, loff_t *);
-+
-+extern int file_fsync(struct file *, struct dentry *, int);
-+extern int generic_buffer_fdatasync(struct inode *inode, unsigned long start_idx, unsigned long end_idx);
-+extern int generic_osync_inode(struct inode *, int);
-+#define OSYNC_METADATA (1<<0)
-+#define OSYNC_DATA (1<<1)
-+#define OSYNC_INODE (1<<2)
-+
-+extern int inode_change_ok(struct inode *, struct iattr *);
-+extern int inode_setattr(struct inode *, struct iattr *);
-+
-+/*
-+ * Common dentry functions for inclusion in the VFS
-+ * or in other stackable file systems. Some of these
-+ * functions were in linux/fs/ C (VFS) files.
-+ *
-+ */
-+
-+/*
-+ * Locking the parent is needed to:
-+ * - serialize directory operations
-+ * - make sure the parent doesn't change from
-+ * under us in the middle of an operation.
-+ *
-+ * NOTE! Right now we'd rather use a "struct inode"
-+ * for this, but as I expect things to move toward
-+ * using dentries instead for most things it is
-+ * probably better to start with the conceptually
-+ * better interface of relying on a path of dentries.
-+ */
-+static inline struct dentry *lock_parent(struct dentry *dentry)
-+{
-+ struct dentry *dir = dget(dentry->d_parent);
-+
-+ down(&dir->d_inode->i_sem);
-+ return dir;
-+}
-+
-+static inline struct dentry *get_parent(struct dentry *dentry)
-+{
-+ return dget(dentry->d_parent);
-+}
-+
-+static inline void unlock_dir(struct dentry *dir)
-+{
-+ up(&dir->d_inode->i_sem);
-+ dput(dir);
-+}
-+
-+/*
-+ * Whee.. Deadlock country. Happily there are only two VFS
-+ * operations that does this..
-+ */
-+static inline void double_down(struct semaphore *s1, struct semaphore *s2)
-+{
-+ if (s1 != s2) {
-+ if ((unsigned long) s1 < (unsigned long) s2) {
-+ struct semaphore *tmp = s2;
-+ s2 = s1; s1 = tmp;
-+ }
-+ down(s1);
-+ }
-+ down(s2);
-+}
-+
-+/*
-+ * Ewwwwwwww... _triple_ lock. We are guaranteed that the 3rd argument is
-+ * not equal to 1st and not equal to 2nd - the first case (target is parent of
-+ * source) would be already caught, the second is plain impossible (target is
-+ * its own parent and that case would be caught even earlier). Very messy.
-+ * I _think_ that it works, but no warranties - please, look it through.
-+ * Pox on bloody lusers who mandated overwriting rename() for directories...
-+ */
-+
-+static inline void triple_down(struct semaphore *s1,
-+ struct semaphore *s2,
-+ struct semaphore *s3)
-+{
-+ if (s1 != s2) {
-+ if ((unsigned long) s1 < (unsigned long) s2) {
-+ if ((unsigned long) s1 < (unsigned long) s3) {
-+ struct semaphore *tmp = s3;
-+ s3 = s1; s1 = tmp;
-+ }
-+ if ((unsigned long) s1 < (unsigned long) s2) {
-+ struct semaphore *tmp = s2;
-+ s2 = s1; s1 = tmp;
-+ }
-+ } else {
-+ if ((unsigned long) s1 < (unsigned long) s3) {
-+ struct semaphore *tmp = s3;
-+ s3 = s1; s1 = tmp;
-+ }
-+ if ((unsigned long) s2 < (unsigned long) s3) {
-+ struct semaphore *tmp = s3;
-+ s3 = s2; s2 = tmp;
-+ }
-+ }
-+ down(s1);
-+ } else if ((unsigned long) s2 < (unsigned long) s3) {
-+ struct semaphore *tmp = s3;
-+ s3 = s2; s2 = tmp;
-+ }
-+ down(s2);
-+ down(s3);
-+}
-+
-+static inline void double_up(struct semaphore *s1, struct semaphore *s2)
-+{
-+ up(s1);
-+ if (s1 != s2)
-+ up(s2);
-+}
-+
-+static inline void triple_up(struct semaphore *s1,
-+ struct semaphore *s2,
-+ struct semaphore *s3)
-+{
-+ up(s1);
-+ if (s1 != s2)
-+ up(s2);
-+ up(s3);
-+}
-+
-+static inline void double_lock(struct dentry *d1, struct dentry *d2)
-+{
-+ double_down(&d1->d_inode->i_sem, &d2->d_inode->i_sem);
-+}
-+
-+static inline void double_unlock(struct dentry *d1, struct dentry *d2)
-+{
-+ double_up(&d1->d_inode->i_sem,&d2->d_inode->i_sem);
-+ dput(d1);
-+ dput(d2);
-+}
-+
-+#endif /* __KERNEL__ */
-+
-+#endif /* _LINUX_FS_H */
---- /dev/null Fri Aug 30 17:31:37 2002
-+++ linux-rh-2.4.20-6-braam/kernel/ksyms.c Mon Mar 31 23:43:55 2003
-@@ -0,0 +1,632 @@
-+/*
-+ * Herein lies all the functions/variables that are "exported" for linkage
-+ * with dynamically loaded kernel modules.
-+ * Jon.
-+ *
-+ * - Stacked module support and unified symbol table added (June 1994)
-+ * - External symbol table support added (December 1994)
-+ * - Versions on symbols added (December 1994)
-+ * by Bjorn Ekwall <bj0rn@blox.se>
-+ */
-+
-+#define __KERNEL_SYSCALLS__
-+#include <linux/config.h>
-+#include <linux/slab.h>
-+#include <linux/smp.h>
-+#include <linux/module.h>
-+#include <linux/blkdev.h>
-+#include <linux/cdrom.h>
-+#include <linux/kernel_stat.h>
-+#include <linux/vmalloc.h>
-+#include <linux/sys.h>
-+#include <linux/utsname.h>
-+#include <linux/interrupt.h>
-+#include <linux/ioport.h>
-+#include <linux/serial.h>
-+#include <linux/locks.h>
-+#include <linux/delay.h>
-+#include <linux/random.h>
-+#include <linux/reboot.h>
-+#include <linux/pagemap.h>
-+#include <linux/sysctl.h>
-+#include <linux/hdreg.h>
-+#include <linux/skbuff.h>
-+#include <linux/genhd.h>
-+#include <linux/blkpg.h>
-+#include <linux/swap.h>
-+#include <linux/ctype.h>
-+#include <linux/file.h>
-+#include <linux/iobuf.h>
-+#include <linux/console.h>
-+#include <linux/poll.h>
-+#include <linux/mmzone.h>
-+#include <linux/mm.h>
-+#include <linux/capability.h>
-+#include <linux/highuid.h>
-+#include <linux/brlock.h>
-+#include <linux/fs.h>
-+#include <linux/tty.h>
-+#include <linux/in6.h>
-+#include <linux/completion.h>
-+#include <linux/seq_file.h>
-+#include <linux/dnotify.h>
-+#include <asm/checksum.h>
-+#include <linux/unistd.h>
-+
-+
-+#if defined(CONFIG_PROC_FS)
-+#include <linux/proc_fs.h>
-+#endif
-+#ifdef CONFIG_KMOD
-+#include <linux/kmod.h>
-+#endif
-+#ifdef CONFIG_KALLSYMS
-+#include <linux/kallsyms.h>
-+#endif
-+
-+extern void set_device_ro(kdev_t dev,int flag);
-+
-+extern void *sys_call_table;
-+
-+extern struct timezone sys_tz;
-+extern int request_dma(unsigned int dmanr, char * deviceID);
-+extern void free_dma(unsigned int dmanr);
-+extern spinlock_t dma_spin_lock;
-+extern int panic_timeout;
-+
-+
-+#ifdef CONFIG_MODVERSIONS
-+const struct module_symbol __export_Using_Versions
-+__attribute__((section("__ksymtab"))) = {
-+ 1 /* Version version */, "Using_Versions"
-+};
-+#endif
-+
-+
-+EXPORT_SYMBOL(inter_module_register);
-+EXPORT_SYMBOL(inter_module_unregister);
-+EXPORT_SYMBOL(inter_module_get);
-+EXPORT_SYMBOL(inter_module_get_request);
-+EXPORT_SYMBOL(inter_module_put);
-+EXPORT_SYMBOL(try_inc_mod_count);
-+
-+#ifdef CONFIG_KALLSYMS
-+extern const char __start___kallsyms[];
-+extern const char __stop___kallsyms[];
-+EXPORT_SYMBOL(__start___kallsyms);
-+EXPORT_SYMBOL(__stop___kallsyms);
-+
-+
-+#endif
-+
-+/* process memory management */
-+EXPORT_SYMBOL(do_mmap_pgoff);
-+EXPORT_SYMBOL(do_munmap);
-+EXPORT_SYMBOL(do_brk);
-+EXPORT_SYMBOL(exit_mm);
-+EXPORT_SYMBOL(exit_files);
-+EXPORT_SYMBOL(exit_fs);
-+EXPORT_SYMBOL(exit_sighand);
-+
-+/* internal kernel memory management */
-+EXPORT_SYMBOL(_alloc_pages);
-+EXPORT_SYMBOL(__alloc_pages);
-+EXPORT_SYMBOL(alloc_pages_node);
-+EXPORT_SYMBOL(__get_free_pages);
-+EXPORT_SYMBOL(get_zeroed_page);
-+EXPORT_SYMBOL(__free_pages);
-+EXPORT_SYMBOL(free_pages);
-+EXPORT_SYMBOL(num_physpages);
-+EXPORT_SYMBOL(kmem_find_general_cachep);
-+EXPORT_SYMBOL(kmem_cache_create);
-+EXPORT_SYMBOL(kmem_cache_destroy);
-+EXPORT_SYMBOL(kmem_cache_shrink);
-+EXPORT_SYMBOL(kmem_cache_alloc);
-+EXPORT_SYMBOL(kmem_cache_free);
-+EXPORT_SYMBOL(kmem_cache_size);
-+EXPORT_SYMBOL(kmalloc);
-+EXPORT_SYMBOL(kfree);
-+EXPORT_SYMBOL(vfree);
-+EXPORT_SYMBOL(__vmalloc);
-+EXPORT_SYMBOL(vmalloc_to_page);
-+EXPORT_SYMBOL(mem_map);
-+EXPORT_SYMBOL(remap_page_range);
-+EXPORT_SYMBOL(max_mapnr);
-+EXPORT_SYMBOL(high_memory);
-+EXPORT_SYMBOL(vmtruncate);
-+EXPORT_SYMBOL(find_vma);
-+EXPORT_SYMBOL(get_unmapped_area);
-+EXPORT_SYMBOL(init_mm);
-+#ifdef CONFIG_HIGHMEM
-+EXPORT_SYMBOL(kmap_high);
-+EXPORT_SYMBOL(kunmap_high);
-+EXPORT_SYMBOL(highmem_start_page);
-+EXPORT_SYMBOL(create_bounce);
-+EXPORT_SYMBOL(kmap_prot);
-+EXPORT_SYMBOL(kmap_pte);
-+#endif
-+
-+/* filesystem internal functions */
-+EXPORT_SYMBOL(def_blk_fops);
-+EXPORT_SYMBOL(update_atime);
-+EXPORT_SYMBOL(get_fs_type);
-+EXPORT_SYMBOL(get_super);
-+EXPORT_SYMBOL(drop_super);
-+EXPORT_SYMBOL(getname);
-+EXPORT_SYMBOL(names_cachep);
-+EXPORT_SYMBOL(fput);
-+EXPORT_SYMBOL(fget);
-+EXPORT_SYMBOL(igrab);
-+EXPORT_SYMBOL(iunique);
-+EXPORT_SYMBOL(iget4);
-+EXPORT_SYMBOL(iput);
-+EXPORT_SYMBOL(inode_init_once);
-+EXPORT_SYMBOL(force_delete);
-+EXPORT_SYMBOL(follow_up);
-+EXPORT_SYMBOL(follow_down);
-+EXPORT_SYMBOL(lookup_mnt);
-+EXPORT_SYMBOL(path_init);
-+EXPORT_SYMBOL(path_walk);
-+EXPORT_SYMBOL(path_release);
-+EXPORT_SYMBOL(__user_walk);
-+EXPORT_SYMBOL(lookup_one_len);
-+EXPORT_SYMBOL(lookup_hash);
-+EXPORT_SYMBOL(sys_close);
-+EXPORT_SYMBOL(sys_read);
-+EXPORT_SYMBOL(sys_write);
-+EXPORT_SYMBOL(sys_dup);
-+EXPORT_SYMBOL(sys_chroot);
-+EXPORT_SYMBOL(sys_chdir);
-+EXPORT_SYMBOL(sys_fcntl);
-+EXPORT_SYMBOL(do_pipe);
-+EXPORT_SYMBOL(dcache_lock);
-+EXPORT_SYMBOL(d_alloc_root);
-+EXPORT_SYMBOL(d_delete);
-+EXPORT_SYMBOL(dget_locked);
-+EXPORT_SYMBOL(d_validate);
-+EXPORT_SYMBOL(d_rehash);
-+EXPORT_SYMBOL(d_invalidate); /* May be it will be better in dcache.h? */
-+EXPORT_SYMBOL(d_move);
-+EXPORT_SYMBOL(d_instantiate);
-+EXPORT_SYMBOL(d_alloc);
-+EXPORT_SYMBOL(d_lookup);
-+EXPORT_SYMBOL(__d_path);
-+EXPORT_SYMBOL(mark_buffer_dirty);
-+EXPORT_SYMBOL(set_buffer_async_io); /* for reiserfs_writepage */
-+EXPORT_SYMBOL(__mark_buffer_dirty);
-+EXPORT_SYMBOL(__mark_inode_dirty);
-+EXPORT_SYMBOL(fd_install);
-+EXPORT_SYMBOL(get_empty_filp);
-+EXPORT_SYMBOL(init_private_file);
-+EXPORT_SYMBOL(filp_open);
-+EXPORT_SYMBOL(filp_close);
-+EXPORT_SYMBOL(put_filp);
-+EXPORT_SYMBOL(files_lock);
-+EXPORT_SYMBOL(check_disk_change);
-+EXPORT_SYMBOL(__invalidate_buffers);
-+EXPORT_SYMBOL(invalidate_bdev);
-+EXPORT_SYMBOL(invalidate_inodes);
-+EXPORT_SYMBOL(invalidate_device);
-+EXPORT_SYMBOL(invalidate_inode_pages);
-+EXPORT_SYMBOL(truncate_inode_pages);
-+EXPORT_SYMBOL(fsync_dev);
-+EXPORT_SYMBOL_GPL(fsync_dev_lockfs);
-+EXPORT_SYMBOL_GPL(unlockfs);
-+EXPORT_SYMBOL(fsync_no_super);
-+EXPORT_SYMBOL(permission);
-+EXPORT_SYMBOL(vfs_permission);
-+EXPORT_SYMBOL(inode_setattr);
-+EXPORT_SYMBOL(inode_change_ok);
-+EXPORT_SYMBOL(write_inode_now);
-+EXPORT_SYMBOL(notify_change);
-+EXPORT_SYMBOL(set_blocksize);
-+EXPORT_SYMBOL(sb_set_blocksize);
-+EXPORT_SYMBOL(sb_min_blocksize);
-+EXPORT_SYMBOL(getblk);
-+EXPORT_SYMBOL(cdget);
-+EXPORT_SYMBOL(cdput);
-+EXPORT_SYMBOL(bdget);
-+EXPORT_SYMBOL(bdput);
-+EXPORT_SYMBOL(bread);
-+EXPORT_SYMBOL(__brelse);
-+EXPORT_SYMBOL(__bforget);
-+EXPORT_SYMBOL(ll_rw_block);
-+EXPORT_SYMBOL(submit_bh);
-+EXPORT_SYMBOL(unlock_buffer);
-+EXPORT_SYMBOL(__wait_on_buffer);
-+EXPORT_SYMBOL(___wait_on_page);
-+EXPORT_SYMBOL(generic_direct_IO);
-+EXPORT_SYMBOL(discard_bh_page);
-+EXPORT_SYMBOL(block_write_full_page);
-+EXPORT_SYMBOL(block_read_full_page);
-+EXPORT_SYMBOL(block_prepare_write);
-+EXPORT_SYMBOL(block_sync_page);
-+EXPORT_SYMBOL(generic_cont_expand);
-+EXPORT_SYMBOL(cont_prepare_write);
-+EXPORT_SYMBOL(generic_commit_write);
-+EXPORT_SYMBOL(block_truncate_page);
-+EXPORT_SYMBOL(generic_block_bmap);
-+EXPORT_SYMBOL(generic_file_read);
-+EXPORT_SYMBOL(do_generic_file_read);
-+EXPORT_SYMBOL(generic_file_write);
-+EXPORT_SYMBOL(generic_file_mmap);
-+EXPORT_SYMBOL(generic_ro_fops);
-+EXPORT_SYMBOL(generic_buffer_fdatasync);
-+EXPORT_SYMBOL(page_hash_bits);
-+EXPORT_SYMBOL(page_hash_table);
-+EXPORT_SYMBOL(file_lock_list);
-+EXPORT_SYMBOL(locks_init_lock);
-+EXPORT_SYMBOL(locks_copy_lock);
-+EXPORT_SYMBOL(posix_lock_file);
-+EXPORT_SYMBOL(posix_test_lock);
-+EXPORT_SYMBOL(posix_block_lock);
-+EXPORT_SYMBOL(posix_unblock_lock);
-+EXPORT_SYMBOL(posix_locks_deadlock);
-+EXPORT_SYMBOL(locks_mandatory_area);
-+EXPORT_SYMBOL(dput);
-+EXPORT_SYMBOL(have_submounts);
-+EXPORT_SYMBOL(d_find_alias);
-+EXPORT_SYMBOL(d_prune_aliases);
-+EXPORT_SYMBOL(prune_dcache);
-+EXPORT_SYMBOL(shrink_dcache_sb);
-+EXPORT_SYMBOL(shrink_dcache_parent);
-+EXPORT_SYMBOL_GPL(flush_dentry_attributes);
-+EXPORT_SYMBOL(find_inode_number);
-+EXPORT_SYMBOL(is_subdir);
-+EXPORT_SYMBOL(get_unused_fd);
-+EXPORT_SYMBOL(vfs_create);
-+EXPORT_SYMBOL(vfs_mkdir);
-+EXPORT_SYMBOL(vfs_mknod);
-+EXPORT_SYMBOL(vfs_symlink);
-+EXPORT_SYMBOL(vfs_link);
-+EXPORT_SYMBOL(vfs_rmdir);
-+EXPORT_SYMBOL(vfs_unlink);
-+EXPORT_SYMBOL(vfs_rename);
-+EXPORT_SYMBOL(vfs_statfs);
-+EXPORT_SYMBOL(generic_read_dir);
-+EXPORT_SYMBOL(generic_file_llseek);
-+EXPORT_SYMBOL(no_llseek);
-+EXPORT_SYMBOL(__pollwait);
-+EXPORT_SYMBOL(poll_freewait);
-+EXPORT_SYMBOL(ROOT_DEV);
-+EXPORT_SYMBOL(__find_get_page);
-+EXPORT_SYMBOL(__find_lock_page);
-+EXPORT_SYMBOL(find_or_create_page);
-+EXPORT_SYMBOL(grab_cache_page_nowait);
-+EXPORT_SYMBOL(read_cache_page);
-+EXPORT_SYMBOL(set_page_dirty);
-+EXPORT_SYMBOL(vfs_readlink);
-+EXPORT_SYMBOL(vfs_follow_link);
-+EXPORT_SYMBOL(page_readlink);
-+EXPORT_SYMBOL(page_follow_link);
-+EXPORT_SYMBOL(page_symlink_inode_operations);
-+EXPORT_SYMBOL(block_symlink);
-+EXPORT_SYMBOL(vfs_readdir);
-+EXPORT_SYMBOL(__get_lease);
-+EXPORT_SYMBOL(lease_get_mtime);
-+EXPORT_SYMBOL(lock_may_read);
-+EXPORT_SYMBOL(lock_may_write);
-+EXPORT_SYMBOL(dcache_dir_open);
-+EXPORT_SYMBOL(dcache_dir_close);
-+EXPORT_SYMBOL(dcache_dir_lseek);
-+EXPORT_SYMBOL(dcache_dir_fsync);
-+EXPORT_SYMBOL(dcache_readdir);
-+EXPORT_SYMBOL(dcache_dir_ops);
-+
+
+ #define kern_umount mntput
+
+--- linux-2.4.20-hp4_pnnl1/kernel/ksyms.c~exports_hp Tue Apr 1 20:36:07 2003
++++ linux-2.4.20-hp4_pnnl1-braam/kernel/ksyms.c Tue Apr 1 20:36:07 2003
+@@ -308,6 +308,11 @@
+ EXPORT_SYMBOL(dcache_readdir);
+ EXPORT_SYMBOL(dcache_dir_ops);
+
+/* lustre */
-+EXPORT_SYMBOL(panic_notifier_list);
+EXPORT_SYMBOL(pagecache_lock_cacheline);
++EXPORT_SYMBOL(panic_notifier_list);
+EXPORT_SYMBOL(do_kern_mount);
+
-+/* for stackable file systems (lofs, wrapfs, cryptfs, etc.) */
-+EXPORT_SYMBOL(default_llseek);
-+EXPORT_SYMBOL(dentry_open);
-+EXPORT_SYMBOL(filemap_nopage);
-+EXPORT_SYMBOL(filemap_sync);
-+EXPORT_SYMBOL(filemap_fdatasync);
-+EXPORT_SYMBOL(filemap_fdatawait);
-+EXPORT_SYMBOL(lock_page);
-+EXPORT_SYMBOL(unlock_page);
-+EXPORT_SYMBOL_GPL(wakeup_page_waiters);
-+
-+/* device registration */
-+EXPORT_SYMBOL(register_chrdev);
-+EXPORT_SYMBOL(unregister_chrdev);
-+EXPORT_SYMBOL(register_blkdev);
-+EXPORT_SYMBOL(unregister_blkdev);
-+EXPORT_SYMBOL(tty_register_driver);
-+EXPORT_SYMBOL(tty_unregister_driver);
-+EXPORT_SYMBOL(tty_std_termios);
-+
-+/* block device driver support */
-+EXPORT_SYMBOL(blksize_size);
-+EXPORT_SYMBOL(hardsect_size);
-+EXPORT_SYMBOL(blk_size);
-+EXPORT_SYMBOL(blk_dev);
-+EXPORT_SYMBOL(is_read_only);
-+EXPORT_SYMBOL(set_device_ro);
-+EXPORT_SYMBOL(bmap);
-+EXPORT_SYMBOL(sync_dev);
-+EXPORT_SYMBOL(devfs_register_partitions);
-+EXPORT_SYMBOL(blkdev_open);
-+EXPORT_SYMBOL(blkdev_get);
-+EXPORT_SYMBOL(blkdev_put);
-+EXPORT_SYMBOL(ioctl_by_bdev);
-+EXPORT_SYMBOL(grok_partitions);
-+EXPORT_SYMBOL(register_disk);
-+EXPORT_SYMBOL(tq_disk);
-+EXPORT_SYMBOL(init_buffer);
-+EXPORT_SYMBOL(refile_buffer);
-+EXPORT_SYMBOL(max_sectors);
-+EXPORT_SYMBOL(max_readahead);
-+
-+/* tty routines */
-+EXPORT_SYMBOL(tty_hangup);
-+EXPORT_SYMBOL(tty_wait_until_sent);
-+EXPORT_SYMBOL(tty_check_change);
-+EXPORT_SYMBOL(tty_hung_up_p);
-+EXPORT_SYMBOL(tty_flip_buffer_push);
-+EXPORT_SYMBOL(tty_get_baud_rate);
-+EXPORT_SYMBOL(do_SAK);
-+
-+/* filesystem registration */
-+EXPORT_SYMBOL(register_filesystem);
-+EXPORT_SYMBOL(unregister_filesystem);
-+EXPORT_SYMBOL(kern_mount);
-+EXPORT_SYMBOL(__mntput);
-+EXPORT_SYMBOL(may_umount);
-+
-+/* executable format registration */
-+EXPORT_SYMBOL(register_binfmt);
-+EXPORT_SYMBOL(unregister_binfmt);
-+EXPORT_SYMBOL(search_binary_handler);
-+EXPORT_SYMBOL(prepare_binprm);
-+EXPORT_SYMBOL(compute_creds);
-+EXPORT_SYMBOL(remove_arg_zero);
-+EXPORT_SYMBOL(set_binfmt);
-+
-+/* sysctl table registration */
-+EXPORT_SYMBOL(register_sysctl_table);
-+EXPORT_SYMBOL(unregister_sysctl_table);
-+EXPORT_SYMBOL(sysctl_string);
-+EXPORT_SYMBOL(sysctl_intvec);
-+EXPORT_SYMBOL(sysctl_jiffies);
-+EXPORT_SYMBOL(proc_dostring);
-+EXPORT_SYMBOL(proc_dointvec);
-+EXPORT_SYMBOL(proc_dointvec_jiffies);
-+EXPORT_SYMBOL(proc_dointvec_minmax);
-+EXPORT_SYMBOL(proc_doulongvec_ms_jiffies_minmax);
-+EXPORT_SYMBOL(proc_doulongvec_minmax);
-+
-+/* interrupt handling */
-+EXPORT_SYMBOL(add_timer);
-+EXPORT_SYMBOL(del_timer);
-+EXPORT_SYMBOL(request_irq);
-+EXPORT_SYMBOL(free_irq);
-+#if !defined(CONFIG_IA64) /* irq_stat is part of struct cpuinfo_ia64 */
-+EXPORT_SYMBOL(irq_stat);
-+#endif
-+
-+/* waitqueue handling */
-+EXPORT_SYMBOL(add_wait_queue);
-+EXPORT_SYMBOL(add_wait_queue_exclusive);
-+EXPORT_SYMBOL(remove_wait_queue);
-+
-+EXPORT_SYMBOL_GPL(flush_signal_handlers);
-+
-+/* completion handling */
-+EXPORT_SYMBOL(wait_for_completion);
-+EXPORT_SYMBOL(complete);
-+
-+/* The notion of irq probe/assignment is foreign to S/390 */
-+
-+#if !defined(CONFIG_ARCH_S390)
-+EXPORT_SYMBOL(probe_irq_on);
-+EXPORT_SYMBOL(probe_irq_off);
-+#endif
-+
-+#ifdef CONFIG_SMP
-+EXPORT_SYMBOL(del_timer_sync);
-+#endif
-+EXPORT_SYMBOL(mod_timer);
-+EXPORT_SYMBOL(tq_timer);
-+EXPORT_SYMBOL(tq_immediate);
-+
-+#ifdef CONFIG_SMP
-+/* Various random spinlocks we want to export */
-+EXPORT_SYMBOL(tqueue_lock);
-+
-+/* Big-Reader lock implementation */
-+EXPORT_SYMBOL(__brlock_array);
-+#ifndef __BRLOCK_USE_ATOMICS
-+EXPORT_SYMBOL(__br_write_locks);
-+#endif
-+EXPORT_SYMBOL(__br_write_lock);
-+EXPORT_SYMBOL(__br_write_unlock);
-+#endif
-+
-+/* Kiobufs */
-+EXPORT_SYMBOL(alloc_kiovec);
-+EXPORT_SYMBOL(free_kiovec);
-+EXPORT_SYMBOL(expand_kiobuf);
-+
-+EXPORT_SYMBOL(map_user_kiobuf);
-+EXPORT_SYMBOL(unmap_kiobuf);
-+EXPORT_SYMBOL(lock_kiovec);
-+EXPORT_SYMBOL(unlock_kiovec);
-+EXPORT_SYMBOL(brw_kiovec);
-+EXPORT_SYMBOL(kiobuf_wait_for_io);
-+
-+/* dma handling */
-+EXPORT_SYMBOL(request_dma);
-+EXPORT_SYMBOL(free_dma);
-+EXPORT_SYMBOL(dma_spin_lock);
-+#ifdef HAVE_DISABLE_HLT
-+EXPORT_SYMBOL(disable_hlt);
-+EXPORT_SYMBOL(enable_hlt);
-+#endif
-+
-+/* resource handling */
-+EXPORT_SYMBOL(request_resource);
-+EXPORT_SYMBOL(release_resource);
-+EXPORT_SYMBOL(allocate_resource);
-+EXPORT_SYMBOL(check_resource);
-+EXPORT_SYMBOL(__request_region);
-+EXPORT_SYMBOL(__check_region);
-+EXPORT_SYMBOL(__release_region);
-+EXPORT_SYMBOL(ioport_resource);
-+EXPORT_SYMBOL(iomem_resource);
-+
-+/* process management */
-+EXPORT_SYMBOL(complete_and_exit);
-+EXPORT_SYMBOL(__wake_up);
-+EXPORT_SYMBOL(wake_up_process);
-+EXPORT_SYMBOL(sleep_on);
-+EXPORT_SYMBOL(sleep_on_timeout);
-+EXPORT_SYMBOL(interruptible_sleep_on);
-+EXPORT_SYMBOL(interruptible_sleep_on_timeout);
-+EXPORT_SYMBOL(schedule);
-+EXPORT_SYMBOL(schedule_timeout);
-+EXPORT_SYMBOL(yield);
-+EXPORT_SYMBOL(__cond_resched);
-+EXPORT_SYMBOL(set_user_nice);
-+#ifdef CONFIG_SMP
-+EXPORT_SYMBOL_GPL(set_cpus_allowed);
-+#endif
-+EXPORT_SYMBOL(nr_context_switches);
-+EXPORT_SYMBOL(jiffies);
-+EXPORT_SYMBOL(xtime);
-+EXPORT_SYMBOL(do_gettimeofday);
-+EXPORT_SYMBOL(do_settimeofday);
-+
-+#if LOWLATENCY_NEEDED
-+EXPORT_SYMBOL(set_running_and_schedule);
-+
-+
-+
-+#endif
-+
-+#if !defined(__ia64__)
-+EXPORT_SYMBOL(loops_per_jiffy);
-+#endif
-+
-+EXPORT_SYMBOL(kstat);
-+
-+/* misc */
-+EXPORT_SYMBOL(panic);
-+EXPORT_SYMBOL_GPL(panic_notifier_list);
-+EXPORT_SYMBOL_GPL(panic_timeout);
-+EXPORT_SYMBOL(__out_of_line_bug);
-+EXPORT_SYMBOL(sprintf);
-+EXPORT_SYMBOL(snprintf);
-+EXPORT_SYMBOL(sscanf);
-+EXPORT_SYMBOL(vsprintf);
-+EXPORT_SYMBOL(vsnprintf);
-+EXPORT_SYMBOL(vsscanf);
-+EXPORT_SYMBOL(kdevname);
-+EXPORT_SYMBOL(bdevname);
-+EXPORT_SYMBOL(cdevname);
-+EXPORT_SYMBOL(simple_strtol);
-+EXPORT_SYMBOL(simple_strtoul);
-+EXPORT_SYMBOL(simple_strtoull);
-+EXPORT_SYMBOL(system_utsname); /* UTS data */
-+EXPORT_SYMBOL(uts_sem); /* UTS semaphore */
-+EXPORT_SYMBOL(machine_restart);
-+EXPORT_SYMBOL(machine_halt);
-+EXPORT_SYMBOL(machine_power_off);
-+EXPORT_SYMBOL(_ctype);
-+EXPORT_SYMBOL(secure_tcp_sequence_number);
-+EXPORT_SYMBOL(get_random_bytes);
-+EXPORT_SYMBOL(securebits);
-+EXPORT_SYMBOL(cap_bset);
-+EXPORT_SYMBOL(reparent_to_init);
-+EXPORT_SYMBOL(daemonize);
-+EXPORT_SYMBOL(csum_partial); /* for networking and md */
-+EXPORT_SYMBOL(seq_escape);
-+EXPORT_SYMBOL(seq_printf);
-+EXPORT_SYMBOL(seq_open);
-+EXPORT_SYMBOL(seq_release);
-+EXPORT_SYMBOL(seq_read);
-+EXPORT_SYMBOL(seq_lseek);
-+extern int disable_all_usb;
-+EXPORT_SYMBOL(disable_all_usb);
-+
-+/* Program loader interfaces */
-+EXPORT_SYMBOL(setup_arg_pages);
-+EXPORT_SYMBOL(copy_strings_kernel);
-+EXPORT_SYMBOL(do_execve);
-+EXPORT_SYMBOL(flush_old_exec);
-+EXPORT_SYMBOL(kernel_read);
-+EXPORT_SYMBOL(open_exec);
-+
-+/* Miscellaneous access points */
-+EXPORT_SYMBOL(si_meminfo);
-+
-+/* Added to make file system as module */
-+EXPORT_SYMBOL(sys_tz);
-+EXPORT_SYMBOL(file_fsync);
-+EXPORT_SYMBOL(fsync_buffers_list);
-+EXPORT_SYMBOL(clear_inode);
-+EXPORT_SYMBOL(___strtok);
-+EXPORT_SYMBOL(init_special_inode);
-+EXPORT_SYMBOL(read_ahead);
-+EXPORT_SYMBOL(get_hash_table);
-+EXPORT_SYMBOL(new_inode);
-+EXPORT_SYMBOL(insert_inode_hash);
-+EXPORT_SYMBOL(remove_inode_hash);
-+EXPORT_SYMBOL(buffer_insert_list);
-+EXPORT_SYMBOL(make_bad_inode);
-+EXPORT_SYMBOL(is_bad_inode);
-+EXPORT_SYMBOL(event);
-+EXPORT_SYMBOL(brw_page);
-+EXPORT_SYMBOL(__inode_dir_notify);
-+
-+#ifdef CONFIG_UID16
-+EXPORT_SYMBOL(overflowuid);
-+EXPORT_SYMBOL(overflowgid);
-+#endif
-+EXPORT_SYMBOL(fs_overflowuid);
-+EXPORT_SYMBOL(fs_overflowgid);
-+
-+/* all busmice */
-+EXPORT_SYMBOL(fasync_helper);
-+EXPORT_SYMBOL(kill_fasync);
-+
-+EXPORT_SYMBOL(disk_name); /* for md.c */
-+
-+/* binfmt_aout */
-+EXPORT_SYMBOL(get_write_access);
-+
-+/* library functions */
-+EXPORT_SYMBOL(strnicmp);
-+EXPORT_SYMBOL(strspn);
-+EXPORT_SYMBOL(strsep);
-+
-+/* software interrupts */
-+EXPORT_SYMBOL(tasklet_hi_vec);
-+EXPORT_SYMBOL(tasklet_vec);
-+EXPORT_SYMBOL(bh_task_vec);
-+EXPORT_SYMBOL(init_bh);
-+EXPORT_SYMBOL(remove_bh);
-+EXPORT_SYMBOL(tasklet_init);
-+EXPORT_SYMBOL(tasklet_kill);
-+EXPORT_SYMBOL(__run_task_queue);
-+EXPORT_SYMBOL(do_softirq);
-+EXPORT_SYMBOL(raise_softirq);
-+EXPORT_SYMBOL(cpu_raise_softirq);
-+EXPORT_SYMBOL(__tasklet_schedule);
-+EXPORT_SYMBOL(__tasklet_hi_schedule);
-+
-+/* init task, for moving kthread roots - ought to export a function ?? */
-+
-+EXPORT_SYMBOL(init_task_union);
-+
-+EXPORT_SYMBOL(tasklist_lock);
-+EXPORT_SYMBOL_GPL(next_thread);
-+EXPORT_SYMBOL_GPL(find_task_by_pid);
-+EXPORT_SYMBOL(sys_wait4);
-+EXPORT_SYMBOL_GPL(set_special_pids);
-+/* debug */
-+extern void check_tasklist_locked(void);
-+EXPORT_SYMBOL_GPL(check_tasklist_locked);
-+EXPORT_SYMBOL(dump_stack);
+ /* for stackable file systems (lofs, wrapfs, cryptfs, etc.) */
+ EXPORT_SYMBOL(default_llseek);
+ EXPORT_SYMBOL(dentry_open);
_
git://git.whamcloud.com / fs / lustre-release.git / commitdiff