117 files changed, 4274 insertions, 2521 deletions

diff --git a/fs/Kconfig.binfmt b/fs/Kconfig.binfmt
index 7c3d5f923da1..b5c3b6114add 100644
--- a/fs/Kconfig.binfmt
+++ b/fs/Kconfig.binfmt
@@ -61,7 +61,8 @@ config BINFMT_SHARED_FLAT
 
 config BINFMT_AOUT
         tristate "Kernel support for a.out and ECOFF binaries"
-        depends on X86_32 || ALPHA || ARM || M68K || SPARC32
+        depends on ARCH_SUPPORTS_AOUT && \
+                (X86_32 || ALPHA || ARM || M68K || SPARC32)
         ---help---
           A.out (Assembler.OUTput) is a set of formats for libraries and
           executables used in the earliest versions of UNIX.  Linux used
diff --git a/fs/adfs/super.c b/fs/adfs/super.c
index b36695ae5c2e..9e421eeb672b 100644
--- a/fs/adfs/super.c
+++ b/fs/adfs/super.c
@@ -20,6 +20,8 @@
 #include <linux/vfs.h>
 #include <linux/parser.h>
 #include <linux/bitops.h>
+#include <linux/mount.h>
+#include <linux/seq_file.h>
 
 #include <asm/uaccess.h>
 #include <asm/system.h>
@@ -30,6 +32,9 @@
 #include "dir_f.h"
 #include "dir_fplus.h"
 
+#define ADFS_DEFAULT_OWNER_MASK S_IRWXU
+#define ADFS_DEFAULT_OTHER_MASK (S_IRWXG | S_IRWXO)
+
 void __adfs_error(struct super_block *sb, const char *function, const char *fmt, ...)
 {
         char error_buf[128];
@@ -134,6 +139,22 @@ static void adfs_put_super(struct super_block *sb)
         sb->s_fs_info = NULL;
 }
 
+static int adfs_show_options(struct seq_file *seq, struct vfsmount *mnt)
+{
+        struct adfs_sb_info *asb = ADFS_SB(mnt->mnt_sb);
+
+        if (asb->s_uid != 0)
+                seq_printf(seq, ",uid=%u", asb->s_uid);
+        if (asb->s_gid != 0)
+                seq_printf(seq, ",gid=%u", asb->s_gid);
+        if (asb->s_owner_mask != ADFS_DEFAULT_OWNER_MASK)
+                seq_printf(seq, ",ownmask=%o", asb->s_owner_mask);
+        if (asb->s_other_mask != ADFS_DEFAULT_OTHER_MASK)
+                seq_printf(seq, ",othmask=%o", asb->s_other_mask);
+
+        return 0;
+}
+
 enum {Opt_uid, Opt_gid, Opt_ownmask, Opt_othmask, Opt_err};
 
 static match_table_t tokens = {
@@ -259,6 +280,7 @@ static const struct super_operations adfs_sops = {
         .put_super      = adfs_put_super,
         .statfs         = adfs_statfs,
         .remount_fs     = adfs_remount,
+        .show_options   = adfs_show_options,
 };
 
 static struct adfs_discmap *adfs_read_map(struct super_block *sb, struct adfs_discrecord *dr)
@@ -344,8 +366,8 @@ static int adfs_fill_super(struct super_block *sb, void *data, int silent)
         /* set default options */
         asb->s_uid = 0;
         asb->s_gid = 0;
-        asb->s_owner_mask = S_IRWXU;
-        asb->s_other_mask = S_IRWXG | S_IRWXO;
+        asb->s_owner_mask = ADFS_DEFAULT_OWNER_MASK;
+        asb->s_other_mask = ADFS_DEFAULT_OTHER_MASK;
 
         if (parse_options(sb, data))
                 goto error;
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 3c45d49c0d26..d2dc047cb479 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -122,6 +122,7 @@ static const struct super_operations affs_sops = {
         .write_super    = affs_write_super,
         .statfs         = affs_statfs,
         .remount_fs     = affs_remount,
+        .show_options   = generic_show_options,
 };
 
 enum {
@@ -272,6 +273,8 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
         u8                       sig[4];
         int                      ret = -EINVAL;
 
+        save_mount_options(sb, data);
+
         pr_debug("AFFS: read_super(%s)\n",data ? (const char *)data : "no options");
 
         sb->s_magic             = AFFS_SUPER_MAGIC;
@@ -487,14 +490,21 @@ affs_remount(struct super_block *sb, int *flags, char *data)
         int                      root_block;
         unsigned long            mount_flags;
         int                      res = 0;
+        char                    *new_opts = kstrdup(data, GFP_KERNEL);
 
         pr_debug("AFFS: remount(flags=0x%x,opts=\"%s\")\n",*flags,data);
 
         *flags |= MS_NODIRATIME;
 
-        if (!parse_options(data,&uid,&gid,&mode,&reserved,&root_block,
-            &blocksize,&sbi->s_prefix,sbi->s_volume,&mount_flags))
+        if (!parse_options(data, &uid, &gid, &mode, &reserved, &root_block,
+                           &blocksize, &sbi->s_prefix, sbi->s_volume,
+                           &mount_flags)) {
+                kfree(new_opts);
                 return -EINVAL;
+        }
+        kfree(sb->s_options);
+        sb->s_options = new_opts;
+
         sbi->s_flags = mount_flags;
         sbi->s_mode  = mode;
         sbi->s_uid   = uid;
diff --git a/fs/afs/security.c b/fs/afs/security.c
index 9446a1fd108a..3bcbeceba1bb 100644
--- a/fs/afs/security.c
+++ b/fs/afs/security.c
@@ -287,7 +287,7 @@ static int afs_check_permit(struct afs_vnode *vnode, struct key *key,
 int afs_permission(struct inode *inode, int mask, struct nameidata *nd)
 {
         struct afs_vnode *vnode = AFS_FS_I(inode);
-        afs_access_t access;
+        afs_access_t uninitialized_var(access);
         struct key *key;
         int ret;
 
diff --git a/fs/afs/super.c b/fs/afs/super.c
index 4b2558c42213..36bbce45f44b 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -52,6 +52,7 @@ static const struct super_operations afs_super_ops = {
         .clear_inode    = afs_clear_inode,
         .umount_begin   = afs_umount_begin,
         .put_super      = afs_put_super,
+        .show_options   = generic_show_options,
 };
 
 static struct kmem_cache *afs_inode_cachep;
@@ -357,6 +358,7 @@ static int afs_get_sb(struct file_system_type *fs_type,
         struct super_block *sb;
         struct afs_volume *vol;
         struct key *key;
+        char *new_opts = kstrdup(options, GFP_KERNEL);
         int ret;
 
         _enter(",,%s,%p", dev_name, options);
@@ -408,9 +410,11 @@ static int afs_get_sb(struct file_system_type *fs_type,
                         deactivate_super(sb);
                         goto error;
                 }
+                sb->s_options = new_opts;
                 sb->s_flags |= MS_ACTIVE;
         } else {
                 _debug("reuse");
+                kfree(new_opts);
                 ASSERTCMP(sb->s_flags, &, MS_ACTIVE);
         }
 
@@ -424,6 +428,7 @@ error:
         afs_put_volume(params.volume);
         afs_put_cell(params.cell);
         key_put(params.key);
+        kfree(new_opts);
         _leave(" = %d", ret);
         return ret;
 }
diff --git a/fs/aio.c b/fs/aio.c
index 8a37dbbf3437..b74c567383bc 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -317,7 +317,7 @@ out:
 /* wait_on_sync_kiocb:
  *      Waits on the given sync kiocb to complete.
  */
-ssize_t fastcall wait_on_sync_kiocb(struct kiocb *iocb)
+ssize_t wait_on_sync_kiocb(struct kiocb *iocb)
 {
         while (iocb->ki_users) {
                 set_current_state(TASK_UNINTERRUPTIBLE);
@@ -336,7 +336,7 @@ ssize_t fastcall wait_on_sync_kiocb(struct kiocb *iocb)
  * go away, they will call put_ioctx and release any pinned memory
  * associated with the request (held via struct page * references).
  */
-void fastcall exit_aio(struct mm_struct *mm)
+void exit_aio(struct mm_struct *mm)
 {
         struct kioctx *ctx = mm->ioctx_list;
         mm->ioctx_list = NULL;
@@ -365,7 +365,7 @@ void fastcall exit_aio(struct mm_struct *mm)
  *      Called when the last user of an aio context has gone away,
  *      and the struct needs to be freed.
  */
-void fastcall __put_ioctx(struct kioctx *ctx)
+void __put_ioctx(struct kioctx *ctx)
 {
         unsigned nr_events = ctx->max_reqs;
 
@@ -397,8 +397,7 @@ void fastcall __put_ioctx(struct kioctx *ctx)
  * This prevents races between the aio code path referencing the
  * req (after submitting it) and aio_complete() freeing the req.
  */
-static struct kiocb *__aio_get_req(struct kioctx *ctx);
-static struct kiocb fastcall *__aio_get_req(struct kioctx *ctx)
+static struct kiocb *__aio_get_req(struct kioctx *ctx)
 {
         struct kiocb *req = NULL;
         struct aio_ring *ring;
@@ -533,7 +532,7 @@ static int __aio_put_req(struct kioctx *ctx, struct kiocb *req)
  *      Returns true if this put was the last user of the kiocb,
  *      false if the request is still in use.
  */
-int fastcall aio_put_req(struct kiocb *req)
+int aio_put_req(struct kiocb *req)
 {
         struct kioctx *ctx = req->ki_ctx;
         int ret;
@@ -893,7 +892,7 @@ static void try_queue_kicked_iocb(struct kiocb *iocb)
  *      The retry is usually executed by aio workqueue
  *      threads (See aio_kick_handler).
  */
-void fastcall kick_iocb(struct kiocb *iocb)
+void kick_iocb(struct kiocb *iocb)
 {
         /* sync iocbs are easy: they can only ever be executing from a 
          * single context. */
@@ -912,7 +911,7 @@ EXPORT_SYMBOL(kick_iocb);
  *      Returns true if this is the last user of the request.  The 
  *      only other user of the request can be the cancellation code.
  */
-int fastcall aio_complete(struct kiocb *iocb, long res, long res2)
+int aio_complete(struct kiocb *iocb, long res, long res2)
 {
         struct kioctx   *ctx = iocb->ki_ctx;
         struct aio_ring_info    *info;
@@ -1330,6 +1329,10 @@ static ssize_t aio_rw_vect_retry(struct kiocb *iocb)
                 opcode = IOCB_CMD_PWRITEV;
         }
 
+        /* This matches the pread()/pwrite() logic */
+        if (iocb->ki_pos < 0)
+                return -EINVAL;
+
         do {
                 ret = rw_op(iocb, &iocb->ki_iovec[iocb->ki_cur_seg],
                             iocb->ki_nr_segs - iocb->ki_cur_seg,
@@ -1348,6 +1351,13 @@ static ssize_t aio_rw_vect_retry(struct kiocb *iocb)
         if ((ret == 0) || (iocb->ki_left == 0))
                 ret = iocb->ki_nbytes - iocb->ki_left;
 
+        /* If we managed to write some out we return that, rather than
+         * the eventual error. */
+        if (opcode == IOCB_CMD_PWRITEV
+            && ret < 0 && ret != -EIOCBQUEUED && ret != -EIOCBRETRY
+            && iocb->ki_nbytes - iocb->ki_left)
+                ret = iocb->ki_nbytes - iocb->ki_left;
+
         return ret;
 }
 
@@ -1523,7 +1533,7 @@ static int aio_wake_function(wait_queue_t *wait, unsigned mode,
         return 1;
 }
 
-int fastcall io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
+int io_submit_one(struct kioctx *ctx, struct iocb __user *user_iocb,
                          struct iocb *iocb)
 {
         struct kiocb *req;
diff --git a/fs/autofs/inode.c b/fs/autofs/inode.c
index 708bdb89fea1..dda510d31f84 100644
--- a/fs/autofs/inode.c
+++ b/fs/autofs/inode.c
@@ -54,6 +54,7 @@ out_kill_sb:
 
 static const struct super_operations autofs_sops = {
         .statfs         = simple_statfs,
+        .show_options   = generic_show_options,
 };
 
 enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto};
@@ -140,6 +141,8 @@ int autofs_fill_super(struct super_block *s, void *data, int silent)
         int minproto, maxproto;
         pid_t pgid;
 
+        save_mount_options(s, data);
+
         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
         if (!sbi)
                 goto fail_unlock;
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 7f05d6ccdb13..2fdcf5e1d236 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -176,11 +176,16 @@ out_kill_sb:
 static int autofs4_show_options(struct seq_file *m, struct vfsmount *mnt)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(mnt->mnt_sb);
+        struct inode *root_inode = mnt->mnt_sb->s_root->d_inode;
 
         if (!sbi)
                 return 0;
 
         seq_printf(m, ",fd=%d", sbi->pipefd);
+        if (root_inode->i_uid != 0)
+                seq_printf(m, ",uid=%u", root_inode->i_uid);
+        if (root_inode->i_gid != 0)
+                seq_printf(m, ",gid=%u", root_inode->i_gid);
         seq_printf(m, ",pgrp=%d", sbi->oz_pgrp);
         seq_printf(m, ",timeout=%lu", sbi->exp_timeout/HZ);
         seq_printf(m, ",minproto=%d", sbi->min_proto);
diff --git a/fs/befs/linuxvfs.c b/fs/befs/linuxvfs.c
index 403fe661c144..82123ff3e1dd 100644
--- a/fs/befs/linuxvfs.c
+++ b/fs/befs/linuxvfs.c
@@ -57,6 +57,7 @@ static const struct super_operations befs_sops = {
         .put_super      = befs_put_super,       /* uninit super */
         .statfs         = befs_statfs,  /* statfs */
         .remount_fs     = befs_remount,
+        .show_options   = generic_show_options,
 };
 
 /* slab cache for befs_inode_info objects */
@@ -759,10 +760,11 @@ befs_fill_super(struct super_block *sb, void *data, int silent)
         befs_super_block *disk_sb;
         struct inode *root;
         long ret = -EINVAL;
-
         const unsigned long sb_block = 0;
         const off_t x86_sb_off = 512;
 
+        save_mount_options(sb, data);
+
         sb->s_fs_info = kmalloc(sizeof (*befs_sb), GFP_KERNEL);
         if (sb->s_fs_info == NULL) {
                 printk(KERN_ERR
diff --git a/fs/binfmt_aout.c b/fs/binfmt_aout.c
index 7f65e71bf859..a1bb2244cac7 100644
--- a/fs/binfmt_aout.c
+++ b/fs/binfmt_aout.c
@@ -28,6 +28,7 @@
 #include <asm/system.h>
 #include <asm/uaccess.h>
 #include <asm/cacheflush.h>
+#include <asm/a.out-core.h>
 
 static int load_aout_binary(struct linux_binprm *, struct pt_regs * regs);
 static int load_aout_library(struct file*);
@@ -118,7 +119,7 @@ static int aout_core_dump(long signr, struct pt_regs *regs, struct file *file, u
         dump.u_ar0 = offsetof(struct user, regs);
 #endif
         dump.signal = signr;
-        dump_thread(regs, &dump);
+        aout_dump_thread(regs, &dump);
 
 /* If the size of the dump file exceeds the rlimit, then see what would happen
    if we wrote the stack, but not the data area.  */
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 111771d38e6e..41a958a7585e 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -134,8 +134,7 @@ static int padzero(unsigned long elf_bss)
 
 static int
 create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
-                int interp_aout, unsigned long load_addr,
-                unsigned long interp_load_addr)
+                unsigned long load_addr, unsigned long interp_load_addr)
 {
         unsigned long p = bprm->p;
         int argc = bprm->argc;
@@ -223,12 +222,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
 
         sp = STACK_ADD(p, ei_index);
 
-        items = (argc + 1) + (envc + 1);
-        if (interp_aout) {
-                items += 3; /* a.out interpreters require argv & envp too */
-        } else {
-                items += 1; /* ELF interpreters only put argc on the stack */
-        }
+        items = (argc + 1) + (envc + 1) + 1;
         bprm->p = STACK_ROUND(sp, items);
 
         /* Point sp at the lowest address on the stack */
@@ -251,16 +245,8 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
         /* Now, let's put argc (and argv, envp if appropriate) on the stack */
         if (__put_user(argc, sp++))
                 return -EFAULT;
-        if (interp_aout) {
-                argv = sp + 2;
-                envp = argv + argc + 1;
-                if (__put_user((elf_addr_t)(unsigned long)argv, sp++) ||
-                    __put_user((elf_addr_t)(unsigned long)envp, sp++))
-                        return -EFAULT;
-        } else {
-                argv = sp;
-                envp = argv + argc + 1;
-        }
+        argv = sp;
+        envp = argv + argc + 1;
 
         /* Populate argv and envp */
         p = current->mm->arg_end = current->mm->arg_start;
@@ -513,59 +499,12 @@ out:
         return error;
 }
 
-static unsigned long load_aout_interp(struct exec *interp_ex,
-                struct file *interpreter)
-{
-        unsigned long text_data, elf_entry = ~0UL;
-        char __user * addr;
-        loff_t offset;
-
-        current->mm->end_code = interp_ex->a_text;
-        text_data = interp_ex->a_text + interp_ex->a_data;
-        current->mm->end_data = text_data;
-        current->mm->brk = interp_ex->a_bss + text_data;
-
-        switch (N_MAGIC(*interp_ex)) {
-        case OMAGIC:
-                offset = 32;
-                addr = (char __user *)0;
-                break;
-        case ZMAGIC:
-        case QMAGIC:
-                offset = N_TXTOFF(*interp_ex);
-                addr = (char __user *)N_TXTADDR(*interp_ex);
-                break;
-        default:
-                goto out;
-        }
-
-        down_write(&current->mm->mmap_sem);     
-        do_brk(0, text_data);
-        up_write(&current->mm->mmap_sem);
-        if (!interpreter->f_op || !interpreter->f_op->read)
-                goto out;
-        if (interpreter->f_op->read(interpreter, addr, text_data, &offset) < 0)
-                goto out;
-        flush_icache_range((unsigned long)addr,
-                           (unsigned long)addr + text_data);
-
-        down_write(&current->mm->mmap_sem);     
-        do_brk(ELF_PAGESTART(text_data + ELF_MIN_ALIGN - 1),
-                interp_ex->a_bss);
-        up_write(&current->mm->mmap_sem);
-        elf_entry = interp_ex->a_entry;
-
-out:
-        return elf_entry;
-}
-
 /*
  * These are the functions used to load ELF style executables and shared
  * libraries.  There is no binary dependent code anywhere else.
  */
 
 #define INTERPRETER_NONE 0
-#define INTERPRETER_AOUT 1
 #define INTERPRETER_ELF 2
 
 #ifndef STACK_RND_MASK
@@ -594,7 +533,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         unsigned long load_addr = 0, load_bias = 0;
         int load_addr_set = 0;
         char * elf_interpreter = NULL;
-        unsigned int interpreter_type = INTERPRETER_NONE;
         unsigned long error;
         struct elf_phdr *elf_ppnt, *elf_phdata;
         unsigned long elf_bss, elf_brk;
@@ -605,7 +543,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         unsigned long interp_load_addr = 0;
         unsigned long start_code, end_code, start_data, end_data;
         unsigned long reloc_func_desc = 0;
-        char passed_fileno[6];
         struct files_struct *files;
         int executable_stack = EXSTACK_DEFAULT;
         unsigned long def_flags = 0;
@@ -774,59 +711,18 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
 
         /* Some simple consistency checks for the interpreter */
         if (elf_interpreter) {
-                static int warn;
-                interpreter_type = INTERPRETER_ELF | INTERPRETER_AOUT;
-
-                /* Now figure out which format our binary is */
-                if ((N_MAGIC(loc->interp_ex) != OMAGIC) &&
-                    (N_MAGIC(loc->interp_ex) != ZMAGIC) &&
-                    (N_MAGIC(loc->interp_ex) != QMAGIC))
-                        interpreter_type = INTERPRETER_ELF;
-
-                if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
-                        interpreter_type &= ~INTERPRETER_ELF;
-
-                if (interpreter_type == INTERPRETER_AOUT && warn < 10) {
-                        printk(KERN_WARNING "a.out ELF interpreter %s is "
-                                "deprecated and will not be supported "
-                                "after Linux 2.6.25\n", elf_interpreter);
-                        warn++;
-                }
-
                 retval = -ELIBBAD;
-                if (!interpreter_type)
+                /* Not an ELF interpreter */
+                if (memcmp(loc->interp_elf_ex.e_ident, ELFMAG, SELFMAG) != 0)
                         goto out_free_dentry;
-
-                /* Make sure only one type was selected */
-                if ((interpreter_type & INTERPRETER_ELF) &&
-                     interpreter_type != INTERPRETER_ELF) {
-                        // FIXME - ratelimit this before re-enabling
-                        // printk(KERN_WARNING "ELF: Ambiguous type, using ELF\n");
-                        interpreter_type = INTERPRETER_ELF;
-                }
                 /* Verify the interpreter has a valid arch */
-                if ((interpreter_type == INTERPRETER_ELF) &&
-                    !elf_check_arch(&loc->interp_elf_ex))
+                if (!elf_check_arch(&loc->interp_elf_ex))
                         goto out_free_dentry;
         } else {
                 /* Executables without an interpreter also need a personality  */
                 SET_PERSONALITY(loc->elf_ex, 0);
         }
 
-        /* OK, we are done with that, now set up the arg stuff,
-           and then start this sucker up */
-        if ((!bprm->sh_bang) && (interpreter_type == INTERPRETER_AOUT)) {
-                char *passed_p = passed_fileno;
-                sprintf(passed_fileno, "%d", elf_exec_fileno);
-
-                if (elf_interpreter) {
-                        retval = copy_strings_kernel(1, &passed_p, bprm);
-                        if (retval)
-                                goto out_free_dentry; 
-                        bprm->argc++;
-                }
-        }
-
         /* Flush all traces of the currently running executable */
         retval = flush_old_exec(bprm);
         if (retval)
@@ -1004,24 +900,19 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         }
 
         if (elf_interpreter) {
-                if (interpreter_type == INTERPRETER_AOUT) {
-                        elf_entry = load_aout_interp(&loc->interp_ex,
-                                                     interpreter);
-                } else {
-                        unsigned long uninitialized_var(interp_map_addr);
-
-                        elf_entry = load_elf_interp(&loc->interp_elf_ex,
-                                                    interpreter,
-                                                    &interp_map_addr,
-                                                    load_bias);
-                        if (!IS_ERR((void *)elf_entry)) {
-                                /*
-                                 * load_elf_interp() returns relocation
-                                 * adjustment
-                                 */
-                                interp_load_addr = elf_entry;
-                                elf_entry += loc->interp_elf_ex.e_entry;
-                        }
+                unsigned long uninitialized_var(interp_map_addr);
+
+                elf_entry = load_elf_interp(&loc->interp_elf_ex,
+                                            interpreter,
+                                            &interp_map_addr,
+                                            load_bias);
+                if (!IS_ERR((void *)elf_entry)) {
+                        /*
+                         * load_elf_interp() returns relocation
+                         * adjustment
+                         */
+                        interp_load_addr = elf_entry;
+                        elf_entry += loc->interp_elf_ex.e_entry;
                 }
                 if (BAD_ADDR(elf_entry)) {
                         force_sig(SIGSEGV, current);
@@ -1045,8 +936,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
 
         kfree(elf_phdata);
 
-        if (interpreter_type != INTERPRETER_AOUT)
-                sys_close(elf_exec_fileno);
+        sys_close(elf_exec_fileno);
 
         set_binfmt(&elf_format);
 
@@ -1061,15 +951,12 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         compute_creds(bprm);
         current->flags &= ~PF_FORKNOEXEC;
         retval = create_elf_tables(bprm, &loc->elf_ex,
-                          (interpreter_type == INTERPRETER_AOUT),
                           load_addr, interp_load_addr);
         if (retval < 0) {
                 send_sig(SIGKILL, current, 0);
                 goto out;
         }
         /* N.B. passed_fileno might not be initialized? */
-        if (interpreter_type == INTERPRETER_AOUT)
-                current->mm->arg_start += strlen(passed_fileno) + 1;
         current->mm->end_code = end_code;
         current->mm->start_code = start_code;
         current->mm->start_data = start_data;
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index 33764fd6db66..d8a02f1e08cc 100644
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -20,7 +20,6 @@
 #include <linux/sched.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
-#include <linux/a.out.h>
 #include <linux/errno.h>
 #include <linux/signal.h>
 #include <linux/string.h>
diff --git a/fs/binfmt_som.c b/fs/binfmt_som.c
index 9208c41209f9..14c63527c762 100644
--- a/fs/binfmt_som.c
+++ b/fs/binfmt_som.c
@@ -29,7 +29,6 @@
 #include <linux/personality.h>
 #include <linux/init.h>
 
-#include <asm/a.out.h>
 #include <asm/uaccess.h>
 #include <asm/pgtable.h>
 
diff --git a/fs/buffer.c b/fs/buffer.c
index 826baf4f04bc..3ebccf4aa7e3 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -67,14 +67,14 @@ static int sync_buffer(void *word)
         return 0;
 }
 
-void fastcall __lock_buffer(struct buffer_head *bh)
+void __lock_buffer(struct buffer_head *bh)
 {
         wait_on_bit_lock(&bh->b_state, BH_Lock, sync_buffer,
                                                         TASK_UNINTERRUPTIBLE);
 }
 EXPORT_SYMBOL(__lock_buffer);
 
-void fastcall unlock_buffer(struct buffer_head *bh)
+void unlock_buffer(struct buffer_head *bh)
 {
         smp_mb__before_clear_bit();
         clear_buffer_locked(bh);
@@ -678,7 +678,7 @@ void mark_buffer_dirty_inode(struct buffer_head *bh, struct inode *inode)
         } else {
                 BUG_ON(mapping->assoc_mapping != buffer_mapping);
         }
-        if (list_empty(&bh->b_assoc_buffers)) {
+        if (!bh->b_assoc_map) {
                 spin_lock(&buffer_mapping->private_lock);
                 list_move_tail(&bh->b_assoc_buffers,
                                 &mapping->private_list);
@@ -794,6 +794,7 @@ static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
 {
         struct buffer_head *bh;
         struct list_head tmp;
+        struct address_space *mapping;
         int err = 0, err2;
 
         INIT_LIST_HEAD(&tmp);
@@ -801,9 +802,14 @@ static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
         spin_lock(lock);
         while (!list_empty(list)) {
                 bh = BH_ENTRY(list->next);
+                mapping = bh->b_assoc_map;
                 __remove_assoc_queue(bh);
+                /* Avoid race with mark_buffer_dirty_inode() which does
+                 * a lockless check and we rely on seeing the dirty bit */
+                smp_mb();
                 if (buffer_dirty(bh) || buffer_locked(bh)) {
                         list_add(&bh->b_assoc_buffers, &tmp);
+                        bh->b_assoc_map = mapping;
                         if (buffer_dirty(bh)) {
                                 get_bh(bh);
                                 spin_unlock(lock);
@@ -822,8 +828,17 @@ static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
 
         while (!list_empty(&tmp)) {
                 bh = BH_ENTRY(tmp.prev);
-                list_del_init(&bh->b_assoc_buffers);
                 get_bh(bh);
+                mapping = bh->b_assoc_map;
+                __remove_assoc_queue(bh);
+                /* Avoid race with mark_buffer_dirty_inode() which does
+                 * a lockless check and we rely on seeing the dirty bit */
+                smp_mb();
+                if (buffer_dirty(bh)) {
+                        list_add(&bh->b_assoc_buffers,
+                                 &bh->b_assoc_map->private_list);
+                        bh->b_assoc_map = mapping;
+                }
                 spin_unlock(lock);
                 wait_on_buffer(bh);
                 if (!buffer_uptodate(bh))
@@ -1164,7 +1179,7 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)
  * mark_buffer_dirty() is atomic.  It takes bh->b_page->mapping->private_lock,
  * mapping->tree_lock and the global inode_lock.
  */
-void fastcall mark_buffer_dirty(struct buffer_head *bh)
+void mark_buffer_dirty(struct buffer_head *bh)
 {
         WARN_ON_ONCE(!buffer_uptodate(bh));
         if (!buffer_dirty(bh) && !test_set_buffer_dirty(bh))
@@ -1195,7 +1210,7 @@ void __brelse(struct buffer_head * buf)
 void __bforget(struct buffer_head *bh)
 {
         clear_buffer_dirty(bh);
-        if (!list_empty(&bh->b_assoc_buffers)) {
+        if (bh->b_assoc_map) {
                 struct address_space *buffer_mapping = bh->b_page->mapping;
 
                 spin_lock(&buffer_mapping->private_lock);
@@ -1436,6 +1451,7 @@ void invalidate_bh_lrus(void)
 {
         on_each_cpu(invalidate_bh_lru, NULL, 1, 1);
 }
+EXPORT_SYMBOL_GPL(invalidate_bh_lrus);
 
 void set_bh_page(struct buffer_head *bh,
                 struct page *page, unsigned long offset)
@@ -3021,7 +3037,7 @@ drop_buffers(struct page *page, struct buffer_head **buffers_to_free)
         do {
                 struct buffer_head *next = bh->b_this_page;
 
-                if (!list_empty(&bh->b_assoc_buffers))
+                if (bh->b_assoc_map)
                         __remove_assoc_queue(bh);
                 bh = next;
         } while (bh != head);
diff --git a/fs/char_dev.c b/fs/char_dev.c
index 2c7a8b5b4598..038674aa88a7 100644
--- a/fs/char_dev.c
+++ b/fs/char_dev.c
@@ -357,7 +357,7 @@ void cdev_put(struct cdev *p)
 /*
  * Called every time a character special file is opened
  */
-int chrdev_open(struct inode * inode, struct file * filp)
+static int chrdev_open(struct inode *inode, struct file *filp)
 {
         struct cdev *p;
         struct cdev *new = NULL;
diff --git a/fs/debugfs/file.c b/fs/debugfs/file.c
index fa6b7f7ff914..fddffe4851f5 100644
--- a/fs/debugfs/file.c
+++ b/fs/debugfs/file.c
@@ -56,13 +56,15 @@ const struct inode_operations debugfs_link_operations = {
         .follow_link    = debugfs_follow_link,
 };
 
-static void debugfs_u8_set(void *data, u64 val)
+static int debugfs_u8_set(void *data, u64 val)
 {
         *(u8 *)data = val;
+        return 0;
 }
-static u64 debugfs_u8_get(void *data)
+static int debugfs_u8_get(void *data, u64 *val)
 {
-        return *(u8 *)data;
+        *val = *(u8 *)data;
+        return 0;
 }
 DEFINE_SIMPLE_ATTRIBUTE(fops_u8, debugfs_u8_get, debugfs_u8_set, "%llu\n");
 
@@ -97,13 +99,15 @@ struct dentry *debugfs_create_u8(const char *name, mode_t mode,
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u8);
 
-static void debugfs_u16_set(void *data, u64 val)
+static int debugfs_u16_set(void *data, u64 val)
 {
         *(u16 *)data = val;
+        return 0;
 }
-static u64 debugfs_u16_get(void *data)
+static int debugfs_u16_get(void *data, u64 *val)
 {
-        return *(u16 *)data;
+        *val = *(u16 *)data;
+        return 0;
 }
 DEFINE_SIMPLE_ATTRIBUTE(fops_u16, debugfs_u16_get, debugfs_u16_set, "%llu\n");
 
@@ -138,13 +142,15 @@ struct dentry *debugfs_create_u16(const char *name, mode_t mode,
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u16);
 
-static void debugfs_u32_set(void *data, u64 val)
+static int debugfs_u32_set(void *data, u64 val)
 {
         *(u32 *)data = val;
+        return 0;
 }
-static u64 debugfs_u32_get(void *data)
+static int debugfs_u32_get(void *data, u64 *val)
 {
-        return *(u32 *)data;
+        *val = *(u32 *)data;
+        return 0;
 }
 DEFINE_SIMPLE_ATTRIBUTE(fops_u32, debugfs_u32_get, debugfs_u32_set, "%llu\n");
 
@@ -179,14 +185,16 @@ struct dentry *debugfs_create_u32(const char *name, mode_t mode,
 }
 EXPORT_SYMBOL_GPL(debugfs_create_u32);
 
-static void debugfs_u64_set(void *data, u64 val)
+static int debugfs_u64_set(void *data, u64 val)
 {
         *(u64 *)data = val;
+        return 0;
 }
 
-static u64 debugfs_u64_get(void *data)
+static int debugfs_u64_get(void *data, u64 *val)
 {
-        return *(u64 *)data;
+        *val = *(u64 *)data;
+        return 0;
 }
 DEFINE_SIMPLE_ATTRIBUTE(fops_u64, debugfs_u64_get, debugfs_u64_set, "%llu\n");
 
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 06ef9a255c76..f120e1207874 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -20,9 +20,12 @@
 #include <linux/devpts_fs.h>
 #include <linux/parser.h>
 #include <linux/fsnotify.h>
+#include <linux/seq_file.h>
 
 #define DEVPTS_SUPER_MAGIC 0x1cd1
 
+#define DEVPTS_DEFAULT_MODE 0600
+
 static struct vfsmount *devpts_mnt;
 static struct dentry *devpts_root;
 
@@ -32,7 +35,7 @@ static struct {
         uid_t   uid;
         gid_t   gid;
         umode_t mode;
-} config = {.mode = 0600};
+} config = {.mode = DEVPTS_DEFAULT_MODE};
 
 enum {
         Opt_uid, Opt_gid, Opt_mode,
@@ -54,7 +57,7 @@ static int devpts_remount(struct super_block *sb, int *flags, char *data)
         config.setgid  = 0;
         config.uid     = 0;
         config.gid     = 0;
-        config.mode    = 0600;
+        config.mode    = DEVPTS_DEFAULT_MODE;
 
         while ((p = strsep(&data, ",")) != NULL) {
                 substring_t args[MAX_OPT_ARGS];
@@ -81,7 +84,7 @@ static int devpts_remount(struct super_block *sb, int *flags, char *data)
                 case Opt_mode:
                         if (match_octal(&args[0], &option))
                                 return -EINVAL;
-                        config.mode = option & ~S_IFMT;
+                        config.mode = option & S_IALLUGO;
                         break;
                 default:
                         printk(KERN_ERR "devpts: called with bogus options\n");
@@ -92,9 +95,21 @@ static int devpts_remount(struct super_block *sb, int *flags, char *data)
         return 0;
 }
 
+static int devpts_show_options(struct seq_file *seq, struct vfsmount *vfs)
+{
+        if (config.setuid)
+                seq_printf(seq, ",uid=%u", config.uid);
+        if (config.setgid)
+                seq_printf(seq, ",gid=%u", config.gid);
+        seq_printf(seq, ",mode=%03o", config.mode);
+
+        return 0;
+}
+
 static const struct super_operations devpts_sops = {
         .statfs         = simple_statfs,
         .remount_fs     = devpts_remount,
+        .show_options   = devpts_show_options,
 };
 
 static int
diff --git a/fs/dlm/ast.c b/fs/dlm/ast.c
index 6308122890ca..8bf31e3fbf01 100644
--- a/fs/dlm/ast.c
+++ b/fs/dlm/ast.c
@@ -39,7 +39,6 @@ void dlm_add_ast(struct dlm_lkb *lkb, int type)
                 dlm_user_add_ast(lkb, type);
                 return;
         }
-        DLM_ASSERT(lkb->lkb_astaddr != DLM_FAKE_USER_AST, dlm_print_lkb(lkb););
 
         spin_lock(&ast_queue_lock);
         if (!(lkb->lkb_ast_type & (AST_COMP | AST_BAST))) {
@@ -58,8 +57,8 @@ static void process_asts(void)
         struct dlm_ls *ls = NULL;
         struct dlm_rsb *r = NULL;
         struct dlm_lkb *lkb;
-        void (*cast) (long param);
-        void (*bast) (long param, int mode);
+        void (*cast) (void *astparam);
+        void (*bast) (void *astparam, int mode);
         int type = 0, found, bmode;
 
         for (;;) {
@@ -83,8 +82,8 @@ static void process_asts(void)
                 if (!found)
                         break;
 
-                cast = lkb->lkb_astaddr;
-                bast = lkb->lkb_bastaddr;
+                cast = lkb->lkb_astfn;
+                bast = lkb->lkb_bastfn;
                 bmode = lkb->lkb_bastmode;
 
                 if ((type & AST_COMP) && cast)
diff --git a/fs/dlm/config.c b/fs/dlm/config.c
index 2f8e3c81bc19..c3ad1dff3b25 100644
--- a/fs/dlm/config.c
+++ b/fs/dlm/config.c
@@ -604,7 +604,7 @@ static struct clusters clusters_root = {
         },
 };
 
-int dlm_config_init(void)
+int __init dlm_config_init(void)
 {
         config_group_init(&clusters_root.subsys.su_group);
         mutex_init(&clusters_root.subsys.su_mutex);
diff --git a/fs/dlm/debug_fs.c b/fs/dlm/debug_fs.c
index 12c3bfd5e660..8fc24f4507a3 100644
--- a/fs/dlm/debug_fs.c
+++ b/fs/dlm/debug_fs.c
@@ -162,14 +162,12 @@ static int print_resource(struct dlm_rsb *res, struct seq_file *s)
 
 static void print_lock(struct seq_file *s, struct dlm_lkb *lkb, struct dlm_rsb *r)
 {
-        struct dlm_user_args *ua;
         unsigned int waiting = 0;
         uint64_t xid = 0;
 
         if (lkb->lkb_flags & DLM_IFL_USER) {
-                ua = (struct dlm_user_args *) lkb->lkb_astparam;
-                if (ua)
-                        xid = ua->xid;
+                if (lkb->lkb_ua)
+                        xid = lkb->lkb_ua->xid;
         }
 
         if (lkb->lkb_timestamp)
@@ -543,7 +541,7 @@ void dlm_delete_debug_file(struct dlm_ls *ls)
                 debugfs_remove(ls->ls_debug_locks_dentry);
 }
 
-int dlm_register_debugfs(void)
+int __init dlm_register_debugfs(void)
 {
         mutex_init(&debug_buf_lock);
         dlm_root = debugfs_create_dir("dlm", NULL);
diff --git a/fs/dlm/dir.c b/fs/dlm/dir.c
index ff97ba924333..85defeb64df4 100644
--- a/fs/dlm/dir.c
+++ b/fs/dlm/dir.c
@@ -220,6 +220,7 @@ int dlm_recover_directory(struct dlm_ls *ls)
                 last_len = 0;
 
                 for (;;) {
+                        int left;
                         error = dlm_recovery_stopped(ls);
                         if (error)
                                 goto out_free;
@@ -235,12 +236,21 @@ int dlm_recover_directory(struct dlm_ls *ls)
                          * pick namelen/name pairs out of received buffer
                          */
 
-                        b = ls->ls_recover_buf + sizeof(struct dlm_rcom);
+                        b = ls->ls_recover_buf->rc_buf;
+                        left = ls->ls_recover_buf->rc_header.h_length;
+                        left -= sizeof(struct dlm_rcom);
 
                         for (;;) {
-                                memcpy(&namelen, b, sizeof(uint16_t));
-                                namelen = be16_to_cpu(namelen);
-                                b += sizeof(uint16_t);
+                                __be16 v;
+
+                                error = -EINVAL;
+                                if (left < sizeof(__be16))
+                                        goto out_free;
+
+                                memcpy(&v, b, sizeof(__be16));
+                                namelen = be16_to_cpu(v);
+                                b += sizeof(__be16);
+                                left -= sizeof(__be16);
 
                                 /* namelen of 0xFFFFF marks end of names for
                                    this node; namelen of 0 marks end of the
@@ -251,6 +261,12 @@ int dlm_recover_directory(struct dlm_ls *ls)
                                 if (!namelen)
                                         break;
 
+                                if (namelen > left)
+                                        goto out_free;
+
+                                if (namelen > DLM_RESNAME_MAXLEN)
+                                        goto out_free;
+
                                 error = -ENOMEM;
                                 de = get_free_de(ls, namelen);
                                 if (!de)
@@ -262,6 +278,7 @@ int dlm_recover_directory(struct dlm_ls *ls)
                                 memcpy(de->name, b, namelen);
                                 memcpy(last_name, b, namelen);
                                 b += namelen;
+                                left -= namelen;
 
                                 add_entry_to_hash(ls, de);
                                 count++;
@@ -302,6 +319,9 @@ static int get_entry(struct dlm_ls *ls, int nodeid, char *name,
 
         write_unlock(&ls->ls_dirtbl[bucket].lock);
 
+        if (namelen > DLM_RESNAME_MAXLEN)
+                return -EINVAL;
+
         de = kzalloc(sizeof(struct dlm_direntry) + namelen, GFP_KERNEL);
         if (!de)
                 return -ENOMEM;
diff --git a/fs/dlm/dlm_internal.h b/fs/dlm/dlm_internal.h
index ec61bbaf25df..d30ea8b433a2 100644
--- a/fs/dlm/dlm_internal.h
+++ b/fs/dlm/dlm_internal.h
@@ -92,8 +92,6 @@ do { \
   } \
 }
 
-#define DLM_FAKE_USER_AST ERR_PTR(-EINVAL)
-
 
 struct dlm_direntry {
         struct list_head        list;
@@ -146,9 +144,9 @@ struct dlm_recover {
 
 struct dlm_args {
         uint32_t                flags;
-        void                    *astaddr;
-        long                    astparam;
-        void                    *bastaddr;
+        void                    (*astfn) (void *astparam);
+        void                    *astparam;
+        void                    (*bastfn) (void *astparam, int mode);
         int                     mode;
         struct dlm_lksb         *lksb;
         unsigned long           timeout;
@@ -253,9 +251,12 @@ struct dlm_lkb {
 
         char                    *lkb_lvbptr;
         struct dlm_lksb         *lkb_lksb;      /* caller's status block */
-        void                    *lkb_astaddr;   /* caller's ast function */
-        void                    *lkb_bastaddr;  /* caller's bast function */
-        long                    lkb_astparam;   /* caller's ast arg */
+        void                    (*lkb_astfn) (void *astparam);
+        void                    (*lkb_bastfn) (void *astparam, int mode);
+        union {
+                void                    *lkb_astparam;  /* caller's ast arg */
+                struct dlm_user_args    *lkb_ua;
+        };
 };
 
 
@@ -403,28 +404,34 @@ struct dlm_rcom {
         char                    rc_buf[0];
 };
 
+union dlm_packet {
+        struct dlm_header       header;         /* common to other two */
+        struct dlm_message      message;
+        struct dlm_rcom         rcom;
+};
+
 struct rcom_config {
-        uint32_t                rf_lvblen;
-        uint32_t                rf_lsflags;
-        uint64_t                rf_unused;
+        __le32                  rf_lvblen;
+        __le32                  rf_lsflags;
+        __le64                  rf_unused;
 };
 
 struct rcom_lock {
-        uint32_t                rl_ownpid;
-        uint32_t                rl_lkid;
-        uint32_t                rl_remid;
-        uint32_t                rl_parent_lkid;
-        uint32_t                rl_parent_remid;
-        uint32_t                rl_exflags;
-        uint32_t                rl_flags;
-        uint32_t                rl_lvbseq;
-        int                     rl_result;
+        __le32                  rl_ownpid;
+        __le32                  rl_lkid;
+        __le32                  rl_remid;
+        __le32                  rl_parent_lkid;
+        __le32                  rl_parent_remid;
+        __le32                  rl_exflags;
+        __le32                  rl_flags;
+        __le32                  rl_lvbseq;
+        __le32                  rl_result;
         int8_t                  rl_rqmode;
         int8_t                  rl_grmode;
         int8_t                  rl_status;
         int8_t                  rl_asts;
-        uint16_t                rl_wait_type;
-        uint16_t                rl_namelen;
+        __le16                  rl_wait_type;
+        __le16                  rl_namelen;
         char                    rl_name[DLM_RESNAME_MAXLEN];
         char                    rl_lvb[0];
 };
@@ -494,7 +501,7 @@ struct dlm_ls {
         struct rw_semaphore     ls_recv_active; /* block dlm_recv */
         struct list_head        ls_requestqueue;/* queue remote requests */
         struct mutex            ls_requestqueue_mutex;
-        char                    *ls_recover_buf;
+        struct dlm_rcom         *ls_recover_buf;
         int                     ls_recover_nodeid; /* for debugging */
         uint64_t                ls_rcom_seq;
         spinlock_t              ls_rcom_spin;
diff --git a/fs/dlm/lock.c b/fs/dlm/lock.c
index ff4a198fa677..8f250ac8b928 100644
--- a/fs/dlm/lock.c
+++ b/fs/dlm/lock.c
@@ -436,11 +436,15 @@ static int find_rsb(struct dlm_ls *ls, char *name, int namelen,
 {
         struct dlm_rsb *r, *tmp;
         uint32_t hash, bucket;
-        int error = 0;
+        int error = -EINVAL;
+
+        if (namelen > DLM_RESNAME_MAXLEN)
+                goto out;
 
         if (dlm_no_directory(ls))
                 flags |= R_CREATE;
 
+        error = 0;
         hash = jhash(name, namelen, 0);
         bucket = hash & (ls->ls_rsbtbl_size - 1);
 
@@ -1222,6 +1226,8 @@ static void set_lvb_lock_pc(struct dlm_rsb *r, struct dlm_lkb *lkb,
         b = dlm_lvb_operations[lkb->lkb_grmode + 1][lkb->lkb_rqmode + 1];
         if (b == 1) {
                 int len = receive_extralen(ms);
+                if (len > DLM_RESNAME_MAXLEN)
+                        len = DLM_RESNAME_MAXLEN;
                 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
                 lkb->lkb_lvbseq = ms->m_lvbseq;
         }
@@ -1775,7 +1781,7 @@ static void grant_pending_locks(struct dlm_rsb *r)
          */
 
         list_for_each_entry_safe(lkb, s, &r->res_grantqueue, lkb_statequeue) {
-                if (lkb->lkb_bastaddr && lock_requires_bast(lkb, high, cw)) {
+                if (lkb->lkb_bastfn && lock_requires_bast(lkb, high, cw)) {
                         if (cw && high == DLM_LOCK_PR)
                                 queue_bast(r, lkb, DLM_LOCK_CW);
                         else
@@ -1805,7 +1811,7 @@ static void send_bast_queue(struct dlm_rsb *r, struct list_head *head,
         struct dlm_lkb *gr;
 
         list_for_each_entry(gr, head, lkb_statequeue) {
-                if (gr->lkb_bastaddr && modes_require_bast(gr, lkb)) {
+                if (gr->lkb_bastfn && modes_require_bast(gr, lkb)) {
                         queue_bast(r, gr, lkb->lkb_rqmode);
                         gr->lkb_highbast = lkb->lkb_rqmode;
                 }
@@ -1960,8 +1966,11 @@ static void confirm_master(struct dlm_rsb *r, int error)
 }
 
 static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
-                         int namelen, unsigned long timeout_cs, void *ast,
-                         void *astarg, void *bast, struct dlm_args *args)
+                         int namelen, unsigned long timeout_cs,
+                         void (*ast) (void *astparam),
+                         void *astparam,
+                         void (*bast) (void *astparam, int mode),
+                         struct dlm_args *args)
 {
         int rv = -EINVAL;
 
@@ -2011,9 +2020,9 @@ static int set_lock_args(int mode, struct dlm_lksb *lksb, uint32_t flags,
            an active lkb cannot be modified before locking the rsb */
 
         args->flags = flags;
-        args->astaddr = ast;
-        args->astparam = (long) astarg;
-        args->bastaddr = bast;
+        args->astfn = ast;
+        args->astparam = astparam;
+        args->bastfn = bast;
         args->timeout = timeout_cs;
         args->mode = mode;
         args->lksb = lksb;
@@ -2032,7 +2041,7 @@ static int set_unlock_args(uint32_t flags, void *astarg, struct dlm_args *args)
                 return -EINVAL;
 
         args->flags = flags;
-        args->astparam = (long) astarg;
+        args->astparam = astarg;
         return 0;
 }
 
@@ -2062,9 +2071,9 @@ static int validate_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
 
         lkb->lkb_exflags = args->flags;
         lkb->lkb_sbflags = 0;
-        lkb->lkb_astaddr = args->astaddr;
+        lkb->lkb_astfn = args->astfn;
         lkb->lkb_astparam = args->astparam;
-        lkb->lkb_bastaddr = args->bastaddr;
+        lkb->lkb_bastfn = args->bastfn;
         lkb->lkb_rqmode = args->mode;
         lkb->lkb_lksb = args->lksb;
         lkb->lkb_lvbptr = args->lksb->sb_lvbptr;
@@ -2711,9 +2720,9 @@ static void send_args(struct dlm_rsb *r, struct dlm_lkb *lkb,
         /* m_result and m_bastmode are set from function args,
            not from lkb fields */
 
-        if (lkb->lkb_bastaddr)
+        if (lkb->lkb_bastfn)
                 ms->m_asts |= AST_BAST;
-        if (lkb->lkb_astaddr)
+        if (lkb->lkb_astfn)
                 ms->m_asts |= AST_COMP;
 
         /* compare with switch in create_message; send_remove() doesn't
@@ -2989,11 +2998,23 @@ static int receive_lvb(struct dlm_ls *ls, struct dlm_lkb *lkb,
                 if (!lkb->lkb_lvbptr)
                         return -ENOMEM;
                 len = receive_extralen(ms);
+                if (len > DLM_RESNAME_MAXLEN)
+                        len = DLM_RESNAME_MAXLEN;
                 memcpy(lkb->lkb_lvbptr, ms->m_extra, len);
         }
         return 0;
 }
 
+static void fake_bastfn(void *astparam, int mode)
+{
+        log_print("fake_bastfn should not be called");
+}
+
+static void fake_astfn(void *astparam)
+{
+        log_print("fake_astfn should not be called");
+}
+
 static int receive_request_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
                                 struct dlm_message *ms)
 {
@@ -3002,8 +3023,9 @@ static int receive_request_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
         lkb->lkb_remid = ms->m_lkid;
         lkb->lkb_grmode = DLM_LOCK_IV;
         lkb->lkb_rqmode = ms->m_rqmode;
-        lkb->lkb_bastaddr = (void *) (long) (ms->m_asts & AST_BAST);
-        lkb->lkb_astaddr = (void *) (long) (ms->m_asts & AST_COMP);
+
+        lkb->lkb_bastfn = (ms->m_asts & AST_BAST) ? &fake_bastfn : NULL;
+        lkb->lkb_astfn = (ms->m_asts & AST_COMP) ? &fake_astfn : NULL;
 
         if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
                 /* lkb was just created so there won't be an lvb yet */
@@ -3802,7 +3824,7 @@ static void dlm_receive_message(struct dlm_ls *ls, struct dlm_message *ms,
                                 int nodeid)
 {
         if (dlm_locking_stopped(ls)) {
-                dlm_add_requestqueue(ls, nodeid, (struct dlm_header *) ms);
+                dlm_add_requestqueue(ls, nodeid, ms);
         } else {
                 dlm_wait_requestqueue(ls);
                 _receive_message(ls, ms);
@@ -3822,21 +3844,20 @@ void dlm_receive_message_saved(struct dlm_ls *ls, struct dlm_message *ms)
    standard locking activity) or an RCOM (recovery message sent as part of
    lockspace recovery). */
 
-void dlm_receive_buffer(struct dlm_header *hd, int nodeid)
+void dlm_receive_buffer(union dlm_packet *p, int nodeid)
 {
-        struct dlm_message *ms = (struct dlm_message *) hd;
-        struct dlm_rcom *rc = (struct dlm_rcom *) hd;
+        struct dlm_header *hd = &p->header;
         struct dlm_ls *ls;
         int type = 0;
 
         switch (hd->h_cmd) {
         case DLM_MSG:
-                dlm_message_in(ms);
-                type = ms->m_type;
+                dlm_message_in(&p->message);
+                type = p->message.m_type;
                 break;
         case DLM_RCOM:
-                dlm_rcom_in(rc);
-                type = rc->rc_type;
+                dlm_rcom_in(&p->rcom);
+                type = p->rcom.rc_type;
                 break;
         default:
                 log_print("invalid h_cmd %d from %u", hd->h_cmd, nodeid);
@@ -3856,7 +3877,7 @@ void dlm_receive_buffer(struct dlm_header *hd, int nodeid)
                                   hd->h_lockspace, nodeid, hd->h_cmd, type);
 
                 if (hd->h_cmd == DLM_RCOM && type == DLM_RCOM_STATUS)
-                        dlm_send_ls_not_ready(nodeid, rc);
+                        dlm_send_ls_not_ready(nodeid, &p->rcom);
                 return;
         }
 
@@ -3865,9 +3886,9 @@ void dlm_receive_buffer(struct dlm_header *hd, int nodeid)
 
         down_read(&ls->ls_recv_active);
         if (hd->h_cmd == DLM_MSG)
-                dlm_receive_message(ls, ms, nodeid);
+                dlm_receive_message(ls, &p->message, nodeid);
         else
-                dlm_receive_rcom(ls, rc, nodeid);
+                dlm_receive_rcom(ls, &p->rcom, nodeid);
         up_read(&ls->ls_recv_active);
 
         dlm_put_lockspace(ls);
@@ -4267,32 +4288,34 @@ static struct dlm_lkb *search_remid(struct dlm_rsb *r, int nodeid,
         return NULL;
 }
 
+/* needs at least dlm_rcom + rcom_lock */
 static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
                                   struct dlm_rsb *r, struct dlm_rcom *rc)
 {
         struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
-        int lvblen;
 
         lkb->lkb_nodeid = rc->rc_header.h_nodeid;
-        lkb->lkb_ownpid = rl->rl_ownpid;
-        lkb->lkb_remid = rl->rl_lkid;
-        lkb->lkb_exflags = rl->rl_exflags;
-        lkb->lkb_flags = rl->rl_flags & 0x0000FFFF;
+        lkb->lkb_ownpid = le32_to_cpu(rl->rl_ownpid);
+        lkb->lkb_remid = le32_to_cpu(rl->rl_lkid);
+        lkb->lkb_exflags = le32_to_cpu(rl->rl_exflags);
+        lkb->lkb_flags = le32_to_cpu(rl->rl_flags) & 0x0000FFFF;
         lkb->lkb_flags |= DLM_IFL_MSTCPY;
-        lkb->lkb_lvbseq = rl->rl_lvbseq;
+        lkb->lkb_lvbseq = le32_to_cpu(rl->rl_lvbseq);
         lkb->lkb_rqmode = rl->rl_rqmode;
         lkb->lkb_grmode = rl->rl_grmode;
         /* don't set lkb_status because add_lkb wants to itself */
 
-        lkb->lkb_bastaddr = (void *) (long) (rl->rl_asts & AST_BAST);
-        lkb->lkb_astaddr = (void *) (long) (rl->rl_asts & AST_COMP);
+        lkb->lkb_bastfn = (rl->rl_asts & AST_BAST) ? &fake_bastfn : NULL;
+        lkb->lkb_astfn = (rl->rl_asts & AST_COMP) ? &fake_astfn : NULL;
 
         if (lkb->lkb_exflags & DLM_LKF_VALBLK) {
+                int lvblen = rc->rc_header.h_length - sizeof(struct dlm_rcom) -
+                         sizeof(struct rcom_lock);
+                if (lvblen > ls->ls_lvblen)
+                        return -EINVAL;
                 lkb->lkb_lvbptr = dlm_allocate_lvb(ls);
                 if (!lkb->lkb_lvbptr)
                         return -ENOMEM;
-                lvblen = rc->rc_header.h_length - sizeof(struct dlm_rcom) -
-                         sizeof(struct rcom_lock);
                 memcpy(lkb->lkb_lvbptr, rl->rl_lvb, lvblen);
         }
 
@@ -4300,7 +4323,8 @@ static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
            The real granted mode of these converting locks cannot be determined
            until all locks have been rebuilt on the rsb (recover_conversion) */
 
-        if (rl->rl_wait_type == DLM_MSG_CONVERT && middle_conversion(lkb)) {
+        if (rl->rl_wait_type == cpu_to_le16(DLM_MSG_CONVERT) &&
+            middle_conversion(lkb)) {
                 rl->rl_status = DLM_LKSTS_CONVERT;
                 lkb->lkb_grmode = DLM_LOCK_IV;
                 rsb_set_flag(r, RSB_RECOVER_CONVERT);
@@ -4315,6 +4339,7 @@ static int receive_rcom_lock_args(struct dlm_ls *ls, struct dlm_lkb *lkb,
    the given values and send back our lkid.  We send back our lkid by sending
    back the rcom_lock struct we got but with the remid field filled in. */
 
+/* needs at least dlm_rcom + rcom_lock */
 int dlm_recover_master_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
 {
         struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
@@ -4327,13 +4352,14 @@ int dlm_recover_master_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
                 goto out;
         }
 
-        error = find_rsb(ls, rl->rl_name, rl->rl_namelen, R_MASTER, &r);
+        error = find_rsb(ls, rl->rl_name, le16_to_cpu(rl->rl_namelen),
+                         R_MASTER, &r);
         if (error)
                 goto out;
 
         lock_rsb(r);
 
-        lkb = search_remid(r, rc->rc_header.h_nodeid, rl->rl_lkid);
+        lkb = search_remid(r, rc->rc_header.h_nodeid, le32_to_cpu(rl->rl_lkid));
         if (lkb) {
                 error = -EEXIST;
                 goto out_remid;
@@ -4356,18 +4382,20 @@ int dlm_recover_master_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
  out_remid:
         /* this is the new value returned to the lock holder for
            saving in its process-copy lkb */
-        rl->rl_remid = lkb->lkb_id;
+        rl->rl_remid = cpu_to_le32(lkb->lkb_id);
 
  out_unlock:
         unlock_rsb(r);
         put_rsb(r);
  out:
         if (error)
-                log_debug(ls, "recover_master_copy %d %x", error, rl->rl_lkid);
-        rl->rl_result = error;
+                log_debug(ls, "recover_master_copy %d %x", error,
+                          le32_to_cpu(rl->rl_lkid));
+        rl->rl_result = cpu_to_le32(error);
         return error;
 }
 
+/* needs at least dlm_rcom + rcom_lock */
 int dlm_recover_process_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
 {
         struct rcom_lock *rl = (struct rcom_lock *) rc->rc_buf;
@@ -4375,15 +4403,16 @@ int dlm_recover_process_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
         struct dlm_lkb *lkb;
         int error;
 
-        error = find_lkb(ls, rl->rl_lkid, &lkb);
+        error = find_lkb(ls, le32_to_cpu(rl->rl_lkid), &lkb);
         if (error) {
-                log_error(ls, "recover_process_copy no lkid %x", rl->rl_lkid);
+                log_error(ls, "recover_process_copy no lkid %x",
+                                le32_to_cpu(rl->rl_lkid));
                 return error;
         }
 
         DLM_ASSERT(is_process_copy(lkb), dlm_print_lkb(lkb););
 
-        error = rl->rl_result;
+        error = le32_to_cpu(rl->rl_result);
 
         r = lkb->lkb_resource;
         hold_rsb(r);
@@ -4402,7 +4431,7 @@ int dlm_recover_process_copy(struct dlm_ls *ls, struct dlm_rcom *rc)
                 log_debug(ls, "master copy exists %x", lkb->lkb_id);
                 /* fall through */
         case 0:
-                lkb->lkb_remid = rl->rl_remid;
+                lkb->lkb_remid = le32_to_cpu(rl->rl_remid);
                 break;
         default:
                 log_error(ls, "dlm_recover_process_copy unknown error %d %x",
@@ -4451,7 +4480,7 @@ int dlm_user_request(struct dlm_ls *ls, struct dlm_user_args *ua,
            lock and that lkb_astparam is the dlm_user_args structure. */
 
         error = set_lock_args(mode, &ua->lksb, flags, namelen, timeout_cs,
-                              DLM_FAKE_USER_AST, ua, DLM_FAKE_USER_AST, &args);
+                              fake_astfn, ua, fake_bastfn, &args);
         lkb->lkb_flags |= DLM_IFL_USER;
         ua->old_mode = DLM_LOCK_IV;
 
@@ -4504,7 +4533,7 @@ int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
         /* user can change the params on its lock when it converts it, or
            add an lvb that didn't exist before */
 
-        ua = (struct dlm_user_args *)lkb->lkb_astparam;
+        ua = lkb->lkb_ua;
 
         if (flags & DLM_LKF_VALBLK && !ua->lksb.sb_lvbptr) {
                 ua->lksb.sb_lvbptr = kzalloc(DLM_USER_LVB_LEN, GFP_KERNEL);
@@ -4525,7 +4554,7 @@ int dlm_user_convert(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
         ua->old_mode = lkb->lkb_grmode;
 
         error = set_lock_args(mode, &ua->lksb, flags, 0, timeout_cs,
-                              DLM_FAKE_USER_AST, ua, DLM_FAKE_USER_AST, &args);
+                              fake_astfn, ua, fake_bastfn, &args);
         if (error)
                 goto out_put;
 
@@ -4555,7 +4584,7 @@ int dlm_user_unlock(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
         if (error)
                 goto out;
 
-        ua = (struct dlm_user_args *)lkb->lkb_astparam;
+        ua = lkb->lkb_ua;
 
         if (lvb_in && ua->lksb.sb_lvbptr)
                 memcpy(ua->lksb.sb_lvbptr, lvb_in, DLM_USER_LVB_LEN);
@@ -4604,7 +4633,7 @@ int dlm_user_cancel(struct dlm_ls *ls, struct dlm_user_args *ua_tmp,
         if (error)
                 goto out;
 
-        ua = (struct dlm_user_args *)lkb->lkb_astparam;
+        ua = lkb->lkb_ua;
         if (ua_tmp->castparam)
                 ua->castparam = ua_tmp->castparam;
         ua->user_lksb = ua_tmp->user_lksb;
@@ -4642,7 +4671,7 @@ int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)
         if (error)
                 goto out;
 
-        ua = (struct dlm_user_args *)lkb->lkb_astparam;
+        ua = lkb->lkb_ua;
 
         error = set_unlock_args(flags, ua, &args);
         if (error)
@@ -4681,7 +4710,6 @@ int dlm_user_deadlock(struct dlm_ls *ls, uint32_t flags, uint32_t lkid)
 
 static int orphan_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
 {
-        struct dlm_user_args *ua = (struct dlm_user_args *)lkb->lkb_astparam;
         struct dlm_args args;
         int error;
 
@@ -4690,7 +4718,7 @@ static int orphan_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
         list_add_tail(&lkb->lkb_ownqueue, &ls->ls_orphans);
         mutex_unlock(&ls->ls_orphans_mutex);
 
-        set_unlock_args(0, ua, &args);
+        set_unlock_args(0, lkb->lkb_ua, &args);
 
         error = cancel_lock(ls, lkb, &args);
         if (error == -DLM_ECANCEL)
@@ -4703,11 +4731,10 @@ static int orphan_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
 
 static int unlock_proc_lock(struct dlm_ls *ls, struct dlm_lkb *lkb)
 {
-        struct dlm_user_args *ua = (struct dlm_user_args *)lkb->lkb_astparam;
         struct dlm_args args;
         int error;
 
-        set_unlock_args(DLM_LKF_FORCEUNLOCK, ua, &args);
+        set_unlock_args(DLM_LKF_FORCEUNLOCK, lkb->lkb_ua, &args);
 
         error = unlock_lock(ls, lkb, &args);
         if (error == -DLM_EUNLOCK)
diff --git a/fs/dlm/lock.h b/fs/dlm/lock.h
index 27b6ed302911..05d9c82e646b 100644
--- a/fs/dlm/lock.h
+++ b/fs/dlm/lock.h
@@ -17,7 +17,7 @@ void dlm_print_rsb(struct dlm_rsb *r);
 void dlm_dump_rsb(struct dlm_rsb *r);
 void dlm_print_lkb(struct dlm_lkb *lkb);
 void dlm_receive_message_saved(struct dlm_ls *ls, struct dlm_message *ms);
-void dlm_receive_buffer(struct dlm_header *hd, int nodeid);
+void dlm_receive_buffer(union dlm_packet *p, int nodeid);
 int dlm_modes_compat(int mode1, int mode2);
 void dlm_put_rsb(struct dlm_rsb *r);
 void dlm_hold_rsb(struct dlm_rsb *r);
diff --git a/fs/dlm/lockspace.c b/fs/dlm/lockspace.c
index b180fdc51085..b64e55e0515d 100644
--- a/fs/dlm/lockspace.c
+++ b/fs/dlm/lockspace.c
@@ -191,7 +191,7 @@ static int do_uevent(struct dlm_ls *ls, int in)
 }
 
 
-int dlm_lockspace_init(void)
+int __init dlm_lockspace_init(void)
 {
         ls_count = 0;
         mutex_init(&ls_lock);
diff --git a/fs/dlm/memory.c b/fs/dlm/memory.c
index f7783867491a..54c14c6d06cb 100644
--- a/fs/dlm/memory.c
+++ b/fs/dlm/memory.c
@@ -18,7 +18,7 @@
 static struct kmem_cache *lkb_cache;
 
 
-int dlm_memory_init(void)
+int __init dlm_memory_init(void)
 {
         int ret = 0;
 
@@ -80,7 +80,7 @@ void dlm_free_lkb(struct dlm_lkb *lkb)
 {
         if (lkb->lkb_flags & DLM_IFL_USER) {
                 struct dlm_user_args *ua;
-                ua = (struct dlm_user_args *)lkb->lkb_astparam;
+                ua = lkb->lkb_ua;
                 if (ua) {
                         if (ua->lksb.sb_lvbptr)
                                 kfree(ua->lksb.sb_lvbptr);
diff --git a/fs/dlm/midcomms.c b/fs/dlm/midcomms.c
index e69926e984db..07ac709f3ed7 100644
--- a/fs/dlm/midcomms.c
+++ b/fs/dlm/midcomms.c
@@ -61,9 +61,9 @@ int dlm_process_incoming_buffer(int nodeid, const void *base,
         union {
                 unsigned char __buf[DLM_INBUF_LEN];
                 /* this is to force proper alignment on some arches */
-                struct dlm_header dlm;
+                union dlm_packet p;
         } __tmp;
-        struct dlm_header *msg = &__tmp.dlm;
+        union dlm_packet *p = &__tmp.p;
         int ret = 0;
         int err = 0;
         uint16_t msglen;
@@ -75,15 +75,22 @@ int dlm_process_incoming_buffer(int nodeid, const void *base,
                    message may wrap around the end of the buffer back to the
                    start, so we need to use a temp buffer and copy_from_cb. */
 
-                copy_from_cb(msg, base, offset, sizeof(struct dlm_header),
+                copy_from_cb(p, base, offset, sizeof(struct dlm_header),
                              limit);
 
-                msglen = le16_to_cpu(msg->h_length);
-                lockspace = msg->h_lockspace;
+                msglen = le16_to_cpu(p->header.h_length);
+                lockspace = p->header.h_lockspace;
 
                 err = -EINVAL;
                 if (msglen < sizeof(struct dlm_header))
                         break;
+                if (p->header.h_cmd == DLM_MSG) {
+                        if (msglen < sizeof(struct dlm_message))
+                                break;
+                } else {
+                        if (msglen < sizeof(struct dlm_rcom))
+                                break;
+                }
                 err = -E2BIG;
                 if (msglen > dlm_config.ci_buffer_size) {
                         log_print("message size %d from %d too big, buf len %d",
@@ -104,26 +111,26 @@ int dlm_process_incoming_buffer(int nodeid, const void *base,
                    in the buffer on the stack (which should work for most
                    ordinary messages). */
 
-                if (msglen > DLM_INBUF_LEN && msg == &__tmp.dlm) {
-                        msg = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
-                        if (msg == NULL)
+                if (msglen > sizeof(__tmp) && p == &__tmp.p) {
+                        p = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
+                        if (p == NULL)
                                 return ret;
                 }
 
-                copy_from_cb(msg, base, offset, msglen, limit);
+                copy_from_cb(p, base, offset, msglen, limit);
 
-                BUG_ON(lockspace != msg->h_lockspace);
+                BUG_ON(lockspace != p->header.h_lockspace);
 
                 ret += msglen;
                 offset += msglen;
                 offset &= (limit - 1);
                 len -= msglen;
 
-                dlm_receive_buffer(msg, nodeid);
+                dlm_receive_buffer(p, nodeid);
         }
 
-        if (msg != &__tmp.dlm)
-                kfree(msg);
+        if (p != &__tmp.p)
+                kfree(p);
 
         return err ? err : ret;
 }
diff --git a/fs/dlm/netlink.c b/fs/dlm/netlink.c
index 863b87d0dc71..714593621f4f 100644
--- a/fs/dlm/netlink.c
+++ b/fs/dlm/netlink.c
@@ -78,7 +78,7 @@ static struct genl_ops dlm_nl_ops = {
         .doit           = user_cmd,
 };
 
-int dlm_netlink_init(void)
+int __init dlm_netlink_init(void)
 {
         int rv;
 
@@ -95,7 +95,7 @@ int dlm_netlink_init(void)
         return rv;
 }
 
-void dlm_netlink_exit(void)
+void __exit dlm_netlink_exit(void)
 {
         genl_unregister_ops(&family, &dlm_nl_ops);
         genl_unregister_family(&family);
@@ -104,7 +104,6 @@ void dlm_netlink_exit(void)
 static void fill_data(struct dlm_lock_data *data, struct dlm_lkb *lkb)
 {
         struct dlm_rsb *r = lkb->lkb_resource;
-        struct dlm_user_args *ua = (struct dlm_user_args *) lkb->lkb_astparam;
 
         memset(data, 0, sizeof(struct dlm_lock_data));
 
@@ -117,8 +116,8 @@ static void fill_data(struct dlm_lock_data *data, struct dlm_lkb *lkb)
         data->grmode = lkb->lkb_grmode;
         data->rqmode = lkb->lkb_rqmode;
         data->timestamp = lkb->lkb_timestamp;
-        if (ua)
-                data->xid = ua->xid;
+        if (lkb->lkb_ua)
+                data->xid = lkb->lkb_ua->xid;
         if (r) {
                 data->lockspace_id = r->res_ls->ls_global_id;
                 data->resource_namelen = r->res_length;
diff --git a/fs/dlm/rcom.c b/fs/dlm/rcom.c
index 026824cd3acb..035e6f9990b0 100644
--- a/fs/dlm/rcom.c
+++ b/fs/dlm/rcom.c
@@ -78,13 +78,14 @@ static void send_rcom(struct dlm_ls *ls, struct dlm_mhandle *mh,
 
 static void make_config(struct dlm_ls *ls, struct rcom_config *rf)
 {
-        rf->rf_lvblen = ls->ls_lvblen;
-        rf->rf_lsflags = ls->ls_exflags;
+        rf->rf_lvblen = cpu_to_le32(ls->ls_lvblen);
+        rf->rf_lsflags = cpu_to_le32(ls->ls_exflags);
 }
 
 static int check_config(struct dlm_ls *ls, struct dlm_rcom *rc, int nodeid)
 {
         struct rcom_config *rf = (struct rcom_config *) rc->rc_buf;
+        size_t conf_size = sizeof(struct dlm_rcom) + sizeof(struct rcom_config);
 
         if ((rc->rc_header.h_version & 0xFFFF0000) != DLM_HEADER_MAJOR) {
                 log_error(ls, "version mismatch: %x nodeid %d: %x",
@@ -93,11 +94,18 @@ static int check_config(struct dlm_ls *ls, struct dlm_rcom *rc, int nodeid)
                 return -EPROTO;
         }
 
-        if (rf->rf_lvblen != ls->ls_lvblen ||
-            rf->rf_lsflags != ls->ls_exflags) {
+        if (rc->rc_header.h_length < conf_size) {
+                log_error(ls, "config too short: %d nodeid %d",
+                          rc->rc_header.h_length, nodeid);
+                return -EPROTO;
+        }
+
+        if (le32_to_cpu(rf->rf_lvblen) != ls->ls_lvblen ||
+            le32_to_cpu(rf->rf_lsflags) != ls->ls_exflags) {
                 log_error(ls, "config mismatch: %d,%x nodeid %d: %d,%x",
-                          ls->ls_lvblen, ls->ls_exflags,
-                          nodeid, rf->rf_lvblen, rf->rf_lsflags);
+                          ls->ls_lvblen, ls->ls_exflags, nodeid,
+                          le32_to_cpu(rf->rf_lvblen),
+                          le32_to_cpu(rf->rf_lsflags));
                 return -EPROTO;
         }
         return 0;
@@ -128,7 +136,7 @@ int dlm_rcom_status(struct dlm_ls *ls, int nodeid)
         ls->ls_recover_nodeid = nodeid;
 
         if (nodeid == dlm_our_nodeid()) {
-                rc = (struct dlm_rcom *) ls->ls_recover_buf;
+                rc = ls->ls_recover_buf;
                 rc->rc_result = dlm_recover_status(ls);
                 goto out;
         }
@@ -147,7 +155,7 @@ int dlm_rcom_status(struct dlm_ls *ls, int nodeid)
         if (error)
                 goto out;
 
-        rc = (struct dlm_rcom *) ls->ls_recover_buf;
+        rc = ls->ls_recover_buf;
 
         if (rc->rc_result == -ESRCH) {
                 /* we pretend the remote lockspace exists with 0 status */
@@ -201,14 +209,15 @@ int dlm_rcom_names(struct dlm_ls *ls, int nodeid, char *last_name, int last_len)
 {
         struct dlm_rcom *rc;
         struct dlm_mhandle *mh;
-        int error = 0, len = sizeof(struct dlm_rcom);
+        int error = 0;
+        int max_size = dlm_config.ci_buffer_size - sizeof(struct dlm_rcom);
 
         ls->ls_recover_nodeid = nodeid;
 
         if (nodeid == dlm_our_nodeid()) {
                 dlm_copy_master_names(ls, last_name, last_len,
-                                      ls->ls_recover_buf + len,
-                                      dlm_config.ci_buffer_size - len, nodeid);
+                                      ls->ls_recover_buf->rc_buf,
+                                      max_size, nodeid);
                 goto out;
         }
 
@@ -299,22 +308,22 @@ static void pack_rcom_lock(struct dlm_rsb *r, struct dlm_lkb *lkb,
 {
         memset(rl, 0, sizeof(*rl));
 
-        rl->rl_ownpid = lkb->lkb_ownpid;
-        rl->rl_lkid = lkb->lkb_id;
-        rl->rl_exflags = lkb->lkb_exflags;
-        rl->rl_flags = lkb->lkb_flags;
-        rl->rl_lvbseq = lkb->lkb_lvbseq;
+        rl->rl_ownpid = cpu_to_le32(lkb->lkb_ownpid);
+        rl->rl_lkid = cpu_to_le32(lkb->lkb_id);
+        rl->rl_exflags = cpu_to_le32(lkb->lkb_exflags);
+        rl->rl_flags = cpu_to_le32(lkb->lkb_flags);
+        rl->rl_lvbseq = cpu_to_le32(lkb->lkb_lvbseq);
         rl->rl_rqmode = lkb->lkb_rqmode;
         rl->rl_grmode = lkb->lkb_grmode;
         rl->rl_status = lkb->lkb_status;
-        rl->rl_wait_type = lkb->lkb_wait_type;
+        rl->rl_wait_type = cpu_to_le16(lkb->lkb_wait_type);
 
-        if (lkb->lkb_bastaddr)
+        if (lkb->lkb_bastfn)
                 rl->rl_asts |= AST_BAST;
-        if (lkb->lkb_astaddr)
+        if (lkb->lkb_astfn)
                 rl->rl_asts |= AST_COMP;
 
-        rl->rl_namelen = r->res_length;
+        rl->rl_namelen = cpu_to_le16(r->res_length);
         memcpy(rl->rl_name, r->res_name, r->res_length);
 
         /* FIXME: might we have an lvb without DLM_LKF_VALBLK set ?
@@ -348,6 +357,7 @@ int dlm_send_rcom_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
         return error;
 }
 
+/* needs at least dlm_rcom + rcom_lock */
 static void receive_rcom_lock(struct dlm_ls *ls, struct dlm_rcom *rc_in)
 {
         struct dlm_rcom *rc;
@@ -401,7 +411,7 @@ int dlm_send_ls_not_ready(int nodeid, struct dlm_rcom *rc_in)
         rc->rc_result = -ESRCH;
 
         rf = (struct rcom_config *) rc->rc_buf;
-        rf->rf_lvblen = -1;
+        rf->rf_lvblen = cpu_to_le32(~0U);
 
         dlm_rcom_out(rc);
         dlm_lowcomms_commit_buffer(mh);
@@ -439,6 +449,8 @@ static int is_old_reply(struct dlm_ls *ls, struct dlm_rcom *rc)
 
 void dlm_receive_rcom(struct dlm_ls *ls, struct dlm_rcom *rc, int nodeid)
 {
+        int lock_size = sizeof(struct dlm_rcom) + sizeof(struct rcom_lock);
+
         if (dlm_recovery_stopped(ls) && (rc->rc_type != DLM_RCOM_STATUS)) {
                 log_debug(ls, "ignoring recovery message %x from %d",
                           rc->rc_type, nodeid);
@@ -462,6 +474,8 @@ void dlm_receive_rcom(struct dlm_ls *ls, struct dlm_rcom *rc, int nodeid)
                 break;
 
         case DLM_RCOM_LOCK:
+                if (rc->rc_header.h_length < lock_size)
+                        goto Eshort;
                 receive_rcom_lock(ls, rc);
                 break;
 
@@ -478,13 +492,18 @@ void dlm_receive_rcom(struct dlm_ls *ls, struct dlm_rcom *rc, int nodeid)
                 break;
 
         case DLM_RCOM_LOCK_REPLY:
+                if (rc->rc_header.h_length < lock_size)
+                        goto Eshort;
                 dlm_recover_process_copy(ls, rc);
                 break;
 
         default:
                 log_error(ls, "receive_rcom bad type %d", rc->rc_type);
         }
- out:
+out:
         return;
+Eshort:
+        log_error(ls, "recovery message %x from %d is too short",
+                          rc->rc_type, nodeid);
 }
 
diff --git a/fs/dlm/recover.c b/fs/dlm/recover.c
index df075dc300fa..80aba5bdd4a4 100644
--- a/fs/dlm/recover.c
+++ b/fs/dlm/recover.c
@@ -94,7 +94,7 @@ void dlm_set_recover_status(struct dlm_ls *ls, uint32_t status)
 
 static int wait_status_all(struct dlm_ls *ls, uint32_t wait_status)
 {
-        struct dlm_rcom *rc = (struct dlm_rcom *) ls->ls_recover_buf;
+        struct dlm_rcom *rc = ls->ls_recover_buf;
         struct dlm_member *memb;
         int error = 0, delay;
 
@@ -123,7 +123,7 @@ static int wait_status_all(struct dlm_ls *ls, uint32_t wait_status)
 
 static int wait_status_low(struct dlm_ls *ls, uint32_t wait_status)
 {
-        struct dlm_rcom *rc = (struct dlm_rcom *) ls->ls_recover_buf;
+        struct dlm_rcom *rc = ls->ls_recover_buf;
         int error = 0, delay = 0, nodeid = ls->ls_low_nodeid;
 
         for (;;) {
diff --git a/fs/dlm/requestqueue.c b/fs/dlm/requestqueue.c
index 0de04f17ccea..daa4183fbb84 100644
--- a/fs/dlm/requestqueue.c
+++ b/fs/dlm/requestqueue.c
@@ -20,7 +20,7 @@
 struct rq_entry {
         struct list_head list;
         int nodeid;
-        char request[0];
+        struct dlm_message request;
 };
 
 /*
@@ -30,10 +30,10 @@ struct rq_entry {
  * lockspace is enabled on some while still suspended on others.
  */
 
-void dlm_add_requestqueue(struct dlm_ls *ls, int nodeid, struct dlm_header *hd)
+void dlm_add_requestqueue(struct dlm_ls *ls, int nodeid, struct dlm_message *ms)
 {
         struct rq_entry *e;
-        int length = hd->h_length;
+        int length = ms->m_header.h_length - sizeof(struct dlm_message);
 
         e = kmalloc(sizeof(struct rq_entry) + length, GFP_KERNEL);
         if (!e) {
@@ -42,7 +42,7 @@ void dlm_add_requestqueue(struct dlm_ls *ls, int nodeid, struct dlm_header *hd)
         }
 
         e->nodeid = nodeid;
-        memcpy(e->request, hd, length);
+        memcpy(&e->request, ms, ms->m_header.h_length);
 
         mutex_lock(&ls->ls_requestqueue_mutex);
         list_add_tail(&e->list, &ls->ls_requestqueue);
@@ -76,7 +76,7 @@ int dlm_process_requestqueue(struct dlm_ls *ls)
                 e = list_entry(ls->ls_requestqueue.next, struct rq_entry, list);
                 mutex_unlock(&ls->ls_requestqueue_mutex);
 
-                dlm_receive_message_saved(ls, (struct dlm_message *)e->request);
+                dlm_receive_message_saved(ls, &e->request);
 
                 mutex_lock(&ls->ls_requestqueue_mutex);
                 list_del(&e->list);
@@ -176,7 +176,7 @@ void dlm_purge_requestqueue(struct dlm_ls *ls)
 
         mutex_lock(&ls->ls_requestqueue_mutex);
         list_for_each_entry_safe(e, safe, &ls->ls_requestqueue, list) {
-                ms = (struct dlm_message *) e->request;
+                ms =  &e->request;
 
                 if (purge_request(ls, ms, e->nodeid)) {
                         list_del(&e->list);
diff --git a/fs/dlm/requestqueue.h b/fs/dlm/requestqueue.h
index aba34fc05ee4..10ce449b77da 100644
--- a/fs/dlm/requestqueue.h
+++ b/fs/dlm/requestqueue.h
@@ -13,7 +13,7 @@
 #ifndef __REQUESTQUEUE_DOT_H__
 #define __REQUESTQUEUE_DOT_H__
 
-void dlm_add_requestqueue(struct dlm_ls *ls, int nodeid, struct dlm_header *hd);
+void dlm_add_requestqueue(struct dlm_ls *ls, int nodeid, struct dlm_message *ms);
 int dlm_process_requestqueue(struct dlm_ls *ls);
 void dlm_wait_requestqueue(struct dlm_ls *ls);
 void dlm_purge_requestqueue(struct dlm_ls *ls);
diff --git a/fs/dlm/user.c b/fs/dlm/user.c
index 7cbc6826239b..ebbcf38fd33b 100644
--- a/fs/dlm/user.c
+++ b/fs/dlm/user.c
@@ -82,7 +82,7 @@ struct dlm_lock_result32 {
 
 static void compat_input(struct dlm_write_request *kb,
                          struct dlm_write_request32 *kb32,
-                         int max_namelen)
+                         size_t count)
 {
         kb->version[0] = kb32->version[0];
         kb->version[1] = kb32->version[1];
@@ -94,7 +94,8 @@ static void compat_input(struct dlm_write_request *kb,
             kb->cmd == DLM_USER_REMOVE_LOCKSPACE) {
                 kb->i.lspace.flags = kb32->i.lspace.flags;
                 kb->i.lspace.minor = kb32->i.lspace.minor;
-                strcpy(kb->i.lspace.name, kb32->i.lspace.name);
+                memcpy(kb->i.lspace.name, kb32->i.lspace.name, count -
+                        offsetof(struct dlm_write_request32, i.lspace.name));
         } else if (kb->cmd == DLM_USER_PURGE) {
                 kb->i.purge.nodeid = kb32->i.purge.nodeid;
                 kb->i.purge.pid = kb32->i.purge.pid;
@@ -112,11 +113,8 @@ static void compat_input(struct dlm_write_request *kb,
                 kb->i.lock.bastaddr = (void *)(long)kb32->i.lock.bastaddr;
                 kb->i.lock.lksb = (void *)(long)kb32->i.lock.lksb;
                 memcpy(kb->i.lock.lvb, kb32->i.lock.lvb, DLM_USER_LVB_LEN);
-                if (kb->i.lock.namelen <= max_namelen)
-                        memcpy(kb->i.lock.name, kb32->i.lock.name,
-                               kb->i.lock.namelen);
-                else
-                        kb->i.lock.namelen = max_namelen;
+                memcpy(kb->i.lock.name, kb32->i.lock.name, count -
+                        offsetof(struct dlm_write_request32, i.lock.name));
         }
 }
 
@@ -197,8 +195,8 @@ void dlm_user_add_ast(struct dlm_lkb *lkb, int type)
         if (lkb->lkb_flags & (DLM_IFL_ORPHAN | DLM_IFL_DEAD))
                 goto out;
 
-        DLM_ASSERT(lkb->lkb_astparam, dlm_print_lkb(lkb););
-        ua = (struct dlm_user_args *)lkb->lkb_astparam;
+        DLM_ASSERT(lkb->lkb_ua, dlm_print_lkb(lkb););
+        ua = lkb->lkb_ua;
         proc = ua->proc;
 
         if (type == AST_BAST && ua->bastaddr == NULL)
@@ -508,7 +506,7 @@ static ssize_t device_write(struct file *file, const char __user *buf,
 #endif
                 return -EINVAL;
 
-        kbuf = kmalloc(count, GFP_KERNEL);
+        kbuf = kzalloc(count + 1, GFP_KERNEL);
         if (!kbuf)
                 return -ENOMEM;
 
@@ -526,15 +524,14 @@ static ssize_t device_write(struct file *file, const char __user *buf,
         if (!kbuf->is64bit) {
                 struct dlm_write_request32 *k32buf;
                 k32buf = (struct dlm_write_request32 *)kbuf;
-                kbuf = kmalloc(count + (sizeof(struct dlm_write_request) -
+                kbuf = kmalloc(count + 1 + (sizeof(struct dlm_write_request) -
                                sizeof(struct dlm_write_request32)), GFP_KERNEL);
                 if (!kbuf)
                         return -ENOMEM;
 
                 if (proc)
                         set_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags);
-                compat_input(kbuf, k32buf,
-                             count - sizeof(struct dlm_write_request32));
+                compat_input(kbuf, k32buf, count + 1);
                 kfree(k32buf);
         }
 #endif
@@ -774,7 +771,6 @@ static ssize_t device_read(struct file *file, char __user *buf, size_t count,
 {
         struct dlm_user_proc *proc = file->private_data;
         struct dlm_lkb *lkb;
-        struct dlm_user_args *ua;
         DECLARE_WAITQUEUE(wait, current);
         int error, type=0, bmode=0, removed = 0;
 
@@ -845,8 +841,7 @@ static ssize_t device_read(struct file *file, char __user *buf, size_t count,
         }
         spin_unlock(&proc->asts_spin);
 
-        ua = (struct dlm_user_args *)lkb->lkb_astparam;
-        error = copy_result_to_user(ua,
+        error = copy_result_to_user(lkb->lkb_ua,
                                 test_bit(DLM_PROC_FLAGS_COMPAT, &proc->flags),
                                 type, bmode, buf, count);
 
@@ -907,7 +902,7 @@ static struct miscdevice ctl_device = {
         .minor = MISC_DYNAMIC_MINOR,
 };
 
-int dlm_user_init(void)
+int __init dlm_user_init(void)
 {
         int error;
 
diff --git a/fs/dlm/util.c b/fs/dlm/util.c
index 4d9c1f4e1bd1..e36520af7cc0 100644
--- a/fs/dlm/util.c
+++ b/fs/dlm/util.c
@@ -131,52 +131,8 @@ void dlm_message_in(struct dlm_message *ms)
         ms->m_result            = from_dlm_errno(le32_to_cpu(ms->m_result));
 }
 
-static void rcom_lock_out(struct rcom_lock *rl)
-{
-        rl->rl_ownpid           = cpu_to_le32(rl->rl_ownpid);
-        rl->rl_lkid             = cpu_to_le32(rl->rl_lkid);
-        rl->rl_remid            = cpu_to_le32(rl->rl_remid);
-        rl->rl_parent_lkid      = cpu_to_le32(rl->rl_parent_lkid);
-        rl->rl_parent_remid     = cpu_to_le32(rl->rl_parent_remid);
-        rl->rl_exflags          = cpu_to_le32(rl->rl_exflags);
-        rl->rl_flags            = cpu_to_le32(rl->rl_flags);
-        rl->rl_lvbseq           = cpu_to_le32(rl->rl_lvbseq);
-        rl->rl_result           = cpu_to_le32(rl->rl_result);
-        rl->rl_wait_type        = cpu_to_le16(rl->rl_wait_type);
-        rl->rl_namelen          = cpu_to_le16(rl->rl_namelen);
-}
-
-static void rcom_lock_in(struct rcom_lock *rl)
-{
-        rl->rl_ownpid           = le32_to_cpu(rl->rl_ownpid);
-        rl->rl_lkid             = le32_to_cpu(rl->rl_lkid);
-        rl->rl_remid            = le32_to_cpu(rl->rl_remid);
-        rl->rl_parent_lkid      = le32_to_cpu(rl->rl_parent_lkid);
-        rl->rl_parent_remid     = le32_to_cpu(rl->rl_parent_remid);
-        rl->rl_exflags          = le32_to_cpu(rl->rl_exflags);
-        rl->rl_flags            = le32_to_cpu(rl->rl_flags);
-        rl->rl_lvbseq           = le32_to_cpu(rl->rl_lvbseq);
-        rl->rl_result           = le32_to_cpu(rl->rl_result);
-        rl->rl_wait_type        = le16_to_cpu(rl->rl_wait_type);
-        rl->rl_namelen          = le16_to_cpu(rl->rl_namelen);
-}
-
-static void rcom_config_out(struct rcom_config *rf)
-{
-        rf->rf_lvblen           = cpu_to_le32(rf->rf_lvblen);
-        rf->rf_lsflags          = cpu_to_le32(rf->rf_lsflags);
-}
-
-static void rcom_config_in(struct rcom_config *rf)
-{
-        rf->rf_lvblen           = le32_to_cpu(rf->rf_lvblen);
-        rf->rf_lsflags          = le32_to_cpu(rf->rf_lsflags);
-}
-
 void dlm_rcom_out(struct dlm_rcom *rc)
 {
-        int type = rc->rc_type;
-
         header_out(&rc->rc_header);
 
         rc->rc_type             = cpu_to_le32(rc->rc_type);
@@ -184,18 +140,10 @@ void dlm_rcom_out(struct dlm_rcom *rc)
         rc->rc_id               = cpu_to_le64(rc->rc_id);
         rc->rc_seq              = cpu_to_le64(rc->rc_seq);
         rc->rc_seq_reply        = cpu_to_le64(rc->rc_seq_reply);
-
-        if ((type == DLM_RCOM_LOCK) || (type == DLM_RCOM_LOCK_REPLY))
-                rcom_lock_out((struct rcom_lock *) rc->rc_buf);
-
-        else if (type == DLM_RCOM_STATUS_REPLY)
-                rcom_config_out((struct rcom_config *) rc->rc_buf);
 }
 
 void dlm_rcom_in(struct dlm_rcom *rc)
 {
-        int type;
-
         header_in(&rc->rc_header);
 
         rc->rc_type             = le32_to_cpu(rc->rc_type);
@@ -203,13 +151,4 @@ void dlm_rcom_in(struct dlm_rcom *rc)
         rc->rc_id               = le64_to_cpu(rc->rc_id);
         rc->rc_seq              = le64_to_cpu(rc->rc_seq);
         rc->rc_seq_reply        = le64_to_cpu(rc->rc_seq_reply);
-
-        type = rc->rc_type;
-
-        if ((type == DLM_RCOM_LOCK) || (type == DLM_RCOM_LOCK_REPLY))
-                rcom_lock_in((struct rcom_lock *) rc->rc_buf);
-
-        else if (type == DLM_RCOM_STATUS_REPLY)
-                rcom_config_in((struct rcom_config *) rc->rc_buf);
 }
-
diff --git a/fs/exec.c b/fs/exec.c
index be923e4bc389..9ff6069094d8 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -119,7 +119,7 @@ asmlinkage long sys_uselib(const char __user * library)
         if (error)
                 goto exit;
 
-        file = nameidata_to_filp(&nd, O_RDONLY);
+        file = nameidata_to_filp(&nd, O_RDONLY|O_LARGEFILE);
         error = PTR_ERR(file);
         if (IS_ERR(file))
                 goto out;
@@ -658,7 +658,8 @@ struct file *open_exec(const char *name)
                         int err = vfs_permission(&nd, MAY_EXEC);
                         file = ERR_PTR(err);
                         if (!err) {
-                                file = nameidata_to_filp(&nd, O_RDONLY);
+                                file = nameidata_to_filp(&nd,
+                                                        O_RDONLY|O_LARGEFILE);
                                 if (!IS_ERR(file)) {
                                         err = deny_write_access(file);
                                         if (err) {
@@ -782,26 +783,8 @@ static int de_thread(struct task_struct *tsk)
         zap_other_threads(tsk);
         read_unlock(&tasklist_lock);
 
-        /*
-         * Account for the thread group leader hanging around:
-         */
-        count = 1;
-        if (!thread_group_leader(tsk)) {
-                count = 2;
-                /*
-                 * The SIGALRM timer survives the exec, but needs to point
-                 * at us as the new group leader now.  We have a race with
-                 * a timer firing now getting the old leader, so we need to
-                 * synchronize with any firing (by calling del_timer_sync)
-                 * before we can safely let the old group leader die.
-                 */
-                sig->tsk = tsk;
-                spin_unlock_irq(lock);
-                if (hrtimer_cancel(&sig->real_timer))
-                        hrtimer_restart(&sig->real_timer);
-                spin_lock_irq(lock);
-        }
-
+        /* Account for the thread group leader hanging around: */
+        count = thread_group_leader(tsk) ? 1 : 2;
         sig->notify_count = count;
         while (atomic_read(&sig->count) > count) {
                 __set_current_state(TASK_UNINTERRUPTIBLE);
@@ -1184,7 +1167,7 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 {
         int try,retval;
         struct linux_binfmt *fmt;
-#ifdef __alpha__
+#if defined(__alpha__) && defined(CONFIG_ARCH_SUPPORTS_AOUT)
         /* handle /sbin/loader.. */
         {
             struct exec * eh = (struct exec *) bprm->buf;
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index f1e5705e75f1..47d88da2d33b 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -126,7 +126,6 @@ extern unsigned long ext2_count_free (struct buffer_head *, unsigned);
 /* inode.c */
 extern struct inode *ext2_iget (struct super_block *, unsigned long);
 extern int ext2_write_inode (struct inode *, int);
-extern void ext2_put_inode (struct inode *);
 extern void ext2_delete_inode (struct inode *);
 extern int ext2_sync_inode (struct inode *);
 extern int ext2_get_block(struct inode *, sector_t, struct buffer_head *, int);
diff --git a/fs/ext2/super.c b/fs/ext2/super.c
index 22f1010bf79f..088b011bb97e 100644
--- a/fs/ext2/super.c
+++ b/fs/ext2/super.c
@@ -285,6 +285,9 @@ static int ext2_show_options(struct seq_file *seq, struct vfsmount *vfs)
                 seq_puts(seq, ",xip");
 #endif
 
+        if (!test_opt(sb, RESERVATION))
+                seq_puts(seq, ",noreservation");
+
         return 0;
 }
 
diff --git a/fs/ext3/balloc.c b/fs/ext3/balloc.c
index a75713031105..da0cb2c0e437 100644
--- a/fs/ext3/balloc.c
+++ b/fs/ext3/balloc.c
@@ -630,9 +630,7 @@ do_more:
         jbd_unlock_bh_state(bitmap_bh);
 
         spin_lock(sb_bgl_lock(sbi, block_group));
-        desc->bg_free_blocks_count =
-                cpu_to_le16(le16_to_cpu(desc->bg_free_blocks_count) +
-                        group_freed);
+        le16_add_cpu(&desc->bg_free_blocks_count, group_freed);
         spin_unlock(sb_bgl_lock(sbi, block_group));
         percpu_counter_add(&sbi->s_freeblocks_counter, count);
 
@@ -1696,8 +1694,7 @@ allocated:
                         ret_block, goal_hits, goal_attempts);
 
         spin_lock(sb_bgl_lock(sbi, group_no));
-        gdp->bg_free_blocks_count =
-                        cpu_to_le16(le16_to_cpu(gdp->bg_free_blocks_count)-num);
+        le16_add_cpu(&gdp->bg_free_blocks_count, -num);
         spin_unlock(sb_bgl_lock(sbi, group_no));
         percpu_counter_sub(&sbi->s_freeblocks_counter, num);
 
diff --git a/fs/ext3/ialloc.c b/fs/ext3/ialloc.c
index 58ae2f943f12..4f4020c54683 100644
--- a/fs/ext3/ialloc.c
+++ b/fs/ext3/ialloc.c
@@ -164,11 +164,9 @@ void ext3_free_inode (handle_t *handle, struct inode * inode)
 
                 if (gdp) {
                         spin_lock(sb_bgl_lock(sbi, block_group));
-                        gdp->bg_free_inodes_count = cpu_to_le16(
-                                le16_to_cpu(gdp->bg_free_inodes_count) + 1);
+                        le16_add_cpu(&gdp->bg_free_inodes_count, 1);
                         if (is_directory)
-                                gdp->bg_used_dirs_count = cpu_to_le16(
-                                  le16_to_cpu(gdp->bg_used_dirs_count) - 1);
+                                le16_add_cpu(&gdp->bg_used_dirs_count, -1);
                         spin_unlock(sb_bgl_lock(sbi, block_group));
                         percpu_counter_inc(&sbi->s_freeinodes_counter);
                         if (is_directory)
@@ -527,11 +525,9 @@ got:
         err = ext3_journal_get_write_access(handle, bh2);
         if (err) goto fail;
         spin_lock(sb_bgl_lock(sbi, group));
-        gdp->bg_free_inodes_count =
-                cpu_to_le16(le16_to_cpu(gdp->bg_free_inodes_count) - 1);
+        le16_add_cpu(&gdp->bg_free_inodes_count, -1);
         if (S_ISDIR(mode)) {
-                gdp->bg_used_dirs_count =
-                        cpu_to_le16(le16_to_cpu(gdp->bg_used_dirs_count) + 1);
+                le16_add_cpu(&gdp->bg_used_dirs_count, 1);
         }
         spin_unlock(sb_bgl_lock(sbi, group));
         BUFFER_TRACE(bh2, "call ext3_journal_dirty_metadata");
diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index ebc05af7343a..9397d779c43d 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -518,8 +518,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
         EXT3_SB(sb)->s_gdb_count++;
         kfree(o_group_desc);
 
-        es->s_reserved_gdt_blocks =
-                cpu_to_le16(le16_to_cpu(es->s_reserved_gdt_blocks) - 1);
+        le16_add_cpu(&es->s_reserved_gdt_blocks, -1);
         ext3_journal_dirty_metadata(handle, EXT3_SB(sb)->s_sbh);
 
         return 0;
@@ -890,10 +889,8 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
          * blocks/inodes before the group is live won't actually let us
          * allocate the new space yet.
          */
-        es->s_blocks_count = cpu_to_le32(le32_to_cpu(es->s_blocks_count) +
-                input->blocks_count);
-        es->s_inodes_count = cpu_to_le32(le32_to_cpu(es->s_inodes_count) +
-                EXT3_INODES_PER_GROUP(sb));
+        le32_add_cpu(&es->s_blocks_count, input->blocks_count);
+        le32_add_cpu(&es->s_inodes_count, EXT3_INODES_PER_GROUP(sb));
 
         /*
          * We need to protect s_groups_count against other CPUs seeing
@@ -926,8 +923,7 @@ int ext3_group_add(struct super_block *sb, struct ext3_new_group_data *input)
 
         /* Update the reserved block counts only once the new group is
          * active. */
-        es->s_r_blocks_count = cpu_to_le32(le32_to_cpu(es->s_r_blocks_count) +
-                input->reserved_blocks);
+        le32_add_cpu(&es->s_r_blocks_count, input->reserved_blocks);
 
         /* Update the free space counts */
         percpu_counter_add(&sbi->s_freeblocks_counter,
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index cf2a2c3660ec..8e02cbfb1123 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -1222,7 +1222,7 @@ static int ext3_setup_super(struct super_block *sb, struct ext3_super_block *es,
 #endif
         if (!(__s16) le16_to_cpu(es->s_max_mnt_count))
                 es->s_max_mnt_count = cpu_to_le16(EXT3_DFL_MAX_MNT_COUNT);
-        es->s_mnt_count=cpu_to_le16(le16_to_cpu(es->s_mnt_count) + 1);
+        le16_add_cpu(&es->s_mnt_count, 1);
         es->s_mtime = cpu_to_le32(get_seconds());
         ext3_update_dynamic_rev(sb);
         EXT3_SET_INCOMPAT_FEATURE(sb, EXT3_FEATURE_INCOMPAT_RECOVER);
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index 408373819e34..fb89c299bece 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -492,8 +492,7 @@ ext3_xattr_release_block(handle_t *handle, struct inode *inode,
                 get_bh(bh);
                 ext3_forget(handle, 1, inode, bh, bh->b_blocknr);
         } else {
-                BHDR(bh)->h_refcount = cpu_to_le32(
-                                le32_to_cpu(BHDR(bh)->h_refcount) - 1);
+                le32_add_cpu(&BHDR(bh)->h_refcount, -1);
                 error = ext3_journal_dirty_metadata(handle, bh);
                 if (IS_SYNC(inode))
                         handle->h_sync = 1;
@@ -780,8 +779,7 @@ inserted:
                                 if (error)
                                         goto cleanup_dquot;
                                 lock_buffer(new_bh);
-                                BHDR(new_bh)->h_refcount = cpu_to_le32(1 +
-                                        le32_to_cpu(BHDR(new_bh)->h_refcount));
+                                le32_add_cpu(&BHDR(new_bh)->h_refcount, 1);
                                 ea_bdebug(new_bh, "reusing; refcount now=%d",
                                         le32_to_cpu(BHDR(new_bh)->h_refcount));
                                 unlock_buffer(new_bh);
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 085269e07fb3..53f3cf62b7c1 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -837,6 +837,8 @@ static int fat_show_options(struct seq_file *m, struct vfsmount *mnt)
                 if (!opts->numtail)
                         seq_puts(m, ",nonumtail");
         }
+        if (sbi->options.flush)
+                seq_puts(m, ",flush");
 
         return 0;
 }
diff --git a/fs/fcntl.c b/fs/fcntl.c
index 8685263ccc4a..e632da761fc1 100644
--- a/fs/fcntl.c
+++ b/fs/fcntl.c
@@ -24,7 +24,7 @@
 #include <asm/siginfo.h>
 #include <asm/uaccess.h>
 
-void fastcall set_close_on_exec(unsigned int fd, int flag)
+void set_close_on_exec(unsigned int fd, int flag)
 {
         struct files_struct *files = current->files;
         struct fdtable *fdt;
@@ -309,7 +309,7 @@ pid_t f_getown(struct file *filp)
 {
         pid_t pid;
         read_lock(&filp->f_owner.lock);
-        pid = pid_nr_ns(filp->f_owner.pid, current->nsproxy->pid_ns);
+        pid = pid_vnr(filp->f_owner.pid);
         if (filp->f_owner.pid_type == PIDTYPE_PGID)
                 pid = -pid;
         read_unlock(&filp->f_owner.lock);
diff --git a/fs/file_table.c b/fs/file_table.c
index 664e3f2309b8..6d27befe2d48 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -197,7 +197,7 @@ int init_file(struct file *file, struct vfsmount *mnt, struct dentry *dentry,
 }
 EXPORT_SYMBOL(init_file);
 
-void fastcall fput(struct file *file)
+void fput(struct file *file)
 {
         if (atomic_dec_and_test(&file->f_count))
                 __fput(file);
@@ -208,7 +208,7 @@ EXPORT_SYMBOL(fput);
 /* __fput is called from task context when aio completion releases the last
  * last use of a struct file *.  Do not use otherwise.
  */
-void fastcall __fput(struct file *file)
+void __fput(struct file *file)
 {
         struct dentry *dentry = file->f_path.dentry;
         struct vfsmount *mnt = file->f_path.mnt;
@@ -241,7 +241,7 @@ void fastcall __fput(struct file *file)
         mntput(mnt);
 }
 
-struct file fastcall *fget(unsigned int fd)
+struct file *fget(unsigned int fd)
 {
         struct file *file;
         struct files_struct *files = current->files;
@@ -269,7 +269,7 @@ EXPORT_SYMBOL(fget);
  * and a flag is returned to be passed to the corresponding fput_light().
  * There must not be a cloning between an fget_light/fput_light pair.
  */
-struct file fastcall *fget_light(unsigned int fd, int *fput_needed)
+struct file *fget_light(unsigned int fd, int *fput_needed)
 {
         struct file *file;
         struct files_struct *files = current->files;
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index db80ce9eb1d0..c0076077d338 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -655,7 +655,7 @@ int write_inode_now(struct inode *inode, int sync)
         int ret;
         struct writeback_control wbc = {
                 .nr_to_write = LONG_MAX,
-                .sync_mode = WB_SYNC_ALL,
+                .sync_mode = sync ? WB_SYNC_ALL : WB_SYNC_NONE,
                 .range_start = 0,
                 .range_end = LLONG_MAX,
         };
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 574707409bbf..033f7bdd47e8 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -29,6 +29,8 @@ DEFINE_MUTEX(fuse_mutex);
 
 #define FUSE_SUPER_MAGIC 0x65735546
 
+#define FUSE_DEFAULT_BLKSIZE 512
+
 struct fuse_mount_data {
         int fd;
         unsigned rootmode;
@@ -355,7 +357,7 @@ static int parse_fuse_opt(char *opt, struct fuse_mount_data *d, int is_bdev)
         char *p;
         memset(d, 0, sizeof(struct fuse_mount_data));
         d->max_read = ~0;
-        d->blksize = 512;
+        d->blksize = FUSE_DEFAULT_BLKSIZE;
 
         while ((p = strsep(&opt, ",")) != NULL) {
                 int token;
@@ -440,6 +442,9 @@ static int fuse_show_options(struct seq_file *m, struct vfsmount *mnt)
                 seq_puts(m, ",allow_other");
         if (fc->max_read != ~0)
                 seq_printf(m, ",max_read=%u", fc->max_read);
+        if (mnt->mnt_sb->s_bdev &&
+            mnt->mnt_sb->s_blocksize != FUSE_DEFAULT_BLKSIZE)
+                seq_printf(m, ",blksize=%lu", mnt->mnt_sb->s_blocksize);
         return 0;
 }
 
diff --git a/fs/hfsplus/unicode.c b/fs/hfsplus/unicode.c
index 9e10f9444b64..628ccf6fa402 100644
--- a/fs/hfsplus/unicode.c
+++ b/fs/hfsplus/unicode.c
@@ -325,7 +325,7 @@ int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
         struct super_block *sb = dentry->d_sb;
         const char *astr;
         const u16 *dstr;
-        int casefold, decompose, size, dsize, len;
+        int casefold, decompose, size, len;
         unsigned long hash;
         wchar_t c;
         u16 c2;
@@ -336,6 +336,7 @@ int hfsplus_hash_dentry(struct dentry *dentry, struct qstr *str)
         astr = str->name;
         len = str->len;
         while (len > 0) {
+                int uninitialized_var(dsize);
                 size = asc2unichar(sb, astr, len, &c);
                 astr += size;
                 len -= size;
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index 2b9b35733aac..d0549cb4fb23 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -11,6 +11,7 @@
 #include <linux/mm.h>
 #include <linux/pagemap.h>
 #include <linux/statfs.h>
+#include <linux/seq_file.h>
 #include "hostfs.h"
 #include "init.h"
 #include "kern.h"
@@ -322,12 +323,25 @@ static void hostfs_destroy_inode(struct inode *inode)
         kfree(HOSTFS_I(inode));
 }
 
+static int hostfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
+{
+        struct inode *root = vfs->mnt_sb->s_root->d_inode;
+        const char *root_path = HOSTFS_I(root)->host_filename;
+        size_t offset = strlen(root_ino) + 1;
+
+        if (strlen(root_path) > offset)
+                seq_printf(seq, ",%s", root_path + offset);
+
+        return 0;
+}
+
 static const struct super_operations hostfs_sbops = {
         .alloc_inode    = hostfs_alloc_inode,
         .drop_inode     = generic_delete_inode,
         .delete_inode   = hostfs_delete_inode,
         .destroy_inode  = hostfs_destroy_inode,
         .statfs         = hostfs_statfs,
+        .show_options   = hostfs_show_options,
 };
 
 int hostfs_readdir(struct file *file, void *ent, filldir_t filldir)
diff --git a/fs/hpfs/super.c b/fs/hpfs/super.c
index 00971d999964..f63a699ec659 100644
--- a/fs/hpfs/super.c
+++ b/fs/hpfs/super.c
@@ -386,6 +386,7 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
         int lowercase, conv, eas, chk, errs, chkdsk, timeshift;
         int o;
         struct hpfs_sb_info *sbi = hpfs_sb(s);
+        char *new_opts = kstrdup(data, GFP_KERNEL);
         
         *flags |= MS_NOATIME;
         
@@ -398,15 +399,15 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
         if (!(o = parse_opts(data, &uid, &gid, &umask, &lowercase, &conv,
             &eas, &chk, &errs, &chkdsk, &timeshift))) {
                 printk("HPFS: bad mount options.\n");
-                return 1;
+                goto out_err;
         }
         if (o == 2) {
                 hpfs_help();
-                return 1;
+                goto out_err;
         }
         if (timeshift != sbi->sb_timeshift) {
                 printk("HPFS: timeshift can't be changed using remount.\n");
-                return 1;
+                goto out_err;
         }
 
         unmark_dirty(s);
@@ -419,7 +420,14 @@ static int hpfs_remount_fs(struct super_block *s, int *flags, char *data)
 
         if (!(*flags & MS_RDONLY)) mark_dirty(s);
 
+        kfree(s->s_options);
+        s->s_options = new_opts;
+
         return 0;
+
+out_err:
+        kfree(new_opts);
+        return -EINVAL;
 }
 
 /* Super operations */
@@ -432,6 +440,7 @@ static const struct super_operations hpfs_sops =
         .put_super      = hpfs_put_super,
         .statfs         = hpfs_statfs,
         .remount_fs     = hpfs_remount_fs,
+        .show_options   = generic_show_options,
 };
 
 static int hpfs_fill_super(struct super_block *s, void *options, int silent)
@@ -454,6 +463,8 @@ static int hpfs_fill_super(struct super_block *s, void *options, int silent)
 
         int o;
 
+        save_mount_options(s, options);
+
         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
         if (!sbi)
                 return -ENOMEM;
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 3b3cc28cdefc..eee9487ae47f 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -734,6 +734,7 @@ static const struct super_operations hugetlbfs_ops = {
         .delete_inode   = hugetlbfs_delete_inode,
         .drop_inode     = hugetlbfs_drop_inode,
         .put_super      = hugetlbfs_put_super,
+        .show_options   = generic_show_options,
 };
 
 static int
@@ -817,6 +818,8 @@ hugetlbfs_fill_super(struct super_block *sb, void *data, int silent)
         struct hugetlbfs_config config;
         struct hugetlbfs_sb_info *sbinfo;
 
+        save_mount_options(sb, data);
+
         config.nr_blocks = -1; /* No limit on size by default */
         config.nr_inodes = -1; /* No limit on number of inodes by default */
         config.uid = current->fsuid;
diff --git a/fs/inotify_user.c b/fs/inotify_user.c
index a336c9709f3c..3ab09a65c456 100644
--- a/fs/inotify_user.c
+++ b/fs/inotify_user.c
@@ -283,7 +283,7 @@ static void inotify_dev_queue_event(struct inotify_watch *w, u32 wd, u32 mask,
         /* we can safely put the watch as we don't reference it while
          * generating the event
          */
-        if (mask & IN_IGNORED || mask & IN_ONESHOT)
+        if (mask & IN_IGNORED || w->mask & IN_ONESHOT)
                 put_inotify_watch(w); /* final put */
 
         /* coalescing: drop this event if it is a dupe of the previous */
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 875d37fb6c70..044a254d526b 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -110,6 +110,7 @@ static const struct super_operations isofs_sops = {
         .put_super      = isofs_put_super,
         .statfs         = isofs_statfs,
         .remount_fs     = isofs_remount,
+        .show_options   = generic_show_options,
 };
 
 
@@ -144,7 +145,8 @@ struct iso9660_options{
         char nocompress;
         unsigned char check;
         unsigned int blocksize;
-        mode_t mode;
+        mode_t fmode;
+        mode_t dmode;
         gid_t gid;
         uid_t uid;
         char *iocharset;
@@ -305,7 +307,7 @@ enum {
         Opt_block, Opt_check_r, Opt_check_s, Opt_cruft, Opt_gid, Opt_ignore,
         Opt_iocharset, Opt_map_a, Opt_map_n, Opt_map_o, Opt_mode, Opt_nojoliet,
         Opt_norock, Opt_sb, Opt_session, Opt_uid, Opt_unhide, Opt_utf8, Opt_err,
-        Opt_nocompress, Opt_hide, Opt_showassoc,
+        Opt_nocompress, Opt_hide, Opt_showassoc, Opt_dmode,
 };
 
 static match_table_t tokens = {
@@ -332,6 +334,7 @@ static match_table_t tokens = {
         {Opt_uid, "uid=%u"},
         {Opt_gid, "gid=%u"},
         {Opt_mode, "mode=%u"},
+        {Opt_dmode, "dmode=%u"},
         {Opt_block, "block=%u"},
         {Opt_ignore, "conv=binary"},
         {Opt_ignore, "conv=b"},
@@ -359,7 +362,7 @@ static int parse_options(char *options, struct iso9660_options *popt)
         popt->check = 'u';              /* unset */
         popt->nocompress = 0;
         popt->blocksize = 1024;
-        popt->mode = S_IRUGO | S_IXUGO; /*
+        popt->fmode = popt->dmode = S_IRUGO | S_IXUGO; /*
                                          * r-x for all.  The disc could
                                          * be shared with DOS machines so
                                          * virtually anything could be
@@ -451,7 +454,12 @@ static int parse_options(char *options, struct iso9660_options *popt)
                 case Opt_mode:
                         if (match_int(&args[0], &option))
                                 return 0;
-                        popt->mode = option;
+                        popt->fmode = option;
+                        break;
+                case Opt_dmode:
+                        if (match_int(&args[0], &option))
+                                return 0;
+                        popt->dmode = option;
                         break;
                 case Opt_block:
                         if (match_int(&args[0], &option))
@@ -554,6 +562,8 @@ static int isofs_fill_super(struct super_block *s, void *data, int silent)
         int table, error = -EINVAL;
         unsigned int vol_desc_start;
 
+        save_mount_options(s, data);
+
         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
         if (!sbi)
                 return -ENOMEM;
@@ -801,7 +811,8 @@ root_found:
          * on the disk as suid, so we merely allow them to set the default
          * permissions.
          */
-        sbi->s_mode = opt.mode & 0777;
+        sbi->s_fmode = opt.fmode & 0777;
+        sbi->s_dmode = opt.dmode & 0777;
 
         /*
          * Read the root inode, which _may_ result in changing
@@ -1248,7 +1259,7 @@ static int isofs_read_inode(struct inode *inode)
         ei->i_file_format = isofs_file_normal;
 
         if (de->flags[-high_sierra] & 2) {
-                inode->i_mode = S_IRUGO | S_IXUGO | S_IFDIR;
+                inode->i_mode = sbi->s_dmode | S_IFDIR;
                 inode->i_nlink = 1;     /*
                                          * Set to 1.  We know there are 2, but
                                          * the find utility tries to optimize
@@ -1258,9 +1269,8 @@ static int isofs_read_inode(struct inode *inode)
                                          */
         } else {
                 /* Everybody gets to read the file. */
-                inode->i_mode = sbi->s_mode;
+                inode->i_mode = sbi->s_fmode | S_IFREG;
                 inode->i_nlink = 1;
-                inode->i_mode |= S_IFREG;
         }
         inode->i_uid = sbi->s_uid;
         inode->i_gid = sbi->s_gid;
diff --git a/fs/isofs/isofs.h b/fs/isofs/isofs.h
index f3213f9f89af..d1bdf8adb351 100644
--- a/fs/isofs/isofs.h
+++ b/fs/isofs/isofs.h
@@ -51,7 +51,8 @@ struct isofs_sb_info {
         unsigned char s_hide;
         unsigned char s_showassoc;
 
-        mode_t s_mode;
+        mode_t s_fmode;
+        mode_t s_dmode;
         gid_t s_gid;
         uid_t s_uid;
         struct nls_table *s_nls_iocharset; /* Native language support table */
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index 31853eb65b4c..8e08efcaede2 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -131,6 +131,8 @@ static int journal_write_commit_record(journal_t *journal,
                 barrier_done = 1;
         }
         ret = sync_dirty_buffer(bh);
+        if (barrier_done)
+                clear_buffer_ordered(bh);
         /* is it possible for another commit to fail at roughly
          * the same time as this one?  If so, we don't want to
          * trust the barrier flag in the super, but instead want
@@ -148,7 +150,6 @@ static int journal_write_commit_record(journal_t *journal,
                 spin_unlock(&journal->j_state_lock);
 
                 /* And try again, without the barrier */
-                clear_buffer_ordered(bh);
                 set_buffer_uptodate(bh);
                 set_buffer_dirty(bh);
                 ret = sync_dirty_buffer(bh);
diff --git a/fs/libfs.c b/fs/libfs.c
index 5523bde96387..b004dfadd891 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -583,8 +583,8 @@ int simple_transaction_release(struct inode *inode, struct file *file)
 /* Simple attribute files */
 
 struct simple_attr {
-        u64 (*get)(void *);
-        void (*set)(void *, u64);
+        int (*get)(void *, u64 *);
+        int (*set)(void *, u64);
         char get_buf[24];       /* enough to store a u64 and "\n\0" */
         char set_buf[24];
         void *data;
@@ -595,7 +595,7 @@ struct simple_attr {
 /* simple_attr_open is called by an actual attribute open file operation
  * to set the attribute specific access operations. */
 int simple_attr_open(struct inode *inode, struct file *file,
-                     u64 (*get)(void *), void (*set)(void *, u64),
+                     int (*get)(void *, u64 *), int (*set)(void *, u64),
                      const char *fmt)
 {
         struct simple_attr *attr;
@@ -615,7 +615,7 @@ int simple_attr_open(struct inode *inode, struct file *file,
         return nonseekable_open(inode, file);
 }
 
-int simple_attr_close(struct inode *inode, struct file *file)
+int simple_attr_release(struct inode *inode, struct file *file)
 {
         kfree(file->private_data);
         return 0;
@@ -634,15 +634,24 @@ ssize_t simple_attr_read(struct file *file, char __user *buf,
         if (!attr->get)
                 return -EACCES;
 
-        mutex_lock(&attr->mutex);
-        if (*ppos) /* continued read */
+        ret = mutex_lock_interruptible(&attr->mutex);
+        if (ret)
+                return ret;
+
+        if (*ppos) {            /* continued read */
                 size = strlen(attr->get_buf);
-        else      /* first read */
+        } else {                /* first read */
+                u64 val;
+                ret = attr->get(attr->data, &val);
+                if (ret)
+                        goto out;
+
                 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
-                                 attr->fmt,
-                                 (unsigned long long)attr->get(attr->data));
+                                 attr->fmt, (unsigned long long)val);
+        }
 
         ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
+out:
         mutex_unlock(&attr->mutex);
         return ret;
 }
@@ -657,11 +666,13 @@ ssize_t simple_attr_write(struct file *file, const char __user *buf,
         ssize_t ret;
 
         attr = file->private_data;
-
         if (!attr->set)
                 return -EACCES;
 
-        mutex_lock(&attr->mutex);
+        ret = mutex_lock_interruptible(&attr->mutex);
+        if (ret)
+                return ret;
+
         ret = -EFAULT;
         size = min(sizeof(attr->set_buf) - 1, len);
         if (copy_from_user(attr->set_buf, buf, size))
@@ -793,6 +804,6 @@ EXPORT_SYMBOL(simple_transaction_get);
 EXPORT_SYMBOL(simple_transaction_read);
 EXPORT_SYMBOL(simple_transaction_release);
 EXPORT_SYMBOL_GPL(simple_attr_open);
-EXPORT_SYMBOL_GPL(simple_attr_close);
+EXPORT_SYMBOL_GPL(simple_attr_release);
 EXPORT_SYMBOL_GPL(simple_attr_read);
 EXPORT_SYMBOL_GPL(simple_attr_write);
diff --git a/fs/locks.c b/fs/locks.c
index 49354b9c7dc1..f36f0e61558d 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -658,8 +658,7 @@ posix_test_lock(struct file *filp, struct file_lock *fl)
         if (cfl) {
                 __locks_copy_lock(fl, cfl);
                 if (cfl->fl_nspid)
-                        fl->fl_pid = pid_nr_ns(cfl->fl_nspid,
-                                                task_active_pid_ns(current));
+                        fl->fl_pid = pid_vnr(cfl->fl_nspid);
         } else
                 fl->fl_type = F_UNLCK;
         unlock_kernel();
@@ -2084,7 +2083,7 @@ static void lock_get_status(struct seq_file *f, struct file_lock *fl,
         unsigned int fl_pid;
 
         if (fl->fl_nspid)
-                fl_pid = pid_nr_ns(fl->fl_nspid, task_active_pid_ns(current));
+                fl_pid = pid_vnr(fl->fl_nspid);
         else
                 fl_pid = fl->fl_pid;
 
diff --git a/fs/namei.c b/fs/namei.c
index 241cff423653..52703986323a 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -106,7 +106,7 @@
  * any extra contention...
  */
 
-static int fastcall link_path_walk(const char *name, struct nameidata *nd);
+static int link_path_walk(const char *name, struct nameidata *nd);
 
 /* In order to reduce some races, while at the same time doing additional
  * checking and hopefully speeding things up, we copy filenames to the
@@ -823,7 +823,7 @@ fail:
  * Returns 0 and nd will have valid dentry and mnt on success.
  * Returns error and drops reference to input namei data on failure.
  */
-static fastcall int __link_path_walk(const char * name, struct nameidata *nd)
+static int __link_path_walk(const char *name, struct nameidata *nd)
 {
         struct path next;
         struct inode *inode;
@@ -1015,7 +1015,7 @@ return_err:
  * Retry the whole path once, forcing real lookup requests
  * instead of relying on the dcache.
  */
-static int fastcall link_path_walk(const char *name, struct nameidata *nd)
+static int link_path_walk(const char *name, struct nameidata *nd)
 {
         struct nameidata save = *nd;
         int result;
@@ -1039,7 +1039,7 @@ static int fastcall link_path_walk(const char *name, struct nameidata *nd)
         return result;
 }
 
-static int fastcall path_walk(const char * name, struct nameidata *nd)
+static int path_walk(const char *name, struct nameidata *nd)
 {
         current->total_link_count = 0;
         return link_path_walk(name, nd);
@@ -1116,7 +1116,7 @@ set_it:
 }
 
 /* Returns 0 and nd will be valid on success; Retuns error, otherwise. */
-static int fastcall do_path_lookup(int dfd, const char *name,
+static int do_path_lookup(int dfd, const char *name,
                                 unsigned int flags, struct nameidata *nd)
 {
         int retval = 0;
@@ -1183,7 +1183,7 @@ fput_fail:
         goto out_fail;
 }
 
-int fastcall path_lookup(const char *name, unsigned int flags,
+int path_lookup(const char *name, unsigned int flags,
                         struct nameidata *nd)
 {
         return do_path_lookup(AT_FDCWD, name, flags, nd);
@@ -1409,7 +1409,7 @@ struct dentry *lookup_one_noperm(const char *name, struct dentry *base)
         return __lookup_hash(&this, base, NULL);
 }
 
-int fastcall __user_walk_fd(int dfd, const char __user *name, unsigned flags,
+int __user_walk_fd(int dfd, const char __user *name, unsigned flags,
                             struct nameidata *nd)
 {
         char *tmp = getname(name);
@@ -1422,7 +1422,7 @@ int fastcall __user_walk_fd(int dfd, const char __user *name, unsigned flags,
         return err;
 }
 
-int fastcall __user_walk(const char __user *name, unsigned flags, struct nameidata *nd)
+int __user_walk(const char __user *name, unsigned flags, struct nameidata *nd)
 {
         return __user_walk_fd(AT_FDCWD, name, flags, nd);
 }
diff --git a/fs/namespace.c b/fs/namespace.c
index e9c10cd01e13..63ced21c12dc 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -320,6 +320,50 @@ void mnt_unpin(struct vfsmount *mnt)
 
 EXPORT_SYMBOL(mnt_unpin);
 
+static inline void mangle(struct seq_file *m, const char *s)
+{
+        seq_escape(m, s, " \t\n\\");
+}
+
+/*
+ * Simple .show_options callback for filesystems which don't want to
+ * implement more complex mount option showing.
+ *
+ * See also save_mount_options().
+ */
+int generic_show_options(struct seq_file *m, struct vfsmount *mnt)
+{
+        const char *options = mnt->mnt_sb->s_options;
+
+        if (options != NULL && options[0]) {
+                seq_putc(m, ',');
+                mangle(m, options);
+        }
+
+        return 0;
+}
+EXPORT_SYMBOL(generic_show_options);
+
+/*
+ * If filesystem uses generic_show_options(), this function should be
+ * called from the fill_super() callback.
+ *
+ * The .remount_fs callback usually needs to be handled in a special
+ * way, to make sure, that previous options are not overwritten if the
+ * remount fails.
+ *
+ * Also note, that if the filesystem's .remount_fs function doesn't
+ * reset all options to their default value, but changes only newly
+ * given options, then the displayed options will not reflect reality
+ * any more.
+ */
+void save_mount_options(struct super_block *sb, char *options)
+{
+        kfree(sb->s_options);
+        sb->s_options = kstrdup(options, GFP_KERNEL);
+}
+EXPORT_SYMBOL(save_mount_options);
+
 /* iterator */
 static void *m_start(struct seq_file *m, loff_t *pos)
 {
@@ -341,11 +385,6 @@ static void m_stop(struct seq_file *m, void *v)
         up_read(&namespace_sem);
 }
 
-static inline void mangle(struct seq_file *m, const char *s)
-{
-        seq_escape(m, s, " \t\n\\");
-}
-
 static int show_vfsmnt(struct seq_file *m, void *v)
 {
         struct vfsmount *mnt = list_entry(v, struct vfsmount, mnt_list);
@@ -897,8 +936,9 @@ out_unlock:
 
 /*
  * recursively change the type of the mountpoint.
+ * noinline this do_mount helper to save do_mount stack space.
  */
-static int do_change_type(struct nameidata *nd, int flag)
+static noinline int do_change_type(struct nameidata *nd, int flag)
 {
         struct vfsmount *m, *mnt = nd->mnt;
         int recurse = flag & MS_REC;
@@ -921,8 +961,10 @@ static int do_change_type(struct nameidata *nd, int flag)
 
 /*
  * do loopback mount.
+ * noinline this do_mount helper to save do_mount stack space.
  */
-static int do_loopback(struct nameidata *nd, char *old_name, int recurse)
+static noinline int do_loopback(struct nameidata *nd, char *old_name,
+                                int recurse)
 {
         struct nameidata old_nd;
         struct vfsmount *mnt = NULL;
@@ -971,8 +1013,9 @@ out:
  * change filesystem flags. dir should be a physical root of filesystem.
  * If you've mounted a non-root directory somewhere and want to do remount
  * on it - tough luck.
+ * noinline this do_mount helper to save do_mount stack space.
  */
-static int do_remount(struct nameidata *nd, int flags, int mnt_flags,
+static noinline int do_remount(struct nameidata *nd, int flags, int mnt_flags,
                       void *data)
 {
         int err;
@@ -1007,7 +1050,10 @@ static inline int tree_contains_unbindable(struct vfsmount *mnt)
         return 0;
 }
 
-static int do_move_mount(struct nameidata *nd, char *old_name)
+/*
+ * noinline this do_mount helper to save do_mount stack space.
+ */
+static noinline int do_move_mount(struct nameidata *nd, char *old_name)
 {
         struct nameidata old_nd, parent_nd;
         struct vfsmount *p;
@@ -1082,8 +1128,9 @@ out:
 /*
  * create a new mount for userspace and request it to be added into the
  * namespace's tree
+ * noinline this do_mount helper to save do_mount stack space.
  */
-static int do_new_mount(struct nameidata *nd, char *type, int flags,
+static noinline int do_new_mount(struct nameidata *nd, char *type, int flags,
                         int mnt_flags, char *name, void *data)
 {
         struct vfsmount *mnt;
diff --git a/fs/ncpfs/inode.c b/fs/ncpfs/inode.c
index eff1f18d034f..fbbb9f7afa1a 100644
--- a/fs/ncpfs/inode.c
+++ b/fs/ncpfs/inode.c
@@ -28,6 +28,8 @@
 #include <linux/init.h>
 #include <linux/smp_lock.h>
 #include <linux/vfs.h>
+#include <linux/mount.h>
+#include <linux/seq_file.h>
 
 #include <linux/ncp_fs.h>
 
@@ -36,9 +38,15 @@
 #include "ncplib_kernel.h"
 #include "getopt.h"
 
+#define NCP_DEFAULT_FILE_MODE 0600
+#define NCP_DEFAULT_DIR_MODE 0700
+#define NCP_DEFAULT_TIME_OUT 10
+#define NCP_DEFAULT_RETRY_COUNT 20
+
 static void ncp_delete_inode(struct inode *);
 static void ncp_put_super(struct super_block *);
 static int  ncp_statfs(struct dentry *, struct kstatfs *);
+static int  ncp_show_options(struct seq_file *, struct vfsmount *);
 
 static struct kmem_cache * ncp_inode_cachep;
 
@@ -96,6 +104,7 @@ static const struct super_operations ncp_sops =
         .put_super      = ncp_put_super,
         .statfs         = ncp_statfs,
         .remount_fs     = ncp_remount,
+        .show_options   = ncp_show_options,
 };
 
 extern struct dentry_operations ncp_root_dentry_operations;
@@ -304,6 +313,37 @@ static void ncp_stop_tasks(struct ncp_server *server) {
         flush_scheduled_work();
 }
 
+static int  ncp_show_options(struct seq_file *seq, struct vfsmount *mnt)
+{
+        struct ncp_server *server = NCP_SBP(mnt->mnt_sb);
+        unsigned int tmp;
+
+        if (server->m.uid != 0)
+                seq_printf(seq, ",uid=%u", server->m.uid);
+        if (server->m.gid != 0)
+                seq_printf(seq, ",gid=%u", server->m.gid);
+        if (server->m.mounted_uid != 0)
+                seq_printf(seq, ",owner=%u", server->m.mounted_uid);
+        tmp = server->m.file_mode & S_IALLUGO;
+        if (tmp != NCP_DEFAULT_FILE_MODE)
+                seq_printf(seq, ",mode=0%o", tmp);
+        tmp = server->m.dir_mode & S_IALLUGO;
+        if (tmp != NCP_DEFAULT_DIR_MODE)
+                seq_printf(seq, ",dirmode=0%o", tmp);
+        if (server->m.time_out != NCP_DEFAULT_TIME_OUT * HZ / 100) {
+                tmp = server->m.time_out * 100 / HZ;
+                seq_printf(seq, ",timeout=%u", tmp);
+        }
+        if (server->m.retry_count != NCP_DEFAULT_RETRY_COUNT)
+                seq_printf(seq, ",retry=%u", server->m.retry_count);
+        if (server->m.flags != 0)
+                seq_printf(seq, ",flags=%lu", server->m.flags);
+        if (server->m.wdog_pid != NULL)
+                seq_printf(seq, ",wdogpid=%u", pid_vnr(server->m.wdog_pid));
+
+        return 0;
+}
+
 static const struct ncp_option ncp_opts[] = {
         { "uid",        OPT_INT,        'u' },
         { "gid",        OPT_INT,        'g' },
@@ -331,12 +371,12 @@ static int ncp_parse_options(struct ncp_mount_data_kernel *data, char *options)
         data->mounted_uid = 0;
         data->wdog_pid = NULL;
         data->ncp_fd = ~0;
-        data->time_out = 10;
-        data->retry_count = 20;
+        data->time_out = NCP_DEFAULT_TIME_OUT;
+        data->retry_count = NCP_DEFAULT_RETRY_COUNT;
         data->uid = 0;
         data->gid = 0;
-        data->file_mode = 0600;
-        data->dir_mode = 0700;
+        data->file_mode = NCP_DEFAULT_FILE_MODE;
+        data->dir_mode = NCP_DEFAULT_DIR_MODE;
         data->info_fd = -1;
         data->mounted_vol[0] = 0;
         
@@ -982,6 +1022,7 @@ static struct file_system_type ncp_fs_type = {
         .name           = "ncpfs",
         .get_sb         = ncp_get_sb,
         .kill_sb        = kill_anon_super,
+        .fs_flags       = FS_BINARY_MOUNTDATA,
 };
 
 static int __init init_ncp_fs(void)
diff --git a/fs/ocfs2/cluster/endian.h b/fs/ocfs2/cluster/endian.h
deleted file mode 100644
index 2df9082f4e35..000000000000
--- a/fs/ocfs2/cluster/endian.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/* -*- mode: c; c-basic-offset: 8; -*-
- * vim: noexpandtab sw=8 ts=8 sts=0:
- *
- * Copyright (C) 2005 Oracle.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
-
-#ifndef OCFS2_CLUSTER_ENDIAN_H
-#define OCFS2_CLUSTER_ENDIAN_H
-
-static inline void be32_add_cpu(__be32 *var, u32 val)
-{
-        *var = cpu_to_be32(be32_to_cpu(*var) + val);
-}
-
-#endif /* OCFS2_CLUSTER_ENDIAN_H */
diff --git a/fs/ocfs2/cluster/nodemanager.c b/fs/ocfs2/cluster/nodemanager.c
index af2070da308b..709fba25bf7e 100644
--- a/fs/ocfs2/cluster/nodemanager.c
+++ b/fs/ocfs2/cluster/nodemanager.c
@@ -24,7 +24,6 @@
 #include <linux/sysctl.h>
 #include <linux/configfs.h>
 
-#include "endian.h"
 #include "tcp.h"
 #include "nodemanager.h"
 #include "heartbeat.h"
diff --git a/fs/ocfs2/dlm/dlmast.c b/fs/ocfs2/dlm/dlmast.c
index 2fd8bded38f3..644bee55d8ba 100644
--- a/fs/ocfs2/dlm/dlmast.c
+++ b/fs/ocfs2/dlm/dlmast.c
@@ -43,7 +43,6 @@
 #include "cluster/heartbeat.h"
 #include "cluster/nodemanager.h"
 #include "cluster/tcp.h"
-#include "cluster/endian.h"
 
 #include "dlmapi.h"
 #include "dlmcommon.h"
diff --git a/fs/ocfs2/endian.h b/fs/ocfs2/endian.h
deleted file mode 100644
index 1942e09f6ee5..000000000000
--- a/fs/ocfs2/endian.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/* -*- mode: c; c-basic-offset: 8; -*-
- * vim: noexpandtab sw=8 ts=8 sts=0:
- *
- * Copyright (C) 2005 Oracle.  All rights reserved.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public
- * License along with this program; if not, write to the
- * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
- * Boston, MA 021110-1307, USA.
- */
-
-#ifndef OCFS2_ENDIAN_H
-#define OCFS2_ENDIAN_H
-
-static inline void le16_add_cpu(__le16 *var, u16 val)
-{
-        *var = cpu_to_le16(le16_to_cpu(*var) + val);
-}
-
-static inline void le32_add_cpu(__le32 *var, u32 val)
-{
-        *var = cpu_to_le32(le32_to_cpu(*var) + val);
-}
-
-static inline void le64_add_cpu(__le64 *var, u64 val)
-{
-        *var = cpu_to_le64(le64_to_cpu(*var) + val);
-}
-
-static inline void be32_add_cpu(__be32 *var, u32 val)
-{
-        *var = cpu_to_be32(be32_to_cpu(*var) + val);
-}
-
-#endif /* OCFS2_ENDIAN_H */
diff --git a/fs/ocfs2/ocfs2.h b/fs/ocfs2/ocfs2.h
index e8b7292e0152..6546cef212e3 100644
--- a/fs/ocfs2/ocfs2.h
+++ b/fs/ocfs2/ocfs2.h
@@ -43,7 +43,6 @@
 #include "dlm/dlmapi.h"
 
 #include "ocfs2_fs.h"
-#include "endian.h"
 #include "ocfs2_lockid.h"
 
 /* Most user visible OCFS2 inodes will have very few pieces of
diff --git a/fs/open.c b/fs/open.c
index 4932b4d1da05..43fcd6031969 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -991,7 +991,7 @@ static void __put_unused_fd(struct files_struct *files, unsigned int fd)
                 files->next_fd = fd;
 }
 
-void fastcall put_unused_fd(unsigned int fd)
+void put_unused_fd(unsigned int fd)
 {
         struct files_struct *files = current->files;
         spin_lock(&files->file_lock);
@@ -1014,7 +1014,7 @@ EXPORT_SYMBOL(put_unused_fd);
  * will follow.
  */
 
-void fastcall fd_install(unsigned int fd, struct file * file)
+void fd_install(unsigned int fd, struct file *file)
 {
         struct files_struct *files = current->files;
         struct fdtable *fdt;
@@ -1061,7 +1061,6 @@ asmlinkage long sys_open(const char __user *filename, int flags, int mode)
         prevent_tail_call(ret);
         return ret;
 }
-EXPORT_UNUSED_SYMBOL_GPL(sys_open); /* To be deleted for 2.6.25 */
 
 asmlinkage long sys_openat(int dfd, const char __user *filename, int flags,
                            int mode)
diff --git a/fs/pipe.c b/fs/pipe.c
index e66ec48e95d8..a07e9a542064 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -576,9 +576,7 @@ bad_pipe_w(struct file *filp, const char __user *buf, size_t count,
         return -EBADF;
 }
 
-static int
-pipe_ioctl(struct inode *pino, struct file *filp,
-           unsigned int cmd, unsigned long arg)
+static long pipe_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
         struct inode *inode = filp->f_path.dentry->d_inode;
         struct pipe_inode_info *pipe;
@@ -785,7 +783,7 @@ const struct file_operations read_fifo_fops = {
         .aio_read       = pipe_read,
         .write          = bad_pipe_w,
         .poll           = pipe_poll,
-        .ioctl          = pipe_ioctl,
+        .unlocked_ioctl = pipe_ioctl,
         .open           = pipe_read_open,
         .release        = pipe_read_release,
         .fasync         = pipe_read_fasync,
@@ -797,7 +795,7 @@ const struct file_operations write_fifo_fops = {
         .write          = do_sync_write,
         .aio_write      = pipe_write,
         .poll           = pipe_poll,
-        .ioctl          = pipe_ioctl,
+        .unlocked_ioctl = pipe_ioctl,
         .open           = pipe_write_open,
         .release        = pipe_write_release,
         .fasync         = pipe_write_fasync,
@@ -810,7 +808,7 @@ const struct file_operations rdwr_fifo_fops = {
         .write          = do_sync_write,
         .aio_write      = pipe_write,
         .poll           = pipe_poll,
-        .ioctl          = pipe_ioctl,
+        .unlocked_ioctl = pipe_ioctl,
         .open           = pipe_rdwr_open,
         .release        = pipe_rdwr_release,
         .fasync         = pipe_rdwr_fasync,
@@ -822,7 +820,7 @@ static const struct file_operations read_pipe_fops = {
         .aio_read       = pipe_read,
         .write          = bad_pipe_w,
         .poll           = pipe_poll,
-        .ioctl          = pipe_ioctl,
+        .unlocked_ioctl = pipe_ioctl,
         .open           = pipe_read_open,
         .release        = pipe_read_release,
         .fasync         = pipe_read_fasync,
@@ -834,7 +832,7 @@ static const struct file_operations write_pipe_fops = {
         .write          = do_sync_write,
         .aio_write      = pipe_write,
         .poll           = pipe_poll,
-        .ioctl          = pipe_ioctl,
+        .unlocked_ioctl = pipe_ioctl,
         .open           = pipe_write_open,
         .release        = pipe_write_release,
         .fasync         = pipe_write_fasync,
@@ -847,7 +845,7 @@ static const struct file_operations rdwr_pipe_fops = {
         .write          = do_sync_write,
         .aio_write      = pipe_write,
         .poll           = pipe_poll,
-        .ioctl          = pipe_ioctl,
+        .unlocked_ioctl = pipe_ioctl,
         .open           = pipe_rdwr_open,
         .release        = pipe_rdwr_release,
         .fasync         = pipe_rdwr_fasync,
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 6ba2746e4517..07d6c4853fe8 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -77,6 +77,7 @@
 #include <linux/cpuset.h>
 #include <linux/rcupdate.h>
 #include <linux/delayacct.h>
+#include <linux/seq_file.h>
 #include <linux/pid_namespace.h>
 
 #include <asm/pgtable.h>
@@ -88,18 +89,21 @@
 do { memcpy(buffer, string, strlen(string)); \
      buffer += strlen(string); } while (0)
 
-static inline char *task_name(struct task_struct *p, char *buf)
+static inline void task_name(struct seq_file *m, struct task_struct *p)
 {
         int i;
+        char *buf, *end;
         char *name;
         char tcomm[sizeof(p->comm)];
 
         get_task_comm(tcomm, p);
 
-        ADDBUF(buf, "Name:\t");
+        seq_printf(m, "Name:\t");
+        end = m->buf + m->size;
+        buf = m->buf + m->count;
         name = tcomm;
         i = sizeof(tcomm);
-        do {
+        while (i && (buf < end)) {
                 unsigned char c = *name;
                 name++;
                 i--;
@@ -107,20 +111,21 @@ static inline char *task_name(struct task_struct *p, char *buf)
                 if (!c)
                         break;
                 if (c == '\\') {
-                        buf[1] = c;
-                        buf += 2;
+                        buf++;
+                        if (buf < end)
+                                *buf++ = c;
                         continue;
                 }
                 if (c == '\n') {
-                        buf[0] = '\\';
-                        buf[1] = 'n';
-                        buf += 2;
+                        *buf++ = '\\';
+                        if (buf < end)
+                                *buf++ = 'n';
                         continue;
                 }
                 buf++;
-        } while (i);
-        *buf = '\n';
-        return buf+1;
+        }
+        m->count = buf - m->buf;
+        seq_printf(m, "\n");
 }
 
 /*
@@ -151,21 +156,20 @@ static inline const char *get_task_state(struct task_struct *tsk)
         return *p;
 }
 
-static inline char *task_state(struct task_struct *p, char *buffer)
+static inline void task_state(struct seq_file *m, struct pid_namespace *ns,
+                                struct pid *pid, struct task_struct *p)
 {
         struct group_info *group_info;
         int g;
         struct fdtable *fdt = NULL;
-        struct pid_namespace *ns;
         pid_t ppid, tpid;
 
-        ns = current->nsproxy->pid_ns;
         rcu_read_lock();
         ppid = pid_alive(p) ?
                 task_tgid_nr_ns(rcu_dereference(p->real_parent), ns) : 0;
         tpid = pid_alive(p) && p->ptrace ?
                 task_pid_nr_ns(rcu_dereference(p->parent), ns) : 0;
-        buffer += sprintf(buffer,
+        seq_printf(m,
                 "State:\t%s\n"
                 "Tgid:\t%d\n"
                 "Pid:\t%d\n"
@@ -175,7 +179,7 @@ static inline char *task_state(struct task_struct *p, char *buffer)
                 "Gid:\t%d\t%d\t%d\t%d\n",
                 get_task_state(p),
                 task_tgid_nr_ns(p, ns),
-                task_pid_nr_ns(p, ns),
+                pid_nr_ns(pid, ns),
                 ppid, tpid,
                 p->uid, p->euid, p->suid, p->fsuid,
                 p->gid, p->egid, p->sgid, p->fsgid);
@@ -183,7 +187,7 @@ static inline char *task_state(struct task_struct *p, char *buffer)
         task_lock(p);
         if (p->files)
                 fdt = files_fdtable(p->files);
-        buffer += sprintf(buffer,
+        seq_printf(m,
                 "FDSize:\t%d\n"
                 "Groups:\t",
                 fdt ? fdt->max_fds : 0);
@@ -194,20 +198,18 @@ static inline char *task_state(struct task_struct *p, char *buffer)
         task_unlock(p);
 
         for (g = 0; g < min(group_info->ngroups, NGROUPS_SMALL); g++)
-                buffer += sprintf(buffer, "%d ", GROUP_AT(group_info, g));
+                seq_printf(m, "%d ", GROUP_AT(group_info, g));
         put_group_info(group_info);
 
-        buffer += sprintf(buffer, "\n");
-        return buffer;
+        seq_printf(m, "\n");
 }
 
-static char *render_sigset_t(const char *header, sigset_t *set, char *buffer)
+static void render_sigset_t(struct seq_file *m, const char *header,
+                                sigset_t *set)
 {
-        int i, len;
+        int i;
 
-        len = strlen(header);
-        memcpy(buffer, header, len);
-        buffer += len;
+        seq_printf(m, "%s", header);
 
         i = _NSIG;
         do {
@@ -218,12 +220,10 @@ static char *render_sigset_t(const char *header, sigset_t *set, char *buffer)
                 if (sigismember(set, i+2)) x |= 2;
                 if (sigismember(set, i+3)) x |= 4;
                 if (sigismember(set, i+4)) x |= 8;
-                *buffer++ = (x < 10 ? '0' : 'a' - 10) + x;
+                seq_printf(m, "%x", x);
         } while (i >= 4);
 
-        *buffer++ = '\n';
-        *buffer = 0;
-        return buffer;
+        seq_printf(m, "\n");
 }
 
 static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
@@ -241,7 +241,7 @@ static void collect_sigign_sigcatch(struct task_struct *p, sigset_t *ign,
         }
 }
 
-static inline char *task_sig(struct task_struct *p, char *buffer)
+static inline void task_sig(struct seq_file *m, struct task_struct *p)
 {
         unsigned long flags;
         sigset_t pending, shpending, blocked, ignored, caught;
@@ -268,67 +268,66 @@ static inline char *task_sig(struct task_struct *p, char *buffer)
         }
         rcu_read_unlock();
 
-        buffer += sprintf(buffer, "Threads:\t%d\n", num_threads);
-        buffer += sprintf(buffer, "SigQ:\t%lu/%lu\n", qsize, qlim);
+        seq_printf(m, "Threads:\t%d\n", num_threads);
+        seq_printf(m, "SigQ:\t%lu/%lu\n", qsize, qlim);
 
         /* render them all */
-        buffer = render_sigset_t("SigPnd:\t", &pending, buffer);
-        buffer = render_sigset_t("ShdPnd:\t", &shpending, buffer);
-        buffer = render_sigset_t("SigBlk:\t", &blocked, buffer);
-        buffer = render_sigset_t("SigIgn:\t", &ignored, buffer);
-        buffer = render_sigset_t("SigCgt:\t", &caught, buffer);
-
-        return buffer;
+        render_sigset_t(m, "SigPnd:\t", &pending);
+        render_sigset_t(m, "ShdPnd:\t", &shpending);
+        render_sigset_t(m, "SigBlk:\t", &blocked);
+        render_sigset_t(m, "SigIgn:\t", &ignored);
+        render_sigset_t(m, "SigCgt:\t", &caught);
 }
 
-static char *render_cap_t(const char *header, kernel_cap_t *a, char *buffer)
+static void render_cap_t(struct seq_file *m, const char *header,
+                        kernel_cap_t *a)
 {
         unsigned __capi;
 
-        buffer += sprintf(buffer, "%s", header);
+        seq_printf(m, "%s", header);
         CAP_FOR_EACH_U32(__capi) {
-                buffer += sprintf(buffer, "%08x",
-                                  a->cap[(_LINUX_CAPABILITY_U32S-1) - __capi]);
+                seq_printf(m, "%08x",
+                           a->cap[(_LINUX_CAPABILITY_U32S-1) - __capi]);
         }
-        return buffer + sprintf(buffer, "\n");
+        seq_printf(m, "\n");
 }
 
-static inline char *task_cap(struct task_struct *p, char *buffer)
+static inline void task_cap(struct seq_file *m, struct task_struct *p)
 {
-        buffer = render_cap_t("CapInh:\t", &p->cap_inheritable, buffer);
-        buffer = render_cap_t("CapPrm:\t", &p->cap_permitted, buffer);
-        return render_cap_t("CapEff:\t", &p->cap_effective, buffer);
+        render_cap_t(m, "CapInh:\t", &p->cap_inheritable);
+        render_cap_t(m, "CapPrm:\t", &p->cap_permitted);
+        render_cap_t(m, "CapEff:\t", &p->cap_effective);
 }
 
-static inline char *task_context_switch_counts(struct task_struct *p,
-                                                char *buffer)
+static inline void task_context_switch_counts(struct seq_file *m,
+                                                struct task_struct *p)
 {
-        return buffer + sprintf(buffer, "voluntary_ctxt_switches:\t%lu\n"
-                            "nonvoluntary_ctxt_switches:\t%lu\n",
-                            p->nvcsw,
-                            p->nivcsw);
+        seq_printf(m,   "voluntary_ctxt_switches:\t%lu\n"
+                        "nonvoluntary_ctxt_switches:\t%lu\n",
+                        p->nvcsw,
+                        p->nivcsw);
 }
 
-int proc_pid_status(struct task_struct *task, char *buffer)
+int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
+                        struct pid *pid, struct task_struct *task)
 {
-        char *orig = buffer;
         struct mm_struct *mm = get_task_mm(task);
 
-        buffer = task_name(task, buffer);
-        buffer = task_state(task, buffer);
+        task_name(m, task);
+        task_state(m, ns, pid, task);
 
         if (mm) {
-                buffer = task_mem(mm, buffer);
+                task_mem(m, mm);
                 mmput(mm);
         }
-        buffer = task_sig(task, buffer);
-        buffer = task_cap(task, buffer);
-        buffer = cpuset_task_status_allowed(task, buffer);
+        task_sig(m, task);
+        task_cap(m, task);
+        cpuset_task_status_allowed(m, task);
 #if defined(CONFIG_S390)
-        buffer = task_show_regs(task, buffer);
+        task_show_regs(m, task);
 #endif
-        buffer = task_context_switch_counts(task, buffer);
-        return buffer - orig;
+        task_context_switch_counts(m, task);
+        return 0;
 }
 
 /*
@@ -390,14 +389,14 @@ static cputime_t task_gtime(struct task_struct *p)
         return p->gtime;
 }
 
-static int do_task_stat(struct task_struct *task, char *buffer, int whole)
+static int do_task_stat(struct seq_file *m, struct pid_namespace *ns,
+                        struct pid *pid, struct task_struct *task, int whole)
 {
         unsigned long vsize, eip, esp, wchan = ~0UL;
         long priority, nice;
         int tty_pgrp = -1, tty_nr = 0;
         sigset_t sigign, sigcatch;
         char state;
-        int res;
         pid_t ppid = 0, pgid = -1, sid = -1;
         int num_threads = 0;
         struct mm_struct *mm;
@@ -409,9 +408,6 @@ static int do_task_stat(struct task_struct *task, char *buffer, int whole)
         unsigned long rsslim = 0;
         char tcomm[sizeof(task->comm)];
         unsigned long flags;
-        struct pid_namespace *ns;
-
-        ns = current->nsproxy->pid_ns;
 
         state = *get_task_state(task);
         vsize = eip = esp = 0;
@@ -498,10 +494,10 @@ static int do_task_stat(struct task_struct *task, char *buffer, int whole)
         /* convert nsec -> ticks */
         start_time = nsec_to_clock_t(start_time);
 
-        res = sprintf(buffer, "%d (%s) %c %d %d %d %d %d %u %lu \
+        seq_printf(m, "%d (%s) %c %d %d %d %d %d %u %lu \
 %lu %lu %lu %lu %lu %ld %ld %ld %ld %d 0 %llu %lu %ld %lu %lu %lu %lu %lu \
 %lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu %lu %ld\n",
-                task_pid_nr_ns(task, ns),
+                pid_nr_ns(pid, ns),
                 tcomm,
                 state,
                 ppid,
@@ -550,20 +546,23 @@ static int do_task_stat(struct task_struct *task, char *buffer, int whole)
                 cputime_to_clock_t(cgtime));
         if (mm)
                 mmput(mm);
-        return res;
+        return 0;
 }
 
-int proc_tid_stat(struct task_struct *task, char *buffer)
+int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
+                        struct pid *pid, struct task_struct *task)
 {
-        return do_task_stat(task, buffer, 0);
+        return do_task_stat(m, ns, pid, task, 0);
 }
 
-int proc_tgid_stat(struct task_struct *task, char *buffer)
+int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
+                        struct pid *pid, struct task_struct *task)
 {
-        return do_task_stat(task, buffer, 1);
+        return do_task_stat(m, ns, pid, task, 1);
 }
 
-int proc_pid_statm(struct task_struct *task, char *buffer)
+int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
+                        struct pid *pid, struct task_struct *task)
 {
         int size = 0, resident = 0, shared = 0, text = 0, lib = 0, data = 0;
         struct mm_struct *mm = get_task_mm(task);
@@ -572,7 +571,8 @@ int proc_pid_statm(struct task_struct *task, char *buffer)
                 size = task_statm(mm, &shared, &text, &data, &resident);
                 mmput(mm);
         }
+        seq_printf(m, "%d %d %d %d %d %d %d\n",
+                        size, resident, shared, text, lib, data, 0);
 
-        return sprintf(buffer, "%d %d %d %d %d %d %d\n",
-                       size, resident, shared, text, lib, data, 0);
+        return 0;
 }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index c59852b38787..a0c4ba6c6e57 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -121,6 +121,10 @@ struct pid_entry {
         NOD(NAME, (S_IFREG|(MODE)),                     \
                 NULL, &proc_info_file_operations,       \
                 { .proc_read = &proc_##OTYPE } )
+#define ONE(NAME, MODE, OTYPE)                          \
+        NOD(NAME, (S_IFREG|(MODE)),                     \
+                NULL, &proc_single_file_operations,     \
+                { .proc_show = &proc_##OTYPE } )
 
 int maps_protect;
 EXPORT_SYMBOL(maps_protect);
@@ -502,7 +506,7 @@ static const struct inode_operations proc_def_inode_operations = {
         .setattr        = proc_setattr,
 };
 
-extern struct seq_operations mounts_op;
+extern const struct seq_operations mounts_op;
 struct proc_mounts {
         struct seq_file m;
         int event;
@@ -581,7 +585,7 @@ static const struct file_operations proc_mounts_operations = {
         .poll           = mounts_poll,
 };
 
-extern struct seq_operations mountstats_op;
+extern const struct seq_operations mountstats_op;
 static int mountstats_open(struct inode *inode, struct file *file)
 {
         int ret = seq_open(file, &mountstats_op);
@@ -658,6 +662,45 @@ static const struct file_operations proc_info_file_operations = {
         .read           = proc_info_read,
 };
 
+static int proc_single_show(struct seq_file *m, void *v)
+{
+        struct inode *inode = m->private;
+        struct pid_namespace *ns;
+        struct pid *pid;
+        struct task_struct *task;
+        int ret;
+
+        ns = inode->i_sb->s_fs_info;
+        pid = proc_pid(inode);
+        task = get_pid_task(pid, PIDTYPE_PID);
+        if (!task)
+                return -ESRCH;
+
+        ret = PROC_I(inode)->op.proc_show(m, ns, pid, task);
+
+        put_task_struct(task);
+        return ret;
+}
+
+static int proc_single_open(struct inode *inode, struct file *filp)
+{
+        int ret;
+        ret = single_open(filp, proc_single_show, NULL);
+        if (!ret) {
+                struct seq_file *m = filp->private_data;
+
+                m->private = inode;
+        }
+        return ret;
+}
+
+static const struct file_operations proc_single_file_operations = {
+        .open           = proc_single_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
 static int mem_open(struct inode* inode, struct file* file)
 {
         file->private_data = (void*)((long)current->self_exec_id);
@@ -2058,15 +2101,23 @@ static const struct file_operations proc_coredump_filter_operations = {
 static int proc_self_readlink(struct dentry *dentry, char __user *buffer,
                               int buflen)
 {
+        struct pid_namespace *ns = dentry->d_sb->s_fs_info;
+        pid_t pid = task_pid_nr_ns(current, ns);
         char tmp[PROC_NUMBUF];
-        sprintf(tmp, "%d", task_tgid_vnr(current));
+        if (!pid)
+                return -ENOENT;
+        sprintf(tmp, "%d", pid);
         return vfs_readlink(dentry,buffer,buflen,tmp);
 }
 
 static void *proc_self_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
+        struct pid_namespace *ns = dentry->d_sb->s_fs_info;
+        pid_t pid = task_pid_nr_ns(current, ns);
         char tmp[PROC_NUMBUF];
-        sprintf(tmp, "%d", task_tgid_vnr(current));
+        if (!pid)
+                return ERR_PTR(-ENOENT);
+        sprintf(tmp, "%d", pid);
         return ERR_PTR(vfs_follow_link(nd,tmp));
 }
 
@@ -2231,14 +2282,14 @@ static const struct pid_entry tgid_base_stuff[] = {
         DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
         REG("environ",    S_IRUSR, environ),
         INF("auxv",       S_IRUSR, pid_auxv),
-        INF("status",     S_IRUGO, pid_status),
+        ONE("status",     S_IRUGO, pid_status),
         INF("limits",     S_IRUSR, pid_limits),
 #ifdef CONFIG_SCHED_DEBUG
         REG("sched",      S_IRUGO|S_IWUSR, pid_sched),
 #endif
         INF("cmdline",    S_IRUGO, pid_cmdline),
-        INF("stat",       S_IRUGO, tgid_stat),
-        INF("statm",      S_IRUGO, pid_statm),
+        ONE("stat",       S_IRUGO, tgid_stat),
+        ONE("statm",      S_IRUGO, pid_statm),
         REG("maps",       S_IRUGO, maps),
 #ifdef CONFIG_NUMA
         REG("numa_maps",  S_IRUGO, numa_maps),
@@ -2562,14 +2613,14 @@ static const struct pid_entry tid_base_stuff[] = {
         DIR("fdinfo",    S_IRUSR|S_IXUSR, fdinfo),
         REG("environ",   S_IRUSR, environ),
         INF("auxv",      S_IRUSR, pid_auxv),
-        INF("status",    S_IRUGO, pid_status),
+        ONE("status",    S_IRUGO, pid_status),
         INF("limits",    S_IRUSR, pid_limits),
 #ifdef CONFIG_SCHED_DEBUG
         REG("sched",     S_IRUGO|S_IWUSR, pid_sched),
 #endif
         INF("cmdline",   S_IRUGO, pid_cmdline),
-        INF("stat",      S_IRUGO, tid_stat),
-        INF("statm",     S_IRUGO, pid_statm),
+        ONE("stat",      S_IRUGO, tid_stat),
+        ONE("statm",     S_IRUGO, pid_statm),
         REG("maps",      S_IRUGO, maps),
 #ifdef CONFIG_NUMA
         REG("numa_maps", S_IRUGO, numa_maps),
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 6a2fe5187b62..68971e66cd41 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -25,12 +25,6 @@
 
 #include "internal.h"
 
-static ssize_t proc_file_read(struct file *file, char __user *buf,
-                              size_t nbytes, loff_t *ppos);
-static ssize_t proc_file_write(struct file *file, const char __user *buffer,
-                               size_t count, loff_t *ppos);
-static loff_t proc_file_lseek(struct file *, loff_t, int);
-
 DEFINE_SPINLOCK(proc_subdir_lock);
 
 static int proc_match(int len, const char *name, struct proc_dir_entry *de)
@@ -40,12 +34,6 @@ static int proc_match(int len, const char *name, struct proc_dir_entry *de)
         return !memcmp(name, de->name, len);
 }
 
-static const struct file_operations proc_file_operations = {
-        .llseek         = proc_file_lseek,
-        .read           = proc_file_read,
-        .write          = proc_file_write,
-};
-
 /* buffer size is one page but our output routines use some slack for overruns */
 #define PROC_BLOCK_SIZE (PAGE_SIZE - 1024)
 
@@ -233,6 +221,12 @@ proc_file_lseek(struct file *file, loff_t offset, int orig)
         return retval;
 }
 
+static const struct file_operations proc_file_operations = {
+        .llseek         = proc_file_lseek,
+        .read           = proc_file_read,
+        .write          = proc_file_write,
+};
+
 static int proc_notify_change(struct dentry *dentry, struct iattr *iattr)
 {
         struct inode *inode = dentry->d_inode;
@@ -406,12 +400,12 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
                                 spin_unlock(&proc_subdir_lock);
                                 error = -EINVAL;
                                 inode = proc_get_inode(dir->i_sb, ino, de);
-                                spin_lock(&proc_subdir_lock);
-                                break;
+                                goto out_unlock;
                         }
                 }
         }
         spin_unlock(&proc_subdir_lock);
+out_unlock:
         unlock_kernel();
 
         if (inode) {
@@ -527,6 +521,7 @@ static const struct inode_operations proc_dir_inode_operations = {
 static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp)
 {
         unsigned int i;
+        struct proc_dir_entry *tmp;
         
         i = get_inode_number();
         if (i == 0)
@@ -550,6 +545,15 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
         }
 
         spin_lock(&proc_subdir_lock);
+
+        for (tmp = dir->subdir; tmp; tmp = tmp->next)
+                if (strcmp(tmp->name, dp->name) == 0) {
+                        printk(KERN_WARNING "proc_dir_entry '%s' already "
+                                        "registered\n", dp->name);
+                        dump_stack();
+                        break;
+                }
+
         dp->next = dir->subdir;
         dp->parent = dir;
         dir->subdir = dp;
@@ -558,7 +562,7 @@ static int proc_register(struct proc_dir_entry * dir, struct proc_dir_entry * dp
         return 0;
 }
 
-static struct proc_dir_entry *proc_create(struct proc_dir_entry **parent,
+static struct proc_dir_entry *__proc_create(struct proc_dir_entry **parent,
                                           const char *name,
                                           mode_t mode,
                                           nlink_t nlink)
@@ -601,7 +605,7 @@ struct proc_dir_entry *proc_symlink(const char *name,
 {
         struct proc_dir_entry *ent;
 
-        ent = proc_create(&parent,name,
+        ent = __proc_create(&parent, name,
                           (S_IFLNK | S_IRUGO | S_IWUGO | S_IXUGO),1);
 
         if (ent) {
@@ -626,7 +630,7 @@ struct proc_dir_entry *proc_mkdir_mode(const char *name, mode_t mode,
 {
         struct proc_dir_entry *ent;
 
-        ent = proc_create(&parent, name, S_IFDIR | mode, 2);
+        ent = __proc_create(&parent, name, S_IFDIR | mode, 2);
         if (ent) {
                 if (proc_register(parent, ent) < 0) {
                         kfree(ent);
@@ -660,7 +664,7 @@ struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
                 nlink = 1;
         }
 
-        ent = proc_create(&parent,name,mode,nlink);
+        ent = __proc_create(&parent, name, mode, nlink);
         if (ent) {
                 if (proc_register(parent, ent) < 0) {
                         kfree(ent);
@@ -670,6 +674,38 @@ struct proc_dir_entry *create_proc_entry(const char *name, mode_t mode,
         return ent;
 }
 
+struct proc_dir_entry *proc_create(const char *name, mode_t mode,
+                                   struct proc_dir_entry *parent,
+                                   const struct file_operations *proc_fops)
+{
+        struct proc_dir_entry *pde;
+        nlink_t nlink;
+
+        if (S_ISDIR(mode)) {
+                if ((mode & S_IALLUGO) == 0)
+                        mode |= S_IRUGO | S_IXUGO;
+                nlink = 2;
+        } else {
+                if ((mode & S_IFMT) == 0)
+                        mode |= S_IFREG;
+                if ((mode & S_IALLUGO) == 0)
+                        mode |= S_IRUGO;
+                nlink = 1;
+        }
+
+        pde = __proc_create(&parent, name, mode, nlink);
+        if (!pde)
+                goto out;
+        pde->proc_fops = proc_fops;
+        if (proc_register(parent, pde) < 0)
+                goto out_free;
+        return pde;
+out_free:
+        kfree(pde);
+out:
+        return NULL;
+}
+
 void free_proc_entry(struct proc_dir_entry *de)
 {
         unsigned int ino = de->low_ino;
@@ -679,7 +715,7 @@ void free_proc_entry(struct proc_dir_entry *de)
 
         release_inode_number(ino);
 
-        if (S_ISLNK(de->mode) && de->data)
+        if (S_ISLNK(de->mode))
                 kfree(de->data);
         kfree(de);
 }
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 6ecf6396f072..82b3a1b5a70b 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -467,4 +467,3 @@ out_no_root:
         de_put(&proc_root);
         return -ENOMEM;
 }
-MODULE_LICENSE("GPL");
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index 7d57e8069924..ea496ffeabe7 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -46,12 +46,17 @@ extern int nommu_vma_show(struct seq_file *, struct vm_area_struct *);
 
 extern int maps_protect;
 
-extern void create_seq_entry(char *name, mode_t mode, const struct file_operations *f);
+extern void create_seq_entry(char *name, mode_t mode,
+                                const struct file_operations *f);
 extern int proc_exe_link(struct inode *, struct dentry **, struct vfsmount **);
-extern int proc_tid_stat(struct task_struct *,  char *);
-extern int proc_tgid_stat(struct task_struct *, char *);
-extern int proc_pid_status(struct task_struct *, char *);
-extern int proc_pid_statm(struct task_struct *, char *);
+extern int proc_tid_stat(struct seq_file *m, struct pid_namespace *ns,
+                                struct pid *pid, struct task_struct *task);
+extern int proc_tgid_stat(struct seq_file *m, struct pid_namespace *ns,
+                                struct pid *pid, struct task_struct *task);
+extern int proc_pid_status(struct seq_file *m, struct pid_namespace *ns,
+                                struct pid *pid, struct task_struct *task);
+extern int proc_pid_statm(struct seq_file *m, struct pid_namespace *ns,
+                                struct pid *pid, struct task_struct *task);
 extern loff_t mem_lseek(struct file *file, loff_t offset, int orig);
 
 extern const struct file_operations proc_maps_operations;
diff --git a/fs/proc/kcore.c b/fs/proc/kcore.c
index 7dd26e18cbfd..e78c81fcf547 100644
--- a/fs/proc/kcore.c
+++ b/fs/proc/kcore.c
@@ -12,7 +12,6 @@
 #include <linux/mm.h>
 #include <linux/proc_fs.h>
 #include <linux/user.h>
-#include <linux/a.out.h>
 #include <linux/capability.h>
 #include <linux/elf.h>
 #include <linux/elfcore.h>
diff --git a/fs/proc/nommu.c b/fs/proc/nommu.c
index 22f789de3909..5d9147b9d738 100644
--- a/fs/proc/nommu.c
+++ b/fs/proc/nommu.c
@@ -116,7 +116,7 @@ static void *nommu_vma_list_next(struct seq_file *m, void *v, loff_t *pos)
         return rb_next((struct rb_node *) v);
 }
 
-static struct seq_operations proc_nommu_vma_list_seqop = {
+static const struct seq_operations proc_nommu_vma_list_seqop = {
         .start  = nommu_vma_list_start,
         .next   = nommu_vma_list_next,
         .stop   = nommu_vma_list_stop,
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 2686592dbcb2..468805d40e2b 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -222,7 +222,7 @@ static int meminfo_read_proc(char *page, char **start, off_t off,
 #undef K
 }
 
-extern struct seq_operations fragmentation_op;
+extern const struct seq_operations fragmentation_op;
 static int fragmentation_open(struct inode *inode, struct file *file)
 {
         (void)inode;
@@ -236,7 +236,7 @@ static const struct file_operations fragmentation_file_operations = {
         .release        = seq_release,
 };
 
-extern struct seq_operations pagetypeinfo_op;
+extern const struct seq_operations pagetypeinfo_op;
 static int pagetypeinfo_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &pagetypeinfo_op);
@@ -249,7 +249,7 @@ static const struct file_operations pagetypeinfo_file_ops = {
         .release        = seq_release,
 };
 
-extern struct seq_operations zoneinfo_op;
+extern const struct seq_operations zoneinfo_op;
 static int zoneinfo_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &zoneinfo_op);
@@ -274,7 +274,7 @@ static int version_read_proc(char *page, char **start, off_t off,
         return proc_calc_metrics(page, start, off, count, eof, len);
 }
 
-extern struct seq_operations cpuinfo_op;
+extern const struct seq_operations cpuinfo_op;
 static int cpuinfo_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &cpuinfo_op);
@@ -327,7 +327,7 @@ static void devinfo_stop(struct seq_file *f, void *v)
         /* Nothing to do */
 }
 
-static struct seq_operations devinfo_ops = {
+static const struct seq_operations devinfo_ops = {
         .start = devinfo_start,
         .next  = devinfo_next,
         .stop  = devinfo_stop,
@@ -346,7 +346,7 @@ static const struct file_operations proc_devinfo_operations = {
         .release        = seq_release,
 };
 
-extern struct seq_operations vmstat_op;
+extern const struct seq_operations vmstat_op;
 static int vmstat_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &vmstat_op);
@@ -377,7 +377,7 @@ static int stram_read_proc(char *page, char **start, off_t off,
 #endif
 
 #ifdef CONFIG_BLOCK
-extern struct seq_operations partitions_op;
+extern const struct seq_operations partitions_op;
 static int partitions_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &partitions_op);
@@ -389,7 +389,7 @@ static const struct file_operations proc_partitions_operations = {
         .release        = seq_release,
 };
 
-extern struct seq_operations diskstats_op;
+extern const struct seq_operations diskstats_op;
 static int diskstats_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &diskstats_op);
@@ -403,7 +403,7 @@ static const struct file_operations proc_diskstats_operations = {
 #endif
 
 #ifdef CONFIG_MODULES
-extern struct seq_operations modules_op;
+extern const struct seq_operations modules_op;
 static int modules_open(struct inode *inode, struct file *file)
 {
         return seq_open(file, &modules_op);
@@ -430,7 +430,7 @@ static const struct file_operations proc_slabinfo_operations = {
 };
 
 #ifdef CONFIG_DEBUG_SLAB_LEAK
-extern struct seq_operations slabstats_op;
+extern const struct seq_operations slabstats_op;
 static int slabstats_open(struct inode *inode, struct file *file)
 {
         unsigned long *n = kzalloc(PAGE_SIZE, GFP_KERNEL);
@@ -604,7 +604,7 @@ static void int_seq_stop(struct seq_file *f, void *v)
 }
 
 
-static struct seq_operations int_seq_ops = {
+static const struct seq_operations int_seq_ops = {
         .start = int_seq_start,
         .next  = int_seq_next,
         .stop  = int_seq_stop,
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index 4823c9677fac..14e9b5aaf863 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -67,12 +67,7 @@ EXPORT_SYMBOL_GPL(seq_release_net);
 struct proc_dir_entry *proc_net_fops_create(struct net *net,
         const char *name, mode_t mode, const struct file_operations *fops)
 {
-        struct proc_dir_entry *res;
-
-        res = create_proc_entry(name, mode, net->proc_net);
-        if (res)
-                res->proc_fops = fops;
-        return res;
+        return proc_create(name, mode, net->proc_net, fops);
 }
 EXPORT_SYMBOL_GPL(proc_net_fops_create);
 
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 4e57fcf85982..b9cb23c08f63 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -9,7 +9,7 @@
 
 static struct dentry_operations proc_sys_dentry_operations;
 static const struct file_operations proc_sys_file_operations;
-static struct inode_operations proc_sys_inode_operations;
+static const struct inode_operations proc_sys_inode_operations;
 
 static void proc_sys_refresh_inode(struct inode *inode, struct ctl_table *table)
 {
@@ -446,7 +446,7 @@ static const struct file_operations proc_sys_file_operations = {
         .readdir        = proc_sys_readdir,
 };
 
-static struct inode_operations proc_sys_inode_operations = {
+static const struct inode_operations proc_sys_inode_operations = {
         .lookup         = proc_sys_lookup,
         .permission     = proc_sys_permission,
         .setattr        = proc_sys_setattr,
diff --git a/fs/proc/proc_tty.c b/fs/proc/proc_tty.c
index 22846225acfa..49816e00b51a 100644
--- a/fs/proc/proc_tty.c
+++ b/fs/proc/proc_tty.c
@@ -15,9 +15,6 @@
 #include <linux/seq_file.h>
 #include <linux/bitops.h>
 
-static int tty_ldiscs_read_proc(char *page, char **start, off_t off,
-                                int count, int *eof, void *data);
-
 /*
  * The /proc/tty directory inodes...
  */
@@ -120,7 +117,7 @@ static void t_stop(struct seq_file *m, void *v)
         mutex_unlock(&tty_mutex);
 }
 
-static struct seq_operations tty_drivers_op = {
+static const struct seq_operations tty_drivers_op = {
         .start  = t_start,
         .next   = t_next,
         .stop   = t_stop,
diff --git a/fs/proc/root.c b/fs/proc/root.c
index 81f99e691f99..ef0fb57fc9ef 100644
--- a/fs/proc/root.c
+++ b/fs/proc/root.c
@@ -232,6 +232,7 @@ void pid_ns_release_proc(struct pid_namespace *ns)
 EXPORT_SYMBOL(proc_symlink);
 EXPORT_SYMBOL(proc_mkdir);
 EXPORT_SYMBOL(create_proc_entry);
+EXPORT_SYMBOL(proc_create);
 EXPORT_SYMBOL(remove_proc_entry);
 EXPORT_SYMBOL(proc_root);
 EXPORT_SYMBOL(proc_root_fs);
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 38338ed98cc6..ae4d3f2c8cb2 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -9,13 +9,14 @@
 #include <linux/mempolicy.h>
 #include <linux/swap.h>
 #include <linux/swapops.h>
+#include <linux/seq_file.h>
 
 #include <asm/elf.h>
 #include <asm/uaccess.h>
 #include <asm/tlbflush.h>
 #include "internal.h"
 
-char *task_mem(struct mm_struct *mm, char *buffer)
+void task_mem(struct seq_file *m, struct mm_struct *mm)
 {
         unsigned long data, text, lib;
         unsigned long hiwater_vm, total_vm, hiwater_rss, total_rss;
@@ -37,7 +38,7 @@ char *task_mem(struct mm_struct *mm, char *buffer)
         data = mm->total_vm - mm->shared_vm - mm->stack_vm;
         text = (PAGE_ALIGN(mm->end_code) - (mm->start_code & PAGE_MASK)) >> 10;
         lib = (mm->exec_vm << (PAGE_SHIFT-10)) - text;
-        buffer += sprintf(buffer,
+        seq_printf(m,
                 "VmPeak:\t%8lu kB\n"
                 "VmSize:\t%8lu kB\n"
                 "VmLck:\t%8lu kB\n"
@@ -56,7 +57,6 @@ char *task_mem(struct mm_struct *mm, char *buffer)
                 data << (PAGE_SHIFT-10),
                 mm->stack_vm << (PAGE_SHIFT-10), text, lib,
                 (PTRS_PER_PTE*sizeof(pte_t)*mm->nr_ptes) >> 10);
-        return buffer;
 }
 
 unsigned long task_vsize(struct mm_struct *mm)
@@ -216,7 +216,7 @@ static void m_stop(struct seq_file *m, void *v)
 }
 
 static int do_maps_open(struct inode *inode, struct file *file,
-                        struct seq_operations *ops)
+                        const struct seq_operations *ops)
 {
         struct proc_maps_private *priv;
         int ret = -ENOMEM;
@@ -299,7 +299,7 @@ static int show_map(struct seq_file *m, void *v)
         return 0;
 }
 
-static struct seq_operations proc_pid_maps_op = {
+static const struct seq_operations proc_pid_maps_op = {
         .start  = m_start,
         .next   = m_next,
         .stop   = m_stop,
@@ -434,7 +434,7 @@ static int show_smap(struct seq_file *m, void *v)
         return ret;
 }
 
-static struct seq_operations proc_pid_smaps_op = {
+static const struct seq_operations proc_pid_smaps_op = {
         .start  = m_start,
         .next   = m_next,
         .stop   = m_stop,
@@ -734,7 +734,7 @@ static int show_numa_map_checked(struct seq_file *m, void *v)
         return show_numa_map(m, v);
 }
 
-static struct seq_operations proc_pid_numa_maps_op = {
+static const struct seq_operations proc_pid_numa_maps_op = {
         .start  = m_start,
         .next   = m_next,
         .stop   = m_stop,
diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
index 1932c2ca3457..abfc6f5e56ca 100644
--- a/fs/proc/task_nommu.c
+++ b/fs/proc/task_nommu.c
@@ -12,7 +12,7 @@
  * each process that owns it. Non-shared memory is counted
  * accurately.
  */
-char *task_mem(struct mm_struct *mm, char *buffer)
+void task_mem(struct seq_file *m, struct mm_struct *mm)
 {
         struct vm_list_struct *vml;
         unsigned long bytes = 0, sbytes = 0, slack = 0;
@@ -58,14 +58,13 @@ char *task_mem(struct mm_struct *mm, char *buffer)
 
         bytes += kobjsize(current); /* includes kernel stack */
 
-        buffer += sprintf(buffer,
+        seq_printf(m,
                 "Mem:\t%8lu bytes\n"
                 "Slack:\t%8lu bytes\n"
                 "Shared:\t%8lu bytes\n",
                 bytes, slack, sbytes);
 
         up_read(&mm->mmap_sem);
-        return buffer;
 }
 
 unsigned long task_vsize(struct mm_struct *mm)
@@ -199,7 +198,7 @@ static void *m_next(struct seq_file *m, void *_vml, loff_t *pos)
         return vml ? vml->next : NULL;
 }
 
-static struct seq_operations proc_pid_maps_ops = {
+static const struct seq_operations proc_pid_maps_ops = {
         .start  = m_start,
         .next   = m_next,
         .stop   = m_stop,
diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c
index 523e1098ae88..9ac0f5e064e0 100644
--- a/fs/proc/vmcore.c
+++ b/fs/proc/vmcore.c
@@ -10,7 +10,6 @@
 #include <linux/mm.h>
 #include <linux/proc_fs.h>
 #include <linux/user.h>
-#include <linux/a.out.h>
 #include <linux/elf.h>
 #include <linux/elfcore.h>
 #include <linux/highmem.h>
diff --git a/fs/read_write.c b/fs/read_write.c
index 1c177f29e1b7..49a98718ecdf 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -366,7 +366,6 @@ asmlinkage ssize_t sys_read(unsigned int fd, char __user * buf, size_t count)
 
         return ret;
 }
-EXPORT_UNUSED_SYMBOL_GPL(sys_read); /* to be deleted for 2.6.25 */
 
 asmlinkage ssize_t sys_write(unsigned int fd, const char __user * buf, size_t count)
 {
diff --git a/fs/reiserfs/procfs.c b/fs/reiserfs/procfs.c
index 001144621672..8f86c52b30d8 100644
--- a/fs/reiserfs/procfs.c
+++ b/fs/reiserfs/procfs.c
@@ -444,7 +444,7 @@ static int r_show(struct seq_file *m, void *v)
         return show(m, v);
 }
 
-static struct seq_operations r_ops = {
+static const struct seq_operations r_ops = {
         .start = r_start,
         .next = r_next,
         .stop = r_stop,
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 5cd85fe5df5d..6033f0c3bd0b 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -617,6 +617,7 @@ static const struct super_operations reiserfs_sops = {
         .unlockfs = reiserfs_unlockfs,
         .statfs = reiserfs_statfs,
         .remount_fs = reiserfs_remount,
+        .show_options = generic_show_options,
 #ifdef CONFIG_QUOTA
         .quota_read = reiserfs_quota_read,
         .quota_write = reiserfs_quota_write,
@@ -1138,6 +1139,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
         unsigned long safe_mask = 0;
         unsigned int commit_max_age = (unsigned int)-1;
         struct reiserfs_journal *journal = SB_JOURNAL(s);
+        char *new_opts = kstrdup(arg, GFP_KERNEL);
         int err;
 #ifdef CONFIG_QUOTA
         int i;
@@ -1153,7 +1155,8 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
                         REISERFS_SB(s)->s_qf_names[i] = NULL;
                 }
 #endif
-                return -EINVAL;
+                err = -EINVAL;
+                goto out_err;
         }
 
         handle_attrs(s);
@@ -1191,9 +1194,9 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
         }
 
         if (blocks) {
-                int rc = reiserfs_resize(s, blocks);
-                if (rc != 0)
-                        return rc;
+                err = reiserfs_resize(s, blocks);
+                if (err != 0)
+                        goto out_err;
         }
 
         if (*mount_flags & MS_RDONLY) {
@@ -1201,16 +1204,16 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
                 /* remount read-only */
                 if (s->s_flags & MS_RDONLY)
                         /* it is read-only already */
-                        return 0;
+                        goto out_ok;
                 /* try to remount file system with read-only permissions */
                 if (sb_umount_state(rs) == REISERFS_VALID_FS
                     || REISERFS_SB(s)->s_mount_state != REISERFS_VALID_FS) {
-                        return 0;
+                        goto out_ok;
                 }
 
                 err = journal_begin(&th, s, 10);
                 if (err)
-                        return err;
+                        goto out_err;
 
                 /* Mounting a rw partition read-only. */
                 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
@@ -1220,11 +1223,13 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
                 /* remount read-write */
                 if (!(s->s_flags & MS_RDONLY)) {
                         reiserfs_xattr_init(s, *mount_flags);
-                        return 0;       /* We are read-write already */
+                        goto out_ok;    /* We are read-write already */
                 }
 
-                if (reiserfs_is_journal_aborted(journal))
-                        return journal->j_errno;
+                if (reiserfs_is_journal_aborted(journal)) {
+                        err = journal->j_errno;
+                        goto out_err;
+                }
 
                 handle_data_mode(s, mount_options);
                 handle_barrier_mode(s, mount_options);
@@ -1232,7 +1237,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
                 s->s_flags &= ~MS_RDONLY;       /* now it is safe to call journal_begin */
                 err = journal_begin(&th, s, 10);
                 if (err)
-                        return err;
+                        goto out_err;
 
                 /* Mount a partition which is read-only, read-write */
                 reiserfs_prepare_for_journal(s, SB_BUFFER_WITH_SB(s), 1);
@@ -1247,7 +1252,7 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
         SB_JOURNAL(s)->j_must_wait = 1;
         err = journal_end(&th, s, 10);
         if (err)
-                return err;
+                goto out_err;
         s->s_dirt = 0;
 
         if (!(*mount_flags & MS_RDONLY)) {
@@ -1255,7 +1260,14 @@ static int reiserfs_remount(struct super_block *s, int *mount_flags, char *arg)
                 reiserfs_xattr_init(s, *mount_flags);
         }
 
+out_ok:
+        kfree(s->s_options);
+        s->s_options = new_opts;
         return 0;
+
+out_err:
+        kfree(new_opts);
+        return err;
 }
 
 static int read_super_block(struct super_block *s, int offset)
@@ -1559,6 +1571,8 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
         struct reiserfs_sb_info *sbi;
         int errval = -EINVAL;
 
+        save_mount_options(s, data);
+
         sbi = kzalloc(sizeof(struct reiserfs_sb_info), GFP_KERNEL);
         if (!sbi) {
                 errval = -ENOMEM;
diff --git a/fs/splice.c b/fs/splice.c
index 4ee49e86edde..14e2262c0a04 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1179,6 +1179,9 @@ static int copy_from_user_mmap_sem(void *dst, const void __user *src, size_t n)
 {
         int partial;
 
+        if (!access_ok(VERIFY_READ, src, n))
+                return -EFAULT;
+
         pagefault_disable();
         partial = __copy_from_user_inatomic(dst, src, n);
         pagefault_enable();
@@ -1387,6 +1390,11 @@ static long vmsplice_to_user(struct file *file, const struct iovec __user *iov,
                         break;
                 }
 
+                if (unlikely(!access_ok(VERIFY_WRITE, base, len))) {
+                        error = -EFAULT;
+                        break;
+                }
+
                 sd.len = 0;
                 sd.total_len = len;
                 sd.flags = flags;
diff --git a/fs/super.c b/fs/super.c
index ceaf2e3d594c..88811f60c8de 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -105,6 +105,7 @@ static inline void destroy_super(struct super_block *s)
 {
         security_sb_free(s);
         kfree(s->s_subtype);
+        kfree(s->s_options);
         kfree(s);
 }
 
@@ -603,6 +604,7 @@ int do_remount_sb(struct super_block *sb, int flags, void *data, int force)
                         mark_files_ro(sb);
                 else if (!fs_may_remount_ro(sb))
                         return -EBUSY;
+                DQUOT_OFF(sb);
         }
 
         if (sb->s_op->remount_fs) {
diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
index ab26176f6b91..d721a1af1972 100644
--- a/fs/udf/balloc.c
+++ b/fs/udf/balloc.c
@@ -28,15 +28,16 @@
 #include "udf_i.h"
 #include "udf_sb.h"
 
-#define udf_clear_bit(nr,addr) ext2_clear_bit(nr,addr)
-#define udf_set_bit(nr,addr) ext2_set_bit(nr,addr)
+#define udf_clear_bit(nr, addr) ext2_clear_bit(nr, addr)
+#define udf_set_bit(nr, addr) ext2_set_bit(nr, addr)
 #define udf_test_bit(nr, addr) ext2_test_bit(nr, addr)
 #define udf_find_first_one_bit(addr, size) find_first_one_bit(addr, size)
-#define udf_find_next_one_bit(addr, size, offset) find_next_one_bit(addr, size, offset)
+#define udf_find_next_one_bit(addr, size, offset) \
+                find_next_one_bit(addr, size, offset)
 
 #define leBPL_to_cpup(x) leNUM_to_cpup(BITS_PER_LONG, x)
-#define leNUM_to_cpup(x,y) xleNUM_to_cpup(x,y)
-#define xleNUM_to_cpup(x,y) (le ## x ## _to_cpup(y))
+#define leNUM_to_cpup(x, y) xleNUM_to_cpup(x, y)
+#define xleNUM_to_cpup(x, y) (le ## x ## _to_cpup(y))
 #define uintBPL_t uint(BITS_PER_LONG)
 #define uint(x) xuint(x)
 #define xuint(x) __le ## x
@@ -62,7 +63,8 @@ static inline int find_next_one_bit(void *addr, int size, int offset)
                 result += BITS_PER_LONG;
         }
         while (size & ~(BITS_PER_LONG - 1)) {
-                if ((tmp = leBPL_to_cpup(p++)))
+                tmp = leBPL_to_cpup(p++);
+                if (tmp)
                         goto found_middle;
                 result += BITS_PER_LONG;
                 size -= BITS_PER_LONG;
@@ -88,12 +90,12 @@ static int read_block_bitmap(struct super_block *sb,
         kernel_lb_addr loc;
 
         loc.logicalBlockNum = bitmap->s_extPosition;
-        loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
+        loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
 
         bh = udf_tread(sb, udf_get_lb_pblock(sb, loc, block));
-        if (!bh) {
+        if (!bh)
                 retval = -EIO;
-        }
+
         bitmap->s_block_bitmap[bitmap_nr] = bh;
         return retval;
 }
@@ -138,6 +140,20 @@ static inline int load_block_bitmap(struct super_block *sb,
         return slot;
 }
 
+static bool udf_add_free_space(struct udf_sb_info *sbi,
+                                u16 partition, u32 cnt)
+{
+        struct logicalVolIntegrityDesc *lvid;
+
+        if (sbi->s_lvid_bh)
+                return false;
+
+        lvid = (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
+        lvid->freeSpaceTable[partition] = cpu_to_le32(le32_to_cpu(
+                                        lvid->freeSpaceTable[partition]) + cnt);
+        return true;
+}
+
 static void udf_bitmap_free_blocks(struct super_block *sb,
                                    struct inode *inode,
                                    struct udf_bitmap *bitmap,
@@ -155,57 +171,58 @@ static void udf_bitmap_free_blocks(struct super_block *sb,
 
         mutex_lock(&sbi->s_alloc_mutex);
         if (bloc.logicalBlockNum < 0 ||
-            (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
+            (bloc.logicalBlockNum + count) >
+                sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {
                 udf_debug("%d < %d || %d + %d > %d\n",
                           bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
-                          UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
+                          sbi->s_partmaps[bloc.partitionReferenceNum].
+                                                        s_partition_len);
                 goto error_return;
         }
 
-        block = bloc.logicalBlockNum + offset + (sizeof(struct spaceBitmapDesc) << 3);
+        block = bloc.logicalBlockNum + offset +
+                (sizeof(struct spaceBitmapDesc) << 3);
 
-do_more:
-        overflow = 0;
-        block_group = block >> (sb->s_blocksize_bits + 3);
-        bit = block % (sb->s_blocksize << 3);
+        do {
+                overflow = 0;
+                block_group = block >> (sb->s_blocksize_bits + 3);
+                bit = block % (sb->s_blocksize << 3);
 
-        /*
-         * Check to see if we are freeing blocks across a group boundary.
-         */
-        if (bit + count > (sb->s_blocksize << 3)) {
-                overflow = bit + count - (sb->s_blocksize << 3);
-                count -= overflow;
-        }
-        bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
-        if (bitmap_nr < 0)
-                goto error_return;
+                /*
+                * Check to see if we are freeing blocks across a group boundary.
+                */
+                if (bit + count > (sb->s_blocksize << 3)) {
+                        overflow = bit + count - (sb->s_blocksize << 3);
+                        count -= overflow;
+                }
+                bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
+                if (bitmap_nr < 0)
+                        goto error_return;
 
-        bh = bitmap->s_block_bitmap[bitmap_nr];
-        for (i = 0; i < count; i++) {
-                if (udf_set_bit(bit + i, bh->b_data)) {
-                        udf_debug("bit %ld already set\n", bit + i);
-                        udf_debug("byte=%2x\n", ((char *)bh->b_data)[(bit + i) >> 3]);
-                } else {
-                        if (inode)
-                                DQUOT_FREE_BLOCK(inode, 1);
-                        if (UDF_SB_LVIDBH(sb)) {
-                                UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
-                                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + 1);
+                bh = bitmap->s_block_bitmap[bitmap_nr];
+                for (i = 0; i < count; i++) {
+                        if (udf_set_bit(bit + i, bh->b_data)) {
+                                udf_debug("bit %ld already set\n", bit + i);
+                                udf_debug("byte=%2x\n",
+                                        ((char *)bh->b_data)[(bit + i) >> 3]);
+                        } else {
+                                if (inode)
+                                        DQUOT_FREE_BLOCK(inode, 1);
+                                udf_add_free_space(sbi, sbi->s_partition, 1);
                         }
                 }
-        }
-        mark_buffer_dirty(bh);
-        if (overflow) {
-                block += count;
-                count = overflow;
-                goto do_more;
-        }
+                mark_buffer_dirty(bh);
+                if (overflow) {
+                        block += count;
+                        count = overflow;
+                }
+        } while (overflow);
+
 error_return:
         sb->s_dirt = 1;
-        if (UDF_SB_LVIDBH(sb))
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
+        if (sbi->s_lvid_bh)
+                mark_buffer_dirty(sbi->s_lvid_bh);
         mutex_unlock(&sbi->s_alloc_mutex);
-        return;
 }
 
 static int udf_bitmap_prealloc_blocks(struct super_block *sb,
@@ -219,53 +236,50 @@ static int udf_bitmap_prealloc_blocks(struct super_block *sb,
         int bit, block, block_group, group_start;
         int nr_groups, bitmap_nr;
         struct buffer_head *bh;
+        __u32 part_len;
 
         mutex_lock(&sbi->s_alloc_mutex);
-        if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
+        part_len = sbi->s_partmaps[partition].s_partition_len;
+        if (first_block < 0 || first_block >= part_len)
                 goto out;
 
-        if (first_block + block_count > UDF_SB_PARTLEN(sb, partition))
-                block_count = UDF_SB_PARTLEN(sb, partition) - first_block;
+        if (first_block + block_count > part_len)
+                block_count = part_len - first_block;
 
-repeat:
-        nr_groups = (UDF_SB_PARTLEN(sb, partition) +
-                     (sizeof(struct spaceBitmapDesc) << 3) +
-                     (sb->s_blocksize * 8) - 1) / (sb->s_blocksize * 8);
-        block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
-        block_group = block >> (sb->s_blocksize_bits + 3);
-        group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
+        do {
+                nr_groups = udf_compute_nr_groups(sb, partition);
+                block = first_block + (sizeof(struct spaceBitmapDesc) << 3);
+                block_group = block >> (sb->s_blocksize_bits + 3);
+                group_start = block_group ? 0 : sizeof(struct spaceBitmapDesc);
 
-        bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
-        if (bitmap_nr < 0)
-                goto out;
-        bh = bitmap->s_block_bitmap[bitmap_nr];
+                bitmap_nr = load_block_bitmap(sb, bitmap, block_group);
+                if (bitmap_nr < 0)
+                        goto out;
+                bh = bitmap->s_block_bitmap[bitmap_nr];
 
-        bit = block % (sb->s_blocksize << 3);
+                bit = block % (sb->s_blocksize << 3);
 
-        while (bit < (sb->s_blocksize << 3) && block_count > 0) {
-                if (!udf_test_bit(bit, bh->b_data)) {
-                        goto out;
-                } else if (DQUOT_PREALLOC_BLOCK(inode, 1)) {
-                        goto out;
-                } else if (!udf_clear_bit(bit, bh->b_data)) {
-                        udf_debug("bit already cleared for block %d\n", bit);
-                        DQUOT_FREE_BLOCK(inode, 1);
-                        goto out;
+                while (bit < (sb->s_blocksize << 3) && block_count > 0) {
+                        if (!udf_test_bit(bit, bh->b_data))
+                                goto out;
+                        else if (DQUOT_PREALLOC_BLOCK(inode, 1))
+                                goto out;
+                        else if (!udf_clear_bit(bit, bh->b_data)) {
+                                udf_debug("bit already cleared for block %d\n", bit);
+                                DQUOT_FREE_BLOCK(inode, 1);
+                                goto out;
+                        }
+                        block_count--;
+                        alloc_count++;
+                        bit++;
+                        block++;
                 }
-                block_count--;
-                alloc_count++;
-                bit++;
-                block++;
-        }
-        mark_buffer_dirty(bh);
-        if (block_count > 0)
-                goto repeat;
+                mark_buffer_dirty(bh);
+        } while (block_count > 0);
+
 out:
-        if (UDF_SB_LVIDBH(sb)) {
-                UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
-        }
+        if (udf_add_free_space(sbi, partition, -alloc_count))
+                mark_buffer_dirty(sbi->s_lvid_bh);
         sb->s_dirt = 1;
         mutex_unlock(&sbi->s_alloc_mutex);
         return alloc_count;
@@ -287,7 +301,7 @@ static int udf_bitmap_new_block(struct super_block *sb,
         mutex_lock(&sbi->s_alloc_mutex);
 
 repeat:
-        if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
+        if (goal < 0 || goal >= sbi->s_partmaps[partition].s_partition_len)
                 goal = 0;
 
         nr_groups = bitmap->s_nr_groups;
@@ -312,14 +326,16 @@ repeat:
                 if (bit < end_goal)
                         goto got_block;
 
-                ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF, sb->s_blocksize - ((bit + 7) >> 3));
+                ptr = memscan((char *)bh->b_data + (bit >> 3), 0xFF,
+                              sb->s_blocksize - ((bit + 7) >> 3));
                 newbit = (ptr - ((char *)bh->b_data)) << 3;
                 if (newbit < sb->s_blocksize << 3) {
                         bit = newbit;
                         goto search_back;
                 }
 
-                newbit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, bit);
+                newbit = udf_find_next_one_bit(bh->b_data,
+                                               sb->s_blocksize << 3, bit);
                 if (newbit < sb->s_blocksize << 3) {
                         bit = newbit;
                         goto got_block;
@@ -358,15 +374,20 @@ repeat:
         if (bit < sb->s_blocksize << 3)
                 goto search_back;
         else
-                bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3, group_start << 3);
+                bit = udf_find_next_one_bit(bh->b_data, sb->s_blocksize << 3,
+                                            group_start << 3);
         if (bit >= sb->s_blocksize << 3) {
                 mutex_unlock(&sbi->s_alloc_mutex);
                 return 0;
         }
 
 search_back:
-        for (i = 0; i < 7 && bit > (group_start << 3) && udf_test_bit(bit - 1, bh->b_data); i++, bit--)
-                ; /* empty loop */
+        i = 0;
+        while (i < 7 && bit > (group_start << 3) &&
+               udf_test_bit(bit - 1, bh->b_data)) {
+                ++i;
+                --bit;
+        }
 
 got_block:
 
@@ -389,11 +410,8 @@ got_block:
 
         mark_buffer_dirty(bh);
 
-        if (UDF_SB_LVIDBH(sb)) {
-                UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
-        }
+        if (udf_add_free_space(sbi, partition, -1))
+                mark_buffer_dirty(sbi->s_lvid_bh);
         sb->s_dirt = 1;
         mutex_unlock(&sbi->s_alloc_mutex);
         *err = 0;
@@ -418,56 +436,70 @@ static void udf_table_free_blocks(struct super_block *sb,
         struct extent_position oepos, epos;
         int8_t etype;
         int i;
+        struct udf_inode_info *iinfo;
 
         mutex_lock(&sbi->s_alloc_mutex);
         if (bloc.logicalBlockNum < 0 ||
-            (bloc.logicalBlockNum + count) > UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum)) {
+            (bloc.logicalBlockNum + count) >
+                sbi->s_partmaps[bloc.partitionReferenceNum].s_partition_len) {
                 udf_debug("%d < %d || %d + %d > %d\n",
                           bloc.logicalBlockNum, 0, bloc.logicalBlockNum, count,
-                          UDF_SB_PARTLEN(sb, bloc.partitionReferenceNum));
+                          sbi->s_partmaps[bloc.partitionReferenceNum].
+                                                        s_partition_len);
                 goto error_return;
         }
 
-        /* We do this up front - There are some error conditions that could occure,
-           but.. oh well */
+        iinfo = UDF_I(table);
+        /* We do this up front - There are some error conditions that
+           could occure, but.. oh well */
         if (inode)
                 DQUOT_FREE_BLOCK(inode, count);
-        if (UDF_SB_LVIDBH(sb)) {
-                UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)] =
-                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]) + count);
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
-        }
+        if (udf_add_free_space(sbi, sbi->s_partition, count))
+                mark_buffer_dirty(sbi->s_lvid_bh);
 
         start = bloc.logicalBlockNum + offset;
         end = bloc.logicalBlockNum + offset + count - 1;
 
         epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
         elen = 0;
-        epos.block = oepos.block = UDF_I_LOCATION(table);
+        epos.block = oepos.block = iinfo->i_location;
         epos.bh = oepos.bh = NULL;
 
         while (count &&
                (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
-                if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) == start)) {
-                        if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) {
-                                count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
-                                start += ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
-                                elen = (etype << 30) | (0x40000000 - sb->s_blocksize);
+                if (((eloc.logicalBlockNum +
+                        (elen >> sb->s_blocksize_bits)) == start)) {
+                        if ((0x3FFFFFFF - elen) <
+                                        (count << sb->s_blocksize_bits)) {
+                                uint32_t tmp = ((0x3FFFFFFF - elen) >>
+                                                        sb->s_blocksize_bits);
+                                count -= tmp;
+                                start += tmp;
+                                elen = (etype << 30) |
+                                        (0x40000000 - sb->s_blocksize);
                         } else {
-                                elen = (etype << 30) | (elen + (count << sb->s_blocksize_bits));
+                                elen = (etype << 30) |
+                                        (elen +
+                                        (count << sb->s_blocksize_bits));
                                 start += count;
                                 count = 0;
                         }
                         udf_write_aext(table, &oepos, eloc, elen, 1);
                 } else if (eloc.logicalBlockNum == (end + 1)) {
-                        if ((0x3FFFFFFF - elen) < (count << sb->s_blocksize_bits)) {
-                                count -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
-                                end -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
-                                eloc.logicalBlockNum -= ((0x3FFFFFFF - elen) >> sb->s_blocksize_bits);
-                                elen = (etype << 30) | (0x40000000 - sb->s_blocksize);
+                        if ((0x3FFFFFFF - elen) <
+                                        (count << sb->s_blocksize_bits)) {
+                                uint32_t tmp = ((0x3FFFFFFF - elen) >>
+                                                sb->s_blocksize_bits);
+                                count -= tmp;
+                                end -= tmp;
+                                eloc.logicalBlockNum -= tmp;
+                                elen = (etype << 30) |
+                                        (0x40000000 - sb->s_blocksize);
                         } else {
                                 eloc.logicalBlockNum = start;
-                                elen = (etype << 30) | (elen + (count << sb->s_blocksize_bits));
+                                elen = (etype << 30) |
+                                        (elen +
+                                        (count << sb->s_blocksize_bits));
                                 end -= count;
                                 count = 0;
                         }
@@ -488,9 +520,9 @@ static void udf_table_free_blocks(struct super_block *sb,
 
         if (count) {
                 /*
-                 * NOTE: we CANNOT use udf_add_aext here, as it can try to allocate
-                 * a new block, and since we hold the super block lock already
-                 * very bad things would happen :)
+                 * NOTE: we CANNOT use udf_add_aext here, as it can try to
+                 * allocate a new block, and since we hold the super block
+                 * lock already very bad things would happen :)
                  *
                  * We copy the behavior of udf_add_aext, but instead of
                  * trying to allocate a new block close to the existing one,
@@ -509,11 +541,11 @@ static void udf_table_free_blocks(struct super_block *sb,
                 elen = EXT_RECORDED_ALLOCATED |
                         (count << sb->s_blocksize_bits);
 
-                if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT) {
+                if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                         adsize = sizeof(short_ad);
-                } else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG) {
+                else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                         adsize = sizeof(long_ad);
-                } else {
+                else {
                         brelse(oepos.bh);
                         brelse(epos.bh);
                         goto error_return;
@@ -531,56 +563,70 @@ static void udf_table_free_blocks(struct super_block *sb,
                         eloc.logicalBlockNum++;
                         elen -= sb->s_blocksize;
 
-                        if (!(epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, epos.block, 0)))) {
+                        epos.bh = udf_tread(sb,
+                                        udf_get_lb_pblock(sb, epos.block, 0));
+                        if (!epos.bh) {
                                 brelse(oepos.bh);
                                 goto error_return;
                         }
                         aed = (struct allocExtDesc *)(epos.bh->b_data);
-                        aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);
+                        aed->previousAllocExtLocation =
+                                cpu_to_le32(oepos.block.logicalBlockNum);
                         if (epos.offset + adsize > sb->s_blocksize) {
                                 loffset = epos.offset;
                                 aed->lengthAllocDescs = cpu_to_le32(adsize);
-                                sptr = UDF_I_DATA(table) + epos.offset - adsize;
-                                dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
+                                sptr = iinfo->i_ext.i_data + epos.offset
+                                                                - adsize;
+                                dptr = epos.bh->b_data +
+                                        sizeof(struct allocExtDesc);
                                 memcpy(dptr, sptr, adsize);
-                                epos.offset = sizeof(struct allocExtDesc) + adsize;
+                                epos.offset = sizeof(struct allocExtDesc) +
+                                                adsize;
                         } else {
                                 loffset = epos.offset + adsize;
                                 aed->lengthAllocDescs = cpu_to_le32(0);
                                 if (oepos.bh) {
                                         sptr = oepos.bh->b_data + epos.offset;
-                                        aed = (struct allocExtDesc *)oepos.bh->b_data;
+                                        aed = (struct allocExtDesc *)
+                                                oepos.bh->b_data;
                                         aed->lengthAllocDescs =
-                                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
+                                                cpu_to_le32(le32_to_cpu(
+                                                        aed->lengthAllocDescs) +
+                                                                adsize);
                                 } else {
-                                        sptr = UDF_I_DATA(table) + epos.offset;
-                                        UDF_I_LENALLOC(table) += adsize;
+                                        sptr = iinfo->i_ext.i_data +
+                                                                epos.offset;
+                                        iinfo->i_lenAlloc += adsize;
                                         mark_inode_dirty(table);
                                 }
                                 epos.offset = sizeof(struct allocExtDesc);
                         }
-                        if (UDF_SB_UDFREV(sb) >= 0x0200)
-                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
-                                            epos.block.logicalBlockNum, sizeof(tag));
+                        if (sbi->s_udfrev >= 0x0200)
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
+                                            3, 1, epos.block.logicalBlockNum,
+                                            sizeof(tag));
                         else
-                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,
-                                            epos.block.logicalBlockNum, sizeof(tag));
-
-                        switch (UDF_I_ALLOCTYPE(table)) {
-                                case ICBTAG_FLAG_AD_SHORT:
-                                        sad = (short_ad *)sptr;
-                                        sad->extLength = cpu_to_le32(
-                                                EXT_NEXT_EXTENT_ALLOCDECS |
-                                                sb->s_blocksize);
-                                        sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);
-                                        break;
-                                case ICBTAG_FLAG_AD_LONG:
-                                        lad = (long_ad *)sptr;
-                                        lad->extLength = cpu_to_le32(
-                                                EXT_NEXT_EXTENT_ALLOCDECS |
-                                                sb->s_blocksize);
-                                        lad->extLocation = cpu_to_lelb(epos.block);
-                                        break;
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED,
+                                            2, 1, epos.block.logicalBlockNum,
+                                            sizeof(tag));
+
+                        switch (iinfo->i_alloc_type) {
+                        case ICBTAG_FLAG_AD_SHORT:
+                                sad = (short_ad *)sptr;
+                                sad->extLength = cpu_to_le32(
+                                        EXT_NEXT_EXTENT_ALLOCDECS |
+                                        sb->s_blocksize);
+                                sad->extPosition =
+                                        cpu_to_le32(epos.block.logicalBlockNum);
+                                break;
+                        case ICBTAG_FLAG_AD_LONG:
+                                lad = (long_ad *)sptr;
+                                lad->extLength = cpu_to_le32(
+                                        EXT_NEXT_EXTENT_ALLOCDECS |
+                                        sb->s_blocksize);
+                                lad->extLocation =
+                                        cpu_to_lelb(epos.block);
+                                break;
                         }
                         if (oepos.bh) {
                                 udf_update_tag(oepos.bh->b_data, loffset);
@@ -590,16 +636,18 @@ static void udf_table_free_blocks(struct super_block *sb,
                         }
                 }
 
-                if (elen) { /* It's possible that stealing the block emptied the extent */
+                /* It's possible that stealing the block emptied the extent */
+                if (elen) {
                         udf_write_aext(table, &epos, eloc, elen, 1);
 
                         if (!epos.bh) {
-                                UDF_I_LENALLOC(table) += adsize;
+                                iinfo->i_lenAlloc += adsize;
                                 mark_inode_dirty(table);
                         } else {
                                 aed = (struct allocExtDesc *)epos.bh->b_data;
                                 aed->lengthAllocDescs =
-                                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
+                                        cpu_to_le32(le32_to_cpu(
+                                            aed->lengthAllocDescs) + adsize);
                                 udf_update_tag(epos.bh->b_data, epos.offset);
                                 mark_buffer_dirty(epos.bh);
                         }
@@ -626,20 +674,23 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
         kernel_lb_addr eloc;
         struct extent_position epos;
         int8_t etype = -1;
+        struct udf_inode_info *iinfo;
 
-        if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
+        if (first_block < 0 ||
+                first_block >= sbi->s_partmaps[partition].s_partition_len)
                 return 0;
 
-        if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
+        iinfo = UDF_I(table);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 return 0;
 
         mutex_lock(&sbi->s_alloc_mutex);
         epos.offset = sizeof(struct unallocSpaceEntry);
-        epos.block = UDF_I_LOCATION(table);
+        epos.block = iinfo->i_location;
         epos.bh = NULL;
         eloc.logicalBlockNum = 0xFFFFFFFF;
 
@@ -654,26 +705,26 @@ static int udf_table_prealloc_blocks(struct super_block *sb,
                 epos.offset -= adsize;
 
                 alloc_count = (elen >> sb->s_blocksize_bits);
-                if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count)) {
+                if (inode && DQUOT_PREALLOC_BLOCK(inode,
+                        alloc_count > block_count ? block_count : alloc_count))
                         alloc_count = 0;
-                } else if (alloc_count > block_count) {
+                else if (alloc_count > block_count) {
                         alloc_count = block_count;
                         eloc.logicalBlockNum += alloc_count;
                         elen -= (alloc_count << sb->s_blocksize_bits);
-                        udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1);
-                } else {
-                        udf_delete_aext(table, epos, eloc, (etype << 30) | elen);
-                }
+                        udf_write_aext(table, &epos, eloc,
+                                        (etype << 30) | elen, 1);
+                } else
+                        udf_delete_aext(table, epos, eloc,
+                                        (etype << 30) | elen);
         } else {
                 alloc_count = 0;
         }
 
         brelse(epos.bh);
 
-        if (alloc_count && UDF_SB_LVIDBH(sb)) {
-                UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - alloc_count);
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
+        if (alloc_count && udf_add_free_space(sbi, partition, -alloc_count)) {
+                mark_buffer_dirty(sbi->s_lvid_bh);
                 sb->s_dirt = 1;
         }
         mutex_unlock(&sbi->s_alloc_mutex);
@@ -692,33 +743,35 @@ static int udf_table_new_block(struct super_block *sb,
         kernel_lb_addr eloc, uninitialized_var(goal_eloc);
         struct extent_position epos, goal_epos;
         int8_t etype;
+        struct udf_inode_info *iinfo = UDF_I(table);
 
         *err = -ENOSPC;
 
-        if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(table) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 return newblock;
 
         mutex_lock(&sbi->s_alloc_mutex);
-        if (goal < 0 || goal >= UDF_SB_PARTLEN(sb, partition))
+        if (goal < 0 || goal >= sbi->s_partmaps[partition].s_partition_len)
                 goal = 0;
 
-        /* We search for the closest matching block to goal. If we find a exact hit,
-           we stop. Otherwise we keep going till we run out of extents.
-           We store the buffer_head, bloc, and extoffset of the current closest
-           match and use that when we are done.
+        /* We search for the closest matching block to goal. If we find
+           a exact hit, we stop. Otherwise we keep going till we run out
+           of extents. We store the buffer_head, bloc, and extoffset
+           of the current closest match and use that when we are done.
          */
         epos.offset = sizeof(struct unallocSpaceEntry);
-        epos.block = UDF_I_LOCATION(table);
+        epos.block = iinfo->i_location;
         epos.bh = goal_epos.bh = NULL;
 
         while (spread &&
                (etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
                 if (goal >= eloc.logicalBlockNum) {
-                        if (goal < eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits))
+                        if (goal < eloc.logicalBlockNum +
+                                        (elen >> sb->s_blocksize_bits))
                                 nspread = 0;
                         else
                                 nspread = goal - eloc.logicalBlockNum -
@@ -771,11 +824,8 @@ static int udf_table_new_block(struct super_block *sb,
                 udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
         brelse(goal_epos.bh);
 
-        if (UDF_SB_LVIDBH(sb)) {
-                UDF_SB_LVID(sb)->freeSpaceTable[partition] =
-                        cpu_to_le32(le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[partition]) - 1);
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
-        }
+        if (udf_add_free_space(sbi, partition, -1))
+                mark_buffer_dirty(sbi->s_lvid_bh);
 
         sb->s_dirt = 1;
         mutex_unlock(&sbi->s_alloc_mutex);
@@ -789,22 +839,23 @@ inline void udf_free_blocks(struct super_block *sb,
                             uint32_t count)
 {
         uint16_t partition = bloc.partitionReferenceNum;
+        struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
 
-        if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
+        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
                 return udf_bitmap_free_blocks(sb, inode,
-                                              UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
+                                              map->s_uspace.s_bitmap,
                                               bloc, offset, count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
+        } else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
                 return udf_table_free_blocks(sb, inode,
-                                             UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
+                                             map->s_uspace.s_table,
                                              bloc, offset, count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
+        } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
                 return udf_bitmap_free_blocks(sb, inode,
-                                              UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
+                                              map->s_fspace.s_bitmap,
                                               bloc, offset, count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
+        } else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
                 return udf_table_free_blocks(sb, inode,
-                                             UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
+                                             map->s_fspace.s_table,
                                              bloc, offset, count);
         } else {
                 return;
@@ -816,51 +867,55 @@ inline int udf_prealloc_blocks(struct super_block *sb,
                                uint16_t partition, uint32_t first_block,
                                uint32_t block_count)
 {
-        if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
+        struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
+
+        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
                 return udf_bitmap_prealloc_blocks(sb, inode,
-                                                  UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
-                                                  partition, first_block, block_count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
+                                                  map->s_uspace.s_bitmap,
+                                                  partition, first_block,
+                                                  block_count);
+        else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
                 return udf_table_prealloc_blocks(sb, inode,
-                                                 UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
-                                                 partition, first_block, block_count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
+                                                 map->s_uspace.s_table,
+                                                 partition, first_block,
+                                                 block_count);
+        else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
                 return udf_bitmap_prealloc_blocks(sb, inode,
-                                                  UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
-                                                  partition, first_block, block_count);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
+                                                  map->s_fspace.s_bitmap,
+                                                  partition, first_block,
+                                                  block_count);
+        else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
                 return udf_table_prealloc_blocks(sb, inode,
-                                                 UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
-                                                 partition, first_block, block_count);
-        } else {
+                                                 map->s_fspace.s_table,
+                                                 partition, first_block,
+                                                 block_count);
+        else
                 return 0;
-        }
 }
 
 inline int udf_new_block(struct super_block *sb,
                          struct inode *inode,
                          uint16_t partition, uint32_t goal, int *err)
 {
-        int ret;
+        struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
 
-        if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP) {
-                ret = udf_bitmap_new_block(sb, inode,
-                                           UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
+        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
+                return udf_bitmap_new_block(sb, inode,
+                                           map->s_uspace.s_bitmap,
                                            partition, goal, err);
-                return ret;
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE) {
+        else if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
                 return udf_table_new_block(sb, inode,
-                                           UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_table,
+                                           map->s_uspace.s_table,
                                            partition, goal, err);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_BITMAP) {
+        else if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
                 return udf_bitmap_new_block(sb, inode,
-                                            UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_bitmap,
+                                            map->s_fspace.s_bitmap,
                                             partition, goal, err);
-        } else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_FREED_TABLE) {
+        else if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
                 return udf_table_new_block(sb, inode,
-                                           UDF_SB_PARTMAPS(sb)[partition].s_fspace.s_table,
+                                           map->s_fspace.s_table,
                                            partition, goal, err);
-        } else {
+        else {
                 *err = -EIO;
                 return 0;
         }
diff --git a/fs/udf/crc.c b/fs/udf/crc.c
index 85aaee5fab26..b1661296e786 100644
--- a/fs/udf/crc.c
+++ b/fs/udf/crc.c
@@ -79,7 +79,7 @@ static uint16_t crc_table[256] = {
  *      July 21, 1997 - Andrew E. Mileski
  *      Adapted from OSTA-UDF(tm) 1.50 standard.
  */
-uint16_t udf_crc(uint8_t * data, uint32_t size, uint16_t crc)
+uint16_t udf_crc(uint8_t *data, uint32_t size, uint16_t crc)
 {
         while (size--)
                 crc = crc_table[(crc >> 8 ^ *(data++)) & 0xffU] ^ (crc << 8);
diff --git a/fs/udf/dir.c b/fs/udf/dir.c
index 9e3b9f97ddbc..4b44e23caa12 100644
--- a/fs/udf/dir.c
+++ b/fs/udf/dir.c
@@ -36,68 +36,8 @@
 #include "udf_i.h"
 #include "udf_sb.h"
 
-/* Prototypes for file operations */
-static int udf_readdir(struct file *, void *, filldir_t);
-static int do_udf_readdir(struct inode *, struct file *, filldir_t, void *);
-
-/* readdir and lookup functions */
-
-const struct file_operations udf_dir_operations = {
-        .read                   = generic_read_dir,
-        .readdir                = udf_readdir,
-        .ioctl                  = udf_ioctl,
-        .fsync                  = udf_fsync_file,
-};
-
-/*
- * udf_readdir
- *
- * PURPOSE
- *      Read a directory entry.
- *
- * DESCRIPTION
- *      Optional - sys_getdents() will return -ENOTDIR if this routine is not
- *      available.
- *
- *      Refer to sys_getdents() in fs/readdir.c
- *      sys_getdents() -> .
- *
- * PRE-CONDITIONS
- *      filp                    Pointer to directory file.
- *      buf                     Pointer to directory entry buffer.
- *      filldir                 Pointer to filldir function.
- *
- * POST-CONDITIONS
- *      <return>                >=0 on success.
- *
- * HISTORY
- *      July 1, 1997 - Andrew E. Mileski
- *      Written, tested, and released.
- */
-
-int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
-{
-        struct inode *dir = filp->f_path.dentry->d_inode;
-        int result;
-
-        lock_kernel();
-
-        if (filp->f_pos == 0) {
-                if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) < 0) {
-                        unlock_kernel();
-                        return 0;
-                }
-                filp->f_pos++;
-        }
-
-        result = do_udf_readdir(dir, filp, filldir, dirent);
-        unlock_kernel();
-        return result;
-}
-
-static int
-do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
-               void *dirent)
+static int do_udf_readdir(struct inode *dir, struct file *filp,
+                          filldir_t filldir, void *dirent)
 {
         struct udf_fileident_bh fibh;
         struct fileIdentDesc *fi = NULL;
@@ -117,6 +57,7 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
         int i, num;
         unsigned int dt_type;
         struct extent_position epos = { NULL, 0, {0, 0} };
+        struct udf_inode_info *iinfo;
 
         if (nf_pos >= size)
                 return 0;
@@ -125,15 +66,17 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
                 nf_pos = (udf_ext0_offset(dir) >> 2);
 
         fibh.soffset = fibh.eoffset = (nf_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        iinfo = UDF_I(dir);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                 fibh.sbh = fibh.ebh = NULL;
         } else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
                               &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
+                        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
-                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
+                        else if (iinfo->i_alloc_type ==
+                                        ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
                 } else {
                         offset = 0;
@@ -244,3 +187,57 @@ do_udf_readdir(struct inode *dir, struct file *filp, filldir_t filldir,
 
         return 0;
 }
+
+/*
+ * udf_readdir
+ *
+ * PURPOSE
+ *      Read a directory entry.
+ *
+ * DESCRIPTION
+ *      Optional - sys_getdents() will return -ENOTDIR if this routine is not
+ *      available.
+ *
+ *      Refer to sys_getdents() in fs/readdir.c
+ *      sys_getdents() -> .
+ *
+ * PRE-CONDITIONS
+ *      filp                    Pointer to directory file.
+ *      buf                     Pointer to directory entry buffer.
+ *      filldir                 Pointer to filldir function.
+ *
+ * POST-CONDITIONS
+ *      <return>                >=0 on success.
+ *
+ * HISTORY
+ *      July 1, 1997 - Andrew E. Mileski
+ *      Written, tested, and released.
+ */
+
+static int udf_readdir(struct file *filp, void *dirent, filldir_t filldir)
+{
+        struct inode *dir = filp->f_path.dentry->d_inode;
+        int result;
+
+        lock_kernel();
+
+        if (filp->f_pos == 0) {
+                if (filldir(dirent, ".", 1, filp->f_pos, dir->i_ino, DT_DIR) < 0) {
+                        unlock_kernel();
+                        return 0;
+                }
+                filp->f_pos++;
+        }
+
+        result = do_udf_readdir(dir, filp, filldir, dirent);
+        unlock_kernel();
+        return result;
+}
+
+/* readdir and lookup functions */
+const struct file_operations udf_dir_operations = {
+        .read                   = generic_read_dir,
+        .readdir                = udf_readdir,
+        .ioctl                  = udf_ioctl,
+        .fsync                  = udf_fsync_file,
+};
diff --git a/fs/udf/directory.c b/fs/udf/directory.c
index ff8c08fd7bf5..2820f8fcf4cc 100644
--- a/fs/udf/directory.c
+++ b/fs/udf/directory.c
@@ -19,7 +19,7 @@
 #include <linux/buffer_head.h>
 
 #if 0
-static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
+static uint8_t *udf_filead_read(struct inode *dir, uint8_t *tmpad,
                                 uint8_t ad_size, kernel_lb_addr fe_loc,
                                 int *pos, int *offset, struct buffer_head **bh,
                                 int *error)
@@ -45,7 +45,8 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
                 block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
                 if (!block)
                         return NULL;
-                if (!(*bh = udf_tread(dir->i_sb, block)))
+                *bh = udf_tread(dir->i_sb, block);
+                if (!*bh)
                         return NULL;
         } else if (*offset > dir->i_sb->s_blocksize) {
                 ad = tmpad;
@@ -57,10 +58,12 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
                 block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
                 if (!block)
                         return NULL;
-                if (!((*bh) = udf_tread(dir->i_sb, block)))
+                (*bh) = udf_tread(dir->i_sb, block);
+                if (!*bh)
                         return NULL;
 
-                memcpy((uint8_t *)ad + remainder, (*bh)->b_data, ad_size - remainder);
+                memcpy((uint8_t *)ad + remainder, (*bh)->b_data,
+                        ad_size - remainder);
                 *offset = ad_size - remainder;
         }
 
@@ -68,29 +71,31 @@ static uint8_t *udf_filead_read(struct inode *dir, uint8_t * tmpad,
 }
 #endif
 
-struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
+struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t *nf_pos,
                                          struct udf_fileident_bh *fibh,
                                          struct fileIdentDesc *cfi,
                                          struct extent_position *epos,
-                                         kernel_lb_addr * eloc, uint32_t * elen,
-                                         sector_t * offset)
+                                         kernel_lb_addr *eloc, uint32_t *elen,
+                                         sector_t *offset)
 {
         struct fileIdentDesc *fi;
         int i, num, block;
         struct buffer_head *tmp, *bha[16];
+        struct udf_inode_info *iinfo = UDF_I(dir);
 
         fibh->soffset = fibh->eoffset;
 
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
-                fi = udf_get_fileident(UDF_I_DATA(dir) -
-                                       (UDF_I_EFE(dir) ?
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                fi = udf_get_fileident(iinfo->i_ext.i_data -
+                                       (iinfo->i_efe ?
                                         sizeof(struct extendedFileEntry) :
                                         sizeof(struct fileEntry)),
-                                       dir->i_sb->s_blocksize, &(fibh->eoffset));
+                                       dir->i_sb->s_blocksize,
+                                       &(fibh->eoffset));
                 if (!fi)
                         return NULL;
 
-                *nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
+                *nf_pos += fibh->eoffset - fibh->soffset;
 
                 memcpy((uint8_t *)cfi, (uint8_t *)fi,
                        sizeof(struct fileIdentDesc));
@@ -100,6 +105,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
 
         if (fibh->eoffset == dir->i_sb->s_blocksize) {
                 int lextoffset = epos->offset;
+                unsigned char blocksize_bits = dir->i_sb->s_blocksize_bits;
 
                 if (udf_next_aext(dir, epos, eloc, elen, 1) !=
                     (EXT_RECORDED_ALLOCATED >> 30))
@@ -109,24 +115,27 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
 
                 (*offset)++;
 
-                if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
+                if ((*offset << blocksize_bits) >= *elen)
                         *offset = 0;
                 else
                         epos->offset = lextoffset;
 
                 brelse(fibh->sbh);
-                if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
+                fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
+                if (!fibh->sbh)
                         return NULL;
                 fibh->soffset = fibh->eoffset = 0;
 
-                if (!(*offset & ((16 >> (dir->i_sb->s_blocksize_bits - 9)) - 1))) {
-                        i = 16 >> (dir->i_sb->s_blocksize_bits - 9);
-                        if (i + *offset > (*elen >> dir->i_sb->s_blocksize_bits))
-                                i = (*elen >> dir->i_sb->s_blocksize_bits)-*offset;
+                if (!(*offset & ((16 >> (blocksize_bits - 9)) - 1))) {
+                        i = 16 >> (blocksize_bits - 9);
+                        if (i + *offset > (*elen >> blocksize_bits))
+                                i = (*elen >> blocksize_bits)-*offset;
                         for (num = 0; i > 0; i--) {
-                                block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset + i);
+                                block = udf_get_lb_pblock(dir->i_sb, *eloc,
+                                                          *offset + i);
                                 tmp = udf_tgetblk(dir->i_sb, block);
-                                if (tmp && !buffer_uptodate(tmp) && !buffer_locked(tmp))
+                                if (tmp && !buffer_uptodate(tmp) &&
+                                                !buffer_locked(tmp))
                                         bha[num++] = tmp;
                                 else
                                         brelse(tmp);
@@ -148,7 +157,7 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
         if (!fi)
                 return NULL;
 
-        *nf_pos += ((fibh->eoffset - fibh->soffset) >> 2);
+        *nf_pos += fibh->eoffset - fibh->soffset;
 
         if (fibh->eoffset <= dir->i_sb->s_blocksize) {
                 memcpy((uint8_t *)cfi, (uint8_t *)fi,
@@ -172,20 +181,23 @@ struct fileIdentDesc *udf_fileident_read(struct inode *dir, loff_t * nf_pos,
                 fibh->soffset -= dir->i_sb->s_blocksize;
                 fibh->eoffset -= dir->i_sb->s_blocksize;
 
-                if (!(fibh->ebh = udf_tread(dir->i_sb, block)))
+                fibh->ebh = udf_tread(dir->i_sb, block);
+                if (!fibh->ebh)
                         return NULL;
 
                 if (sizeof(struct fileIdentDesc) > -fibh->soffset) {
                         int fi_len;
 
                         memcpy((uint8_t *)cfi, (uint8_t *)fi, -fibh->soffset);
-                        memcpy((uint8_t *)cfi - fibh->soffset, fibh->ebh->b_data,
+                        memcpy((uint8_t *)cfi - fibh->soffset,
+                               fibh->ebh->b_data,
                                sizeof(struct fileIdentDesc) + fibh->soffset);
 
-                        fi_len = (sizeof(struct fileIdentDesc) + cfi->lengthFileIdent +
+                        fi_len = (sizeof(struct fileIdentDesc) +
+                                  cfi->lengthFileIdent +
                                   le16_to_cpu(cfi->lengthOfImpUse) + 3) & ~3;
 
-                        *nf_pos += ((fi_len - (fibh->eoffset - fibh->soffset)) >> 2);
+                        *nf_pos += fi_len - (fibh->eoffset - fibh->soffset);
                         fibh->eoffset = fibh->soffset + fi_len;
                 } else {
                         memcpy((uint8_t *)cfi, (uint8_t *)fi,
@@ -210,11 +222,10 @@ struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset)
 
         ptr = buffer;
 
-        if ((*offset > 0) && (*offset < bufsize)) {
+        if ((*offset > 0) && (*offset < bufsize))
                 ptr += *offset;
-        }
         fi = (struct fileIdentDesc *)ptr;
-        if (le16_to_cpu(fi->descTag.tagIdent) != TAG_IDENT_FID) {
+        if (fi->descTag.tagIdent != cpu_to_le16(TAG_IDENT_FID)) {
                 udf_debug("0x%x != TAG_IDENT_FID\n",
                           le16_to_cpu(fi->descTag.tagIdent));
                 udf_debug("offset: %u sizeof: %lu bufsize: %u\n",
@@ -222,12 +233,11 @@ struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize, int *offset)
                           bufsize);
                 return NULL;
         }
-        if ((*offset + sizeof(struct fileIdentDesc)) > bufsize) {
+        if ((*offset + sizeof(struct fileIdentDesc)) > bufsize)
                 lengthThisIdent = sizeof(struct fileIdentDesc);
-        } else {
+        else
                 lengthThisIdent = sizeof(struct fileIdentDesc) +
                         fi->lengthFileIdent + le16_to_cpu(fi->lengthOfImpUse);
-        }
 
         /* we need to figure padding, too! */
         padlen = lengthThisIdent % UDF_NAME_PAD;
@@ -252,17 +262,17 @@ static extent_ad *udf_get_fileextent(void *buffer, int bufsize, int *offset)
 
         fe = (struct fileEntry *)buffer;
 
-        if (le16_to_cpu(fe->descTag.tagIdent) != TAG_IDENT_FE) {
+        if (fe->descTag.tagIdent != cpu_to_le16(TAG_IDENT_FE)) {
                 udf_debug("0x%x != TAG_IDENT_FE\n",
                           le16_to_cpu(fe->descTag.tagIdent));
                 return NULL;
         }
 
-        ptr = (uint8_t *)(fe->extendedAttr) + le32_to_cpu(fe->lengthExtendedAttr);
+        ptr = (uint8_t *)(fe->extendedAttr) +
+                le32_to_cpu(fe->lengthExtendedAttr);
 
-        if ((*offset > 0) && (*offset < le32_to_cpu(fe->lengthAllocDescs))) {
+        if ((*offset > 0) && (*offset < le32_to_cpu(fe->lengthAllocDescs)))
                 ptr += *offset;
-        }
 
         ext = (extent_ad *)ptr;
 
@@ -271,7 +281,7 @@ static extent_ad *udf_get_fileextent(void *buffer, int bufsize, int *offset)
 }
 #endif
 
-short_ad *udf_get_fileshortad(uint8_t *ptr, int maxoffset, int *offset,
+short_ad *udf_get_fileshortad(uint8_t *ptr, int maxoffset, uint32_t *offset,
                               int inc)
 {
         short_ad *sa;
@@ -281,17 +291,20 @@ short_ad *udf_get_fileshortad(uint8_t *ptr, int maxoffset, int *offset,
                 return NULL;
         }
 
-        if ((*offset < 0) || ((*offset + sizeof(short_ad)) > maxoffset))
-                return NULL;
-        else if ((sa = (short_ad *)ptr)->extLength == 0)
+        if ((*offset + sizeof(short_ad)) > maxoffset)
                 return NULL;
+        else {
+                sa = (short_ad *)ptr;
+                if (sa->extLength == 0)
+                        return NULL;
+        }
 
         if (inc)
                 *offset += sizeof(short_ad);
         return sa;
 }
 
-long_ad *udf_get_filelongad(uint8_t *ptr, int maxoffset, int *offset, int inc)
+long_ad *udf_get_filelongad(uint8_t *ptr, int maxoffset, uint32_t *offset, int inc)
 {
         long_ad *la;
 
@@ -300,10 +313,13 @@ long_ad *udf_get_filelongad(uint8_t *ptr, int maxoffset, int *offset, int inc)
                 return NULL;
         }
 
-        if ((*offset < 0) || ((*offset + sizeof(long_ad)) > maxoffset))
-                return NULL;
-        else if ((la = (long_ad *)ptr)->extLength == 0)
+        if ((*offset + sizeof(long_ad)) > maxoffset)
                 return NULL;
+        else {
+                la = (long_ad *)ptr;
+                if (la->extLength == 0)
+                        return NULL;
+        }
 
         if (inc)
                 *offset += sizeof(long_ad);
diff --git a/fs/udf/file.c b/fs/udf/file.c
index 7c7a1b39d56c..97c71ae7c689 100644
--- a/fs/udf/file.c
+++ b/fs/udf/file.c
@@ -45,12 +45,13 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)
 {
         struct inode *inode = page->mapping->host;
         char *kaddr;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         BUG_ON(!PageLocked(page));
 
         kaddr = kmap(page);
         memset(kaddr, 0, PAGE_CACHE_SIZE);
-        memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), inode->i_size);
+        memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr, inode->i_size);
         flush_dcache_page(page);
         SetPageUptodate(page);
         kunmap(page);
@@ -59,15 +60,17 @@ static int udf_adinicb_readpage(struct file *file, struct page *page)
         return 0;
 }
 
-static int udf_adinicb_writepage(struct page *page, struct writeback_control *wbc)
+static int udf_adinicb_writepage(struct page *page,
+                                 struct writeback_control *wbc)
 {
         struct inode *inode = page->mapping->host;
         char *kaddr;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         BUG_ON(!PageLocked(page));
 
         kaddr = kmap(page);
-        memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), kaddr, inode->i_size);
+        memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr, kaddr, inode->i_size);
         mark_inode_dirty(inode);
         SetPageUptodate(page);
         kunmap(page);
@@ -84,9 +87,10 @@ static int udf_adinicb_write_end(struct file *file,
         struct inode *inode = mapping->host;
         unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
         char *kaddr;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         kaddr = kmap_atomic(page, KM_USER0);
-        memcpy(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset,
+        memcpy(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
                 kaddr + offset, copied);
         kunmap_atomic(kaddr, KM_USER0);
 
@@ -109,25 +113,27 @@ static ssize_t udf_file_aio_write(struct kiocb *iocb, const struct iovec *iov,
         struct inode *inode = file->f_path.dentry->d_inode;
         int err, pos;
         size_t count = iocb->ki_left;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                 if (file->f_flags & O_APPEND)
                         pos = inode->i_size;
                 else
                         pos = ppos;
 
-                if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
+                if (inode->i_sb->s_blocksize <
+                                (udf_file_entry_alloc_offset(inode) +
                                                 pos + count)) {
                         udf_expand_file_adinicb(inode, pos + count, &err);
-                        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
+                        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
                                 udf_debug("udf_expand_adinicb: err=%d\n", err);
                                 return err;
                         }
                 } else {
                         if (pos + count > inode->i_size)
-                                UDF_I_LENALLOC(inode) = pos + count;
+                                iinfo->i_lenAlloc = pos + count;
                         else
-                                UDF_I_LENALLOC(inode) = inode->i_size;
+                                iinfo->i_lenAlloc = inode->i_size;
                 }
         }
 
@@ -191,23 +197,28 @@ int udf_ioctl(struct inode *inode, struct file *filp, unsigned int cmd,
 
         switch (cmd) {
         case UDF_GETVOLIDENT:
-                return copy_to_user((char __user *)arg,
-                                    UDF_SB_VOLIDENT(inode->i_sb), 32) ? -EFAULT : 0;
+                if (copy_to_user((char __user *)arg,
+                                 UDF_SB(inode->i_sb)->s_volume_ident, 32))
+                        return -EFAULT;
+                else
+                        return 0;
         case UDF_RELOCATE_BLOCKS:
                 if (!capable(CAP_SYS_ADMIN))
                         return -EACCES;
                 if (get_user(old_block, (long __user *)arg))
                         return -EFAULT;
-                if ((result = udf_relocate_blocks(inode->i_sb,
-                                                  old_block, &new_block)) == 0)
+                result = udf_relocate_blocks(inode->i_sb,
+                                                old_block, &new_block);
+                if (result == 0)
                         result = put_user(new_block, (long __user *)arg);
                 return result;
         case UDF_GETEASIZE:
-                result = put_user(UDF_I_LENEATTR(inode), (int __user *)arg);
+                result = put_user(UDF_I(inode)->i_lenEAttr, (int __user *)arg);
                 break;
         case UDF_GETEABLOCK:
-                result = copy_to_user((char __user *)arg, UDF_I_DATA(inode),
-                                      UDF_I_LENEATTR(inode)) ? -EFAULT : 0;
+                result = copy_to_user((char __user *)arg,
+                                      UDF_I(inode)->i_ext.i_data,
+                                      UDF_I(inode)->i_lenEAttr) ? -EFAULT : 0;
                 break;
         }
 
diff --git a/fs/udf/ialloc.c b/fs/udf/ialloc.c
index 636d8f613929..84360315aca2 100644
--- a/fs/udf/ialloc.c
+++ b/fs/udf/ialloc.c
@@ -43,19 +43,21 @@ void udf_free_inode(struct inode *inode)
         clear_inode(inode);
 
         mutex_lock(&sbi->s_alloc_mutex);
-        if (sbi->s_lvidbh) {
+        if (sbi->s_lvid_bh) {
+                struct logicalVolIntegrityDescImpUse *lvidiu =
+                                                        udf_sb_lvidiu(sbi);
                 if (S_ISDIR(inode->i_mode))
-                        UDF_SB_LVIDIU(sb)->numDirs =
-                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) - 1);
+                        lvidiu->numDirs =
+                                cpu_to_le32(le32_to_cpu(lvidiu->numDirs) - 1);
                 else
-                        UDF_SB_LVIDIU(sb)->numFiles =
-                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) - 1);
+                        lvidiu->numFiles =
+                                cpu_to_le32(le32_to_cpu(lvidiu->numFiles) - 1);
 
-                mark_buffer_dirty(sbi->s_lvidbh);
+                mark_buffer_dirty(sbi->s_lvid_bh);
         }
         mutex_unlock(&sbi->s_alloc_mutex);
 
-        udf_free_blocks(sb, NULL, UDF_I_LOCATION(inode), 0, 1);
+        udf_free_blocks(sb, NULL, UDF_I(inode)->i_location, 0, 1);
 }
 
 struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
@@ -64,7 +66,9 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
         struct udf_sb_info *sbi = UDF_SB(sb);
         struct inode *inode;
         int block;
-        uint32_t start = UDF_I_LOCATION(dir).logicalBlockNum;
+        uint32_t start = UDF_I(dir)->i_location.logicalBlockNum;
+        struct udf_inode_info *iinfo;
+        struct udf_inode_info *dinfo = UDF_I(dir);
 
         inode = new_inode(sb);
 
@@ -74,13 +78,15 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
         }
         *err = -ENOSPC;
 
-        UDF_I_UNIQUE(inode) = 0;
-        UDF_I_LENEXTENTS(inode) = 0;
-        UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
-        UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
-        UDF_I_STRAT4096(inode) = 0;
+        iinfo = UDF_I(inode);
+        iinfo->i_unique = 0;
+        iinfo->i_lenExtents = 0;
+        iinfo->i_next_alloc_block = 0;
+        iinfo->i_next_alloc_goal = 0;
+        iinfo->i_strat4096 = 0;
 
-        block = udf_new_block(dir->i_sb, NULL, UDF_I_LOCATION(dir).partitionReferenceNum,
+        block = udf_new_block(dir->i_sb, NULL,
+                              dinfo->i_location.partitionReferenceNum,
                               start, err);
         if (*err) {
                 iput(inode);
@@ -88,21 +94,27 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
         }
 
         mutex_lock(&sbi->s_alloc_mutex);
-        if (UDF_SB_LVIDBH(sb)) {
+        if (sbi->s_lvid_bh) {
+                struct logicalVolIntegrityDesc *lvid =
+                        (struct logicalVolIntegrityDesc *)
+                        sbi->s_lvid_bh->b_data;
+                struct logicalVolIntegrityDescImpUse *lvidiu =
+                                                        udf_sb_lvidiu(sbi);
                 struct logicalVolHeaderDesc *lvhd;
                 uint64_t uniqueID;
-                lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(sb)->logicalVolContentsUse);
+                lvhd = (struct logicalVolHeaderDesc *)
+                                (lvid->logicalVolContentsUse);
                 if (S_ISDIR(mode))
-                        UDF_SB_LVIDIU(sb)->numDirs =
-                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs) + 1);
+                        lvidiu->numDirs =
+                                cpu_to_le32(le32_to_cpu(lvidiu->numDirs) + 1);
                 else
-                        UDF_SB_LVIDIU(sb)->numFiles =
-                                cpu_to_le32(le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) + 1);
-                UDF_I_UNIQUE(inode) = uniqueID = le64_to_cpu(lvhd->uniqueID);
+                        lvidiu->numFiles =
+                                cpu_to_le32(le32_to_cpu(lvidiu->numFiles) + 1);
+                iinfo->i_unique = uniqueID = le64_to_cpu(lvhd->uniqueID);
                 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
                         uniqueID += 16;
                 lvhd->uniqueID = cpu_to_le64(uniqueID);
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
+                mark_buffer_dirty(sbi->s_lvid_bh);
         }
         inode->i_mode = mode;
         inode->i_uid = current->fsuid;
@@ -114,35 +126,41 @@ struct inode *udf_new_inode(struct inode *dir, int mode, int *err)
                 inode->i_gid = current->fsgid;
         }
 
-        UDF_I_LOCATION(inode).logicalBlockNum = block;
-        UDF_I_LOCATION(inode).partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
-        inode->i_ino = udf_get_lb_pblock(sb, UDF_I_LOCATION(inode), 0);
+        iinfo->i_location.logicalBlockNum = block;
+        iinfo->i_location.partitionReferenceNum =
+                                dinfo->i_location.partitionReferenceNum;
+        inode->i_ino = udf_get_lb_pblock(sb, iinfo->i_location, 0);
         inode->i_blocks = 0;
-        UDF_I_LENEATTR(inode) = 0;
-        UDF_I_LENALLOC(inode) = 0;
-        UDF_I_USE(inode) = 0;
+        iinfo->i_lenEAttr = 0;
+        iinfo->i_lenAlloc = 0;
+        iinfo->i_use = 0;
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_EXTENDED_FE)) {
-                UDF_I_EFE(inode) = 1;
-                UDF_UPDATE_UDFREV(inode->i_sb, UDF_VERS_USE_EXTENDED_FE);
-                UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry), GFP_KERNEL);
+                iinfo->i_efe = 1;
+                if (UDF_VERS_USE_EXTENDED_FE > sbi->s_udfrev)
+                        sbi->s_udfrev = UDF_VERS_USE_EXTENDED_FE;
+                iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
+                                            sizeof(struct extendedFileEntry),
+                                            GFP_KERNEL);
         } else {
-                UDF_I_EFE(inode) = 0;
-                UDF_I_DATA(inode) = kzalloc(inode->i_sb->s_blocksize - sizeof(struct fileEntry), GFP_KERNEL);
+                iinfo->i_efe = 0;
+                iinfo->i_ext.i_data = kzalloc(inode->i_sb->s_blocksize -
+                                            sizeof(struct fileEntry),
+                                            GFP_KERNEL);
         }
-        if (!UDF_I_DATA(inode)) {
+        if (!iinfo->i_ext.i_data) {
                 iput(inode);
                 *err = -ENOMEM;
                 mutex_unlock(&sbi->s_alloc_mutex);
                 return NULL;
         }
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_AD_IN_ICB))
-                UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
         else if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
-                UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
         else
-                UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
         inode->i_mtime = inode->i_atime = inode->i_ctime =
-                UDF_I_CRTIME(inode) = current_fs_time(inode->i_sb);
+                iinfo->i_crtime = current_fs_time(inode->i_sb);
         insert_inode_hash(inode);
         mark_inode_dirty(inode);
         mutex_unlock(&sbi->s_alloc_mutex);
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index 6ff8151984cf..24cfa55d0fdc 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -19,7 +19,8 @@
  *  10/04/98 dgb  Added rudimentary directory functions
  *  10/07/98      Fully working udf_block_map! It works!
  *  11/25/98      bmap altered to better support extents
- *  12/06/98 blf  partition support in udf_iget, udf_block_map and udf_read_inode
+ *  12/06/98 blf  partition support in udf_iget, udf_block_map
+ *                and udf_read_inode
  *  12/12/98      rewrote udf_block_map to handle next extents and descs across
  *                block boundaries (which is not actually allowed)
  *  12/20/98      added support for strategy 4096
@@ -51,7 +52,7 @@ static int udf_update_inode(struct inode *, int);
 static void udf_fill_inode(struct inode *, struct buffer_head *);
 static int udf_alloc_i_data(struct inode *inode, size_t size);
 static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
-                                        long *, int *);
+                                        sector_t *, int *);
 static int8_t udf_insert_aext(struct inode *, struct extent_position,
                               kernel_lb_addr, uint32_t);
 static void udf_split_extents(struct inode *, int *, int, int,
@@ -111,16 +112,18 @@ no_delete:
  */
 void udf_clear_inode(struct inode *inode)
 {
+        struct udf_inode_info *iinfo;
         if (!(inode->i_sb->s_flags & MS_RDONLY)) {
                 lock_kernel();
                 /* Discard preallocation for directories, symlinks, etc. */
                 udf_discard_prealloc(inode);
                 udf_truncate_tail_extent(inode);
                 unlock_kernel();
-                write_inode_now(inode, 1);
+                write_inode_now(inode, 0);
         }
-        kfree(UDF_I_DATA(inode));
-        UDF_I_DATA(inode) = NULL;
+        iinfo = UDF_I(inode);
+        kfree(iinfo->i_ext.i_data);
+        iinfo->i_ext.i_data = NULL;
 }
 
 static int udf_writepage(struct page *page, struct writeback_control *wbc)
@@ -160,6 +163,7 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
 {
         struct page *page;
         char *kaddr;
+        struct udf_inode_info *iinfo = UDF_I(inode);
         struct writeback_control udf_wbc = {
                 .sync_mode = WB_SYNC_NONE,
                 .nr_to_write = 1,
@@ -168,11 +172,11 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
         /* from now on we have normal address_space methods */
         inode->i_data.a_ops = &udf_aops;
 
-        if (!UDF_I_LENALLOC(inode)) {
+        if (!iinfo->i_lenAlloc) {
                 if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
-                        UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
+                        iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
                 else
-                        UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
+                        iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
                 mark_inode_dirty(inode);
                 return;
         }
@@ -182,21 +186,21 @@ void udf_expand_file_adinicb(struct inode *inode, int newsize, int *err)
 
         if (!PageUptodate(page)) {
                 kaddr = kmap(page);
-                memset(kaddr + UDF_I_LENALLOC(inode), 0x00,
-                       PAGE_CACHE_SIZE - UDF_I_LENALLOC(inode));
-                memcpy(kaddr, UDF_I_DATA(inode) + UDF_I_LENEATTR(inode),
-                       UDF_I_LENALLOC(inode));
+                memset(kaddr + iinfo->i_lenAlloc, 0x00,
+                       PAGE_CACHE_SIZE - iinfo->i_lenAlloc);
+                memcpy(kaddr, iinfo->i_ext.i_data + iinfo->i_lenEAttr,
+                        iinfo->i_lenAlloc);
                 flush_dcache_page(page);
                 SetPageUptodate(page);
                 kunmap(page);
         }
-        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0x00,
-               UDF_I_LENALLOC(inode));
-        UDF_I_LENALLOC(inode) = 0;
+        memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0x00,
+               iinfo->i_lenAlloc);
+        iinfo->i_lenAlloc = 0;
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
-                UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_SHORT;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_SHORT;
         else
-                UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_LONG;
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_LONG;
 
         inode->i_data.a_ops->writepage(page, &udf_wbc);
         page_cache_release(page);
@@ -215,9 +219,10 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
         struct extent_position epos;
 
         struct udf_fileident_bh sfibh, dfibh;
-        loff_t f_pos = udf_ext0_offset(inode) >> 2;
-        int size = (udf_ext0_offset(inode) + inode->i_size) >> 2;
+        loff_t f_pos = udf_ext0_offset(inode);
+        int size = udf_ext0_offset(inode) + inode->i_size;
         struct fileIdentDesc cfi, *sfi, *dfi;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_USE_SHORT_AD))
                 alloctype = ICBTAG_FLAG_AD_SHORT;
@@ -225,19 +230,20 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
                 alloctype = ICBTAG_FLAG_AD_LONG;
 
         if (!inode->i_size) {
-                UDF_I_ALLOCTYPE(inode) = alloctype;
+                iinfo->i_alloc_type = alloctype;
                 mark_inode_dirty(inode);
                 return NULL;
         }
 
         /* alloc block, and copy data to it */
         *block = udf_new_block(inode->i_sb, inode,
-                               UDF_I_LOCATION(inode).partitionReferenceNum,
-                               UDF_I_LOCATION(inode).logicalBlockNum, err);
+                               iinfo->i_location.partitionReferenceNum,
+                               iinfo->i_location.logicalBlockNum, err);
         if (!(*block))
                 return NULL;
         newblock = udf_get_pblock(inode->i_sb, *block,
-                                  UDF_I_LOCATION(inode).partitionReferenceNum, 0);
+                                  iinfo->i_location.partitionReferenceNum,
+                                0);
         if (!newblock)
                 return NULL;
         dbh = udf_tgetblk(inode->i_sb, newblock);
@@ -249,39 +255,44 @@ struct buffer_head *udf_expand_dir_adinicb(struct inode *inode, int *block,
         unlock_buffer(dbh);
         mark_buffer_dirty_inode(dbh, inode);
 
-        sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
+        sfibh.soffset = sfibh.eoffset =
+                        f_pos & (inode->i_sb->s_blocksize - 1);
         sfibh.sbh = sfibh.ebh = NULL;
         dfibh.soffset = dfibh.eoffset = 0;
         dfibh.sbh = dfibh.ebh = dbh;
-        while ((f_pos < size)) {
-                UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
-                sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL);
+        while (f_pos < size) {
+                iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
+                sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL,
+                                         NULL, NULL, NULL);
                 if (!sfi) {
                         brelse(dbh);
                         return NULL;
                 }
-                UDF_I_ALLOCTYPE(inode) = alloctype;
+                iinfo->i_alloc_type = alloctype;
                 sfi->descTag.tagLocation = cpu_to_le32(*block);
                 dfibh.soffset = dfibh.eoffset;
                 dfibh.eoffset += (sfibh.eoffset - sfibh.soffset);
                 dfi = (struct fileIdentDesc *)(dbh->b_data + dfibh.soffset);
                 if (udf_write_fi(inode, sfi, dfi, &dfibh, sfi->impUse,
-                                 sfi->fileIdent + le16_to_cpu(sfi->lengthOfImpUse))) {
-                        UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
+                                 sfi->fileIdent +
+                                        le16_to_cpu(sfi->lengthOfImpUse))) {
+                        iinfo->i_alloc_type = ICBTAG_FLAG_AD_IN_ICB;
                         brelse(dbh);
                         return NULL;
                 }
         }
         mark_buffer_dirty_inode(dbh, inode);
 
-        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, UDF_I_LENALLOC(inode));
-        UDF_I_LENALLOC(inode) = 0;
+        memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr, 0,
+                iinfo->i_lenAlloc);
+        iinfo->i_lenAlloc = 0;
         eloc.logicalBlockNum = *block;
-        eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
-        elen = inode->i_size;
-        UDF_I_LENEXTENTS(inode) = elen;
+        eloc.partitionReferenceNum =
+                                iinfo->i_location.partitionReferenceNum;
+        elen = inode->i_sb->s_blocksize;
+        iinfo->i_lenExtents = elen;
         epos.bh = NULL;
-        epos.block = UDF_I_LOCATION(inode);
+        epos.block = iinfo->i_location;
         epos.offset = udf_file_entry_alloc_offset(inode);
         udf_add_aext(inode, &epos, eloc, elen, 0);
         /* UniqueID stuff */
@@ -296,7 +307,8 @@ static int udf_get_block(struct inode *inode, sector_t block,
 {
         int err, new;
         struct buffer_head *bh;
-        unsigned long phys;
+        sector_t phys = 0;
+        struct udf_inode_info *iinfo;
 
         if (!create) {
                 phys = udf_block_map(inode, block);
@@ -314,9 +326,10 @@ static int udf_get_block(struct inode *inode, sector_t block,
         if (block < 0)
                 goto abort_negative;
 
-        if (block == UDF_I_NEXT_ALLOC_BLOCK(inode) + 1) {
-                UDF_I_NEXT_ALLOC_BLOCK(inode)++;
-                UDF_I_NEXT_ALLOC_GOAL(inode)++;
+        iinfo = UDF_I(inode);
+        if (block == iinfo->i_next_alloc_block + 1) {
+                iinfo->i_next_alloc_block++;
+                iinfo->i_next_alloc_goal++;
         }
 
         err = 0;
@@ -366,32 +379,35 @@ static struct buffer_head *udf_getblk(struct inode *inode, long block,
 
 /* Extend the file by 'blocks' blocks, return the number of extents added */
 int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
-                    kernel_long_ad * last_ext, sector_t blocks)
+                    kernel_long_ad *last_ext, sector_t blocks)
 {
         sector_t add;
         int count = 0, fake = !(last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
         struct super_block *sb = inode->i_sb;
         kernel_lb_addr prealloc_loc = {};
         int prealloc_len = 0;
+        struct udf_inode_info *iinfo;
 
         /* The previous extent is fake and we should not extend by anything
          * - there's nothing to do... */
         if (!blocks && fake)
                 return 0;
 
+        iinfo = UDF_I(inode);
         /* Round the last extent up to a multiple of block size */
         if (last_ext->extLength & (sb->s_blocksize - 1)) {
                 last_ext->extLength =
                         (last_ext->extLength & UDF_EXTENT_FLAG_MASK) |
                         (((last_ext->extLength & UDF_EXTENT_LENGTH_MASK) +
                           sb->s_blocksize - 1) & ~(sb->s_blocksize - 1));
-                UDF_I_LENEXTENTS(inode) =
-                        (UDF_I_LENEXTENTS(inode) + sb->s_blocksize - 1) &
+                iinfo->i_lenExtents =
+                        (iinfo->i_lenExtents + sb->s_blocksize - 1) &
                         ~(sb->s_blocksize - 1);
         }
 
         /* Last extent are just preallocated blocks? */
-        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_ALLOCATED) {
+        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
+                                                EXT_NOT_RECORDED_ALLOCATED) {
                 /* Save the extent so that we can reattach it to the end */
                 prealloc_loc = last_ext->extLocation;
                 prealloc_len = last_ext->extLength;
@@ -399,13 +415,15 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
                 last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
                         (last_ext->extLength & UDF_EXTENT_LENGTH_MASK);
                 last_ext->extLocation.logicalBlockNum = 0;
-                last_ext->extLocation.partitionReferenceNum = 0;
+                last_ext->extLocation.partitionReferenceNum = 0;
         }
 
         /* Can we merge with the previous extent? */
-        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) == EXT_NOT_RECORDED_NOT_ALLOCATED) {
-                add = ((1 << 30) - sb->s_blocksize - (last_ext->extLength &
-                                                      UDF_EXTENT_LENGTH_MASK)) >> sb->s_blocksize_bits;
+        if ((last_ext->extLength & UDF_EXTENT_FLAG_MASK) ==
+                                        EXT_NOT_RECORDED_NOT_ALLOCATED) {
+                add = ((1 << 30) - sb->s_blocksize -
+                        (last_ext->extLength & UDF_EXTENT_LENGTH_MASK)) >>
+                        sb->s_blocksize_bits;
                 if (add > blocks)
                         add = blocks;
                 blocks -= add;
@@ -416,9 +434,9 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
                 udf_add_aext(inode, last_pos, last_ext->extLocation,
                              last_ext->extLength, 1);
                 count++;
-        } else {
-                udf_write_aext(inode, last_pos, last_ext->extLocation, last_ext->extLength, 1);
-        }
+        } else
+                udf_write_aext(inode, last_pos, last_ext->extLocation,
+                                last_ext->extLength, 1);
 
         /* Managed to do everything necessary? */
         if (!blocks)
@@ -426,9 +444,10 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
 
         /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
         last_ext->extLocation.logicalBlockNum = 0;
-        last_ext->extLocation.partitionReferenceNum = 0;
+        last_ext->extLocation.partitionReferenceNum = 0;
         add = (1 << (30-sb->s_blocksize_bits)) - 1;
-        last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED | (add << sb->s_blocksize_bits);
+        last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
+                                (add << sb->s_blocksize_bits);
 
         /* Create enough extents to cover the whole hole */
         while (blocks > add) {
@@ -450,7 +469,8 @@ int udf_extend_file(struct inode *inode, struct extent_position *last_pos,
 out:
         /* Do we have some preallocated blocks saved? */
         if (prealloc_len) {
-                if (udf_add_aext(inode, last_pos, prealloc_loc, prealloc_len, 1) == -1)
+                if (udf_add_aext(inode, last_pos, prealloc_loc,
+                                 prealloc_len, 1) == -1)
                         return -1;
                 last_ext->extLocation = prealloc_loc;
                 last_ext->extLength = prealloc_len;
@@ -458,9 +478,9 @@ out:
         }
 
         /* last_pos should point to the last written extent... */
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 last_pos->offset -= sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 last_pos->offset -= sizeof(long_ad);
         else
                 return -1;
@@ -469,7 +489,7 @@ out:
 }
 
 static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
-                                        int *err, long *phys, int *new)
+                                        int *err, sector_t *phys, int *new)
 {
         static sector_t last_block;
         struct buffer_head *result = NULL;
@@ -483,11 +503,12 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         uint32_t newblocknum, newblock;
         sector_t offset = 0;
         int8_t etype;
-        int goal = 0, pgoal = UDF_I_LOCATION(inode).logicalBlockNum;
+        struct udf_inode_info *iinfo = UDF_I(inode);
+        int goal = 0, pgoal = iinfo->i_location.logicalBlockNum;
         int lastblock = 0;
 
         prev_epos.offset = udf_file_entry_alloc_offset(inode);
-        prev_epos.block = UDF_I_LOCATION(inode);
+        prev_epos.block = iinfo->i_location;
         prev_epos.bh = NULL;
         cur_epos = next_epos = prev_epos;
         b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
@@ -515,7 +536,8 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                 prev_epos.offset = cur_epos.offset;
                 cur_epos.offset = next_epos.offset;
 
-                if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
+                etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1);
+                if (etype == -1)
                         break;
 
                 c = !c;
@@ -569,9 +591,11 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                         startnum = 1;
                 } else {
                         /* Create a fake extent when there's not one */
-                        memset(&laarr[0].extLocation, 0x00, sizeof(kernel_lb_addr));
+                        memset(&laarr[0].extLocation, 0x00,
+                                sizeof(kernel_lb_addr));
                         laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
-                        /* Will udf_extend_file() create real extent from a fake one? */
+                        /* Will udf_extend_file() create real extent from
+                           a fake one? */
                         startnum = (offset > 0);
                 }
                 /* Create extents for the hole between EOF and offset */
@@ -589,14 +613,16 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                 offset = 0;
                 count += ret;
                 /* We are not covered by a preallocated extent? */
-                if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != EXT_NOT_RECORDED_ALLOCATED) {
+                if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) !=
+                                                EXT_NOT_RECORDED_ALLOCATED) {
                         /* Is there any real extent? - otherwise we overwrite
                          * the fake one... */
                         if (count)
                                 c = !c;
                         laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
                                 inode->i_sb->s_blocksize;
-                        memset(&laarr[c].extLocation, 0x00, sizeof(kernel_lb_addr));
+                        memset(&laarr[c].extLocation, 0x00,
+                                sizeof(kernel_lb_addr));
                         count++;
                         endnum++;
                 }
@@ -605,7 +631,8 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
         } else {
                 endnum = startnum = ((count > 2) ? 2 : count);
 
-                /* if the current extent is in position 0, swap it with the previous */
+                /* if the current extent is in position 0,
+                   swap it with the previous */
                 if (!c && count != 1) {
                         laarr[2] = laarr[0];
                         laarr[0] = laarr[1];
@@ -613,44 +640,47 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
                         c = 1;
                 }
 
-                /* if the current block is located in an extent, read the next extent */
-                if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1) {
+                /* if the current block is located in an extent,
+                   read the next extent */
+                etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0);
+                if (etype != -1) {
                         laarr[c + 1].extLength = (etype << 30) | elen;
                         laarr[c + 1].extLocation = eloc;
                         count++;
                         startnum++;
                         endnum++;
-                } else {
+                } else
                         lastblock = 1;
-                }
         }
 
         /* if the current extent is not recorded but allocated, get the
          * block in the extent corresponding to the requested block */
-        if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
+        if ((laarr[c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30))
                 newblocknum = laarr[c].extLocation.logicalBlockNum + offset;
-        } else { /* otherwise, allocate a new block */
-                if (UDF_I_NEXT_ALLOC_BLOCK(inode) == block)
-                        goal = UDF_I_NEXT_ALLOC_GOAL(inode);
+        else { /* otherwise, allocate a new block */
+                if (iinfo->i_next_alloc_block == block)
+                        goal = iinfo->i_next_alloc_goal;
 
                 if (!goal) {
-                        if (!(goal = pgoal))
-                                goal = UDF_I_LOCATION(inode).logicalBlockNum + 1;
+                        if (!(goal = pgoal)) /* XXX: what was intended here? */
+                                goal = iinfo->i_location.logicalBlockNum + 1;
                 }
 
-                if (!(newblocknum = udf_new_block(inode->i_sb, inode,
-                                                  UDF_I_LOCATION(inode).partitionReferenceNum,
-                                                  goal, err))) {
+                newblocknum = udf_new_block(inode->i_sb, inode,
+                                iinfo->i_location.partitionReferenceNum,
+                                goal, err);
+                if (!newblocknum) {
                         brelse(prev_epos.bh);
                         *err = -ENOSPC;
                         return NULL;
                 }
-                UDF_I_LENEXTENTS(inode) += inode->i_sb->s_blocksize;
+                iinfo->i_lenExtents += inode->i_sb->s_blocksize;
         }
 
-        /* if the extent the requsted block is located in contains multiple blocks,
-         * split the extent into at most three extents. blocks prior to requested
-         * block, requested block, and blocks after requested block */
+        /* if the extent the requsted block is located in contains multiple
+         * blocks, split the extent into at most three extents. blocks prior
+         * to requested block, requested block, and blocks after requested
+         * block */
         udf_split_extents(inode, &c, offset, newblocknum, laarr, &endnum);
 
 #ifdef UDF_PREALLOCATE
@@ -668,15 +698,15 @@ static struct buffer_head *inode_getblk(struct inode *inode, sector_t block,
 
         brelse(prev_epos.bh);
 
-        if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
-                                        UDF_I_LOCATION(inode).partitionReferenceNum, 0))) {
+        newblock = udf_get_pblock(inode->i_sb, newblocknum,
+                                iinfo->i_location.partitionReferenceNum, 0);
+        if (!newblock)
                 return NULL;
-        }
         *phys = newblock;
         *err = 0;
         *new = 1;
-        UDF_I_NEXT_ALLOC_BLOCK(inode) = block;
-        UDF_I_NEXT_ALLOC_GOAL(inode) = newblocknum;
+        iinfo->i_next_alloc_block = block;
+        iinfo->i_next_alloc_goal = newblocknum;
         inode->i_ctime = current_fs_time(inode->i_sb);
 
         if (IS_SYNC(inode))
@@ -692,16 +722,20 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
                               kernel_long_ad laarr[EXTENT_MERGE_SIZE],
                               int *endnum)
 {
+        unsigned long blocksize = inode->i_sb->s_blocksize;
+        unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
+
         if ((laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30) ||
-            (laarr[*c].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
+            (laarr[*c].extLength >> 30) ==
+                                (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
                 int curr = *c;
                 int blen = ((laarr[curr].extLength & UDF_EXTENT_LENGTH_MASK) +
-                            inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
+                            blocksize - 1) >> blocksize_bits;
                 int8_t etype = (laarr[curr].extLength >> 30);
 
-                if (blen == 1) {
+                if (blen == 1)
                         ;
-                } else if (!offset || blen == offset + 1) {
+                else if (!offset || blen == offset + 1) {
                         laarr[curr + 2] = laarr[curr + 1];
                         laarr[curr + 1] = laarr[curr];
                 } else {
@@ -711,15 +745,18 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
 
                 if (offset) {
                         if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
-                                udf_free_blocks(inode->i_sb, inode, laarr[curr].extLocation, 0, offset);
-                                laarr[curr].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
-                                        (offset << inode->i_sb->s_blocksize_bits);
+                                udf_free_blocks(inode->i_sb, inode,
+                                                laarr[curr].extLocation,
+                                                0, offset);
+                                laarr[curr].extLength =
+                                        EXT_NOT_RECORDED_NOT_ALLOCATED |
+                                        (offset << blocksize_bits);
                                 laarr[curr].extLocation.logicalBlockNum = 0;
-                                laarr[curr].extLocation.partitionReferenceNum = 0;
-                        } else {
+                                laarr[curr].extLocation.
+                                                partitionReferenceNum = 0;
+                        } else
                                 laarr[curr].extLength = (etype << 30) |
-                                        (offset << inode->i_sb->s_blocksize_bits);
-                        }
+                                        (offset << blocksize_bits);
                         curr++;
                         (*c)++;
                         (*endnum)++;
@@ -728,16 +765,17 @@ static void udf_split_extents(struct inode *inode, int *c, int offset,
                 laarr[curr].extLocation.logicalBlockNum = newblocknum;
                 if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
                         laarr[curr].extLocation.partitionReferenceNum =
-                                UDF_I_LOCATION(inode).partitionReferenceNum;
+                                UDF_I(inode)->i_location.partitionReferenceNum;
                 laarr[curr].extLength = EXT_RECORDED_ALLOCATED |
-                        inode->i_sb->s_blocksize;
+                        blocksize;
                 curr++;
 
                 if (blen != offset + 1) {
                         if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
-                                laarr[curr].extLocation.logicalBlockNum += (offset + 1);
+                                laarr[curr].extLocation.logicalBlockNum +=
+                                                                offset + 1;
                         laarr[curr].extLength = (etype << 30) |
-                                ((blen - (offset + 1)) << inode->i_sb->s_blocksize_bits);
+                                ((blen - (offset + 1)) << blocksize_bits);
                         curr++;
                         (*endnum)++;
                 }
@@ -756,69 +794,86 @@ static void udf_prealloc_extents(struct inode *inode, int c, int lastblock,
                 else
                         start = c;
         } else {
-                if ((laarr[c + 1].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
+                if ((laarr[c + 1].extLength >> 30) ==
+                                        (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
                         start = c + 1;
-                        length = currlength = (((laarr[c + 1].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                                inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
-                } else {
+                        length = currlength =
+                                (((laarr[c + 1].extLength &
+                                        UDF_EXTENT_LENGTH_MASK) +
+                                inode->i_sb->s_blocksize - 1) >>
+                                inode->i_sb->s_blocksize_bits);
+                } else
                         start = c;
-                }
         }
 
         for (i = start + 1; i <= *endnum; i++) {
                 if (i == *endnum) {
                         if (lastblock)
                                 length += UDF_DEFAULT_PREALLOC_BLOCKS;
-                } else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
-                        length += (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                    inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
-                } else {
+                } else if ((laarr[i].extLength >> 30) ==
+                                (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) {
+                        length += (((laarr[i].extLength &
+                                                UDF_EXTENT_LENGTH_MASK) +
+                                    inode->i_sb->s_blocksize - 1) >>
+                                    inode->i_sb->s_blocksize_bits);
+                } else
                         break;
-                }
         }
 
         if (length) {
                 int next = laarr[start].extLocation.logicalBlockNum +
                         (((laarr[start].extLength & UDF_EXTENT_LENGTH_MASK) +
-                          inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
+                          inode->i_sb->s_blocksize - 1) >>
+                          inode->i_sb->s_blocksize_bits);
                 int numalloc = udf_prealloc_blocks(inode->i_sb, inode,
-                                                   laarr[start].extLocation.partitionReferenceNum,
-                                                   next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ? length :
-                                                          UDF_DEFAULT_PREALLOC_BLOCKS) - currlength);
+                                laarr[start].extLocation.partitionReferenceNum,
+                                next, (UDF_DEFAULT_PREALLOC_BLOCKS > length ?
+                                length : UDF_DEFAULT_PREALLOC_BLOCKS) -
+                                currlength);
                 if (numalloc)   {
-                        if (start == (c + 1)) {
+                        if (start == (c + 1))
                                 laarr[start].extLength +=
-                                        (numalloc << inode->i_sb->s_blocksize_bits);
-                        } else {
+                                        (numalloc <<
+                                         inode->i_sb->s_blocksize_bits);
+                        else {
                                 memmove(&laarr[c + 2], &laarr[c + 1],
                                         sizeof(long_ad) * (*endnum - (c + 1)));
                                 (*endnum)++;
                                 laarr[c + 1].extLocation.logicalBlockNum = next;
                                 laarr[c + 1].extLocation.partitionReferenceNum =
-                                        laarr[c].extLocation.partitionReferenceNum;
-                                laarr[c + 1].extLength = EXT_NOT_RECORDED_ALLOCATED |
-                                        (numalloc << inode->i_sb->s_blocksize_bits);
+                                        laarr[c].extLocation.
+                                                        partitionReferenceNum;
+                                laarr[c + 1].extLength =
+                                        EXT_NOT_RECORDED_ALLOCATED |
+                                        (numalloc <<
+                                         inode->i_sb->s_blocksize_bits);
                                 start = c + 1;
                         }
 
                         for (i = start + 1; numalloc && i < *endnum; i++) {
-                                int elen = ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                            inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
+                                int elen = ((laarr[i].extLength &
+                                                UDF_EXTENT_LENGTH_MASK) +
+                                            inode->i_sb->s_blocksize - 1) >>
+                                            inode->i_sb->s_blocksize_bits;
 
                                 if (elen > numalloc) {
                                         laarr[i].extLength -=
-                                                (numalloc << inode->i_sb->s_blocksize_bits);
+                                                (numalloc <<
+                                                 inode->i_sb->s_blocksize_bits);
                                         numalloc = 0;
                                 } else {
                                         numalloc -= elen;
                                         if (*endnum > (i + 1))
-                                                memmove(&laarr[i], &laarr[i + 1],
-                                                        sizeof(long_ad) * (*endnum - (i + 1)));
+                                                memmove(&laarr[i],
+                                                        &laarr[i + 1],
+                                                        sizeof(long_ad) *
+                                                        (*endnum - (i + 1)));
                                         i--;
                                         (*endnum)--;
                                 }
                         }
-                        UDF_I_LENEXTENTS(inode) += numalloc << inode->i_sb->s_blocksize_bits;
+                        UDF_I(inode)->i_lenExtents +=
+                                numalloc << inode->i_sb->s_blocksize_bits;
                 }
         }
 }
@@ -828,70 +883,97 @@ static void udf_merge_extents(struct inode *inode,
                               int *endnum)
 {
         int i;
+        unsigned long blocksize = inode->i_sb->s_blocksize;
+        unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
 
         for (i = 0; i < (*endnum - 1); i++) {
-                if ((laarr[i].extLength >> 30) == (laarr[i + 1].extLength >> 30)) {
-                        if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
-                            ((laarr[i + 1].extLocation.logicalBlockNum - laarr[i].extLocation.logicalBlockNum) ==
-                             (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                               inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits))) {
-                                if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                     (laarr[i + 1].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                     inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
-                                        laarr[i + 1].extLength = (laarr[i + 1].extLength -
-                                                                  (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                                                  UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize - 1);
-                                        laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
-                                                (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
-                                        laarr[i + 1].extLocation.logicalBlockNum =
-                                                laarr[i].extLocation.logicalBlockNum +
-                                                ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) >>
-                                                 inode->i_sb->s_blocksize_bits);
-                                } else {
-                                        laarr[i].extLength = laarr[i + 1].extLength +
-                                                (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                                  inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize - 1));
-                                        if (*endnum > (i + 2))
-                                                memmove(&laarr[i + 1], &laarr[i + 2],
-                                                        sizeof(long_ad) * (*endnum - (i + 2)));
-                                        i--;
-                                        (*endnum)--;
-                                }
+                kernel_long_ad *li /*l[i]*/ = &laarr[i];
+                kernel_long_ad *lip1 /*l[i plus 1]*/ = &laarr[i + 1];
+
+                if (((li->extLength >> 30) == (lip1->extLength >> 30)) &&
+                        (((li->extLength >> 30) ==
+                                (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30)) ||
+                        ((lip1->extLocation.logicalBlockNum -
+                          li->extLocation.logicalBlockNum) ==
+                        (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
+                        blocksize - 1) >> blocksize_bits)))) {
+
+                        if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
+                                (lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
+                                blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
+                                lip1->extLength = (lip1->extLength -
+                                                  (li->extLength &
+                                                   UDF_EXTENT_LENGTH_MASK) +
+                                                   UDF_EXTENT_LENGTH_MASK) &
+                                                        ~(blocksize - 1);
+                                li->extLength = (li->extLength &
+                                                 UDF_EXTENT_FLAG_MASK) +
+                                                (UDF_EXTENT_LENGTH_MASK + 1) -
+                                                blocksize;
+                                lip1->extLocation.logicalBlockNum =
+                                        li->extLocation.logicalBlockNum +
+                                        ((li->extLength &
+                                                UDF_EXTENT_LENGTH_MASK) >>
+                                                blocksize_bits);
+                        } else {
+                                li->extLength = lip1->extLength +
+                                        (((li->extLength &
+                                                UDF_EXTENT_LENGTH_MASK) +
+                                         blocksize - 1) & ~(blocksize - 1));
+                                if (*endnum > (i + 2))
+                                        memmove(&laarr[i + 1], &laarr[i + 2],
+                                                sizeof(long_ad) *
+                                                (*endnum - (i + 2)));
+                                i--;
+                                (*endnum)--;
                         }
-                } else if (((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
-                           ((laarr[i + 1].extLength >> 30) == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
-                        udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
-                                        ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                         inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
-                        laarr[i].extLocation.logicalBlockNum = 0;
-                        laarr[i].extLocation.partitionReferenceNum = 0;
-
-                        if (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                             (laarr[i + 1].extLength & UDF_EXTENT_LENGTH_MASK) +
-                             inode->i_sb->s_blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
-                                laarr[i + 1].extLength = (laarr[i + 1].extLength -
-                                                          (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                                          UDF_EXTENT_LENGTH_MASK) & ~(inode->i_sb->s_blocksize - 1);
-                                laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_FLAG_MASK) +
-                                        (UDF_EXTENT_LENGTH_MASK + 1) - inode->i_sb->s_blocksize;
+                } else if (((li->extLength >> 30) ==
+                                (EXT_NOT_RECORDED_ALLOCATED >> 30)) &&
+                           ((lip1->extLength >> 30) ==
+                                (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))) {
+                        udf_free_blocks(inode->i_sb, inode, li->extLocation, 0,
+                                        ((li->extLength &
+                                          UDF_EXTENT_LENGTH_MASK) +
+                                         blocksize - 1) >> blocksize_bits);
+                        li->extLocation.logicalBlockNum = 0;
+                        li->extLocation.partitionReferenceNum = 0;
+
+                        if (((li->extLength & UDF_EXTENT_LENGTH_MASK) +
+                             (lip1->extLength & UDF_EXTENT_LENGTH_MASK) +
+                             blocksize - 1) & ~UDF_EXTENT_LENGTH_MASK) {
+                                lip1->extLength = (lip1->extLength -
+                                                   (li->extLength &
+                                                   UDF_EXTENT_LENGTH_MASK) +
+                                                   UDF_EXTENT_LENGTH_MASK) &
+                                                   ~(blocksize - 1);
+                                li->extLength = (li->extLength &
+                                                 UDF_EXTENT_FLAG_MASK) +
+                                                (UDF_EXTENT_LENGTH_MASK + 1) -
+                                                blocksize;
                         } else {
-                                laarr[i].extLength = laarr[i + 1].extLength +
-                                        (((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                          inode->i_sb->s_blocksize - 1) & ~(inode->i_sb->s_blocksize - 1));
+                                li->extLength = lip1->extLength +
+                                        (((li->extLength &
+                                                UDF_EXTENT_LENGTH_MASK) +
+                                          blocksize - 1) & ~(blocksize - 1));
                                 if (*endnum > (i + 2))
                                         memmove(&laarr[i + 1], &laarr[i + 2],
-                                                sizeof(long_ad) * (*endnum - (i + 2)));
+                                                sizeof(long_ad) *
+                                                (*endnum - (i + 2)));
                                 i--;
                                 (*endnum)--;
                         }
-                } else if ((laarr[i].extLength >> 30) == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
-                        udf_free_blocks(inode->i_sb, inode, laarr[i].extLocation, 0,
-                                        ((laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) +
-                                         inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits);
-                        laarr[i].extLocation.logicalBlockNum = 0;
-                        laarr[i].extLocation.partitionReferenceNum = 0;
-                        laarr[i].extLength = (laarr[i].extLength & UDF_EXTENT_LENGTH_MASK) |
-                                EXT_NOT_RECORDED_NOT_ALLOCATED;
+                } else if ((li->extLength >> 30) ==
+                                        (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
+                        udf_free_blocks(inode->i_sb, inode,
+                                        li->extLocation, 0,
+                                        ((li->extLength &
+                                                UDF_EXTENT_LENGTH_MASK) +
+                                         blocksize - 1) >> blocksize_bits);
+                        li->extLocation.logicalBlockNum = 0;
+                        li->extLocation.partitionReferenceNum = 0;
+                        li->extLength = (li->extLength &
+                                                UDF_EXTENT_LENGTH_MASK) |
+                                                EXT_NOT_RECORDED_NOT_ALLOCATED;
                 }
         }
 }
@@ -953,6 +1035,7 @@ void udf_truncate(struct inode *inode)
 {
         int offset;
         int err;
+        struct udf_inode_info *iinfo;
 
         if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
               S_ISLNK(inode->i_mode)))
@@ -961,25 +1044,28 @@ void udf_truncate(struct inode *inode)
                 return;
 
         lock_kernel();
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
-                if (inode->i_sb->s_blocksize < (udf_file_entry_alloc_offset(inode) +
-                                                inode->i_size)) {
+        iinfo = UDF_I(inode);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                if (inode->i_sb->s_blocksize <
+                                (udf_file_entry_alloc_offset(inode) +
+                                 inode->i_size)) {
                         udf_expand_file_adinicb(inode, inode->i_size, &err);
-                        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
-                                inode->i_size = UDF_I_LENALLOC(inode);
+                        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                                inode->i_size = iinfo->i_lenAlloc;
                                 unlock_kernel();
                                 return;
-                        } else {
+                        } else
                                 udf_truncate_extents(inode);
-                        }
                 } else {
                         offset = inode->i_size & (inode->i_sb->s_blocksize - 1);
-                        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode) + offset, 0x00,
-                               inode->i_sb->s_blocksize - offset - udf_file_entry_alloc_offset(inode));
-                        UDF_I_LENALLOC(inode) = inode->i_size;
+                        memset(iinfo->i_ext.i_data + iinfo->i_lenEAttr + offset,
+                                0x00, inode->i_sb->s_blocksize -
+                                offset - udf_file_entry_alloc_offset(inode));
+                        iinfo->i_lenAlloc = inode->i_size;
                 }
         } else {
-                block_truncate_page(inode->i_mapping, inode->i_size, udf_get_block);
+                block_truncate_page(inode->i_mapping, inode->i_size,
+                                    udf_get_block);
                 udf_truncate_extents(inode);
         }
 
@@ -996,6 +1082,7 @@ static void __udf_read_inode(struct inode *inode)
         struct buffer_head *bh = NULL;
         struct fileEntry *fe;
         uint16_t ident;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         /*
          * Set defaults, but the inode is still incomplete!
@@ -1009,7 +1096,7 @@ static void __udf_read_inode(struct inode *inode)
          *      i_nlink = 1
          *      i_op = NULL;
          */
-        bh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 0, &ident);
+        bh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 0, &ident);
         if (!bh) {
                 printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed !bh\n",
                        inode->i_ino);
@@ -1019,8 +1106,8 @@ static void __udf_read_inode(struct inode *inode)
 
         if (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE &&
             ident != TAG_IDENT_USE) {
-                printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
-                       inode->i_ino, ident);
+                printk(KERN_ERR "udf: udf_read_inode(ino %ld) "
+                                "failed ident=%d\n", inode->i_ino, ident);
                 brelse(bh);
                 make_bad_inode(inode);
                 return;
@@ -1028,11 +1115,12 @@ static void __udf_read_inode(struct inode *inode)
 
         fe = (struct fileEntry *)bh->b_data;
 
-        if (le16_to_cpu(fe->icbTag.strategyType) == 4096) {
+        if (fe->icbTag.strategyType == cpu_to_le16(4096)) {
                 struct buffer_head *ibh = NULL, *nbh = NULL;
                 struct indirectEntry *ie;
 
-                ibh = udf_read_ptagged(inode->i_sb, UDF_I_LOCATION(inode), 1, &ident);
+                ibh = udf_read_ptagged(inode->i_sb, iinfo->i_location, 1,
+                                        &ident);
                 if (ident == TAG_IDENT_IE) {
                         if (ibh) {
                                 kernel_lb_addr loc;
@@ -1041,10 +1129,12 @@ static void __udf_read_inode(struct inode *inode)
                                 loc = lelb_to_cpu(ie->indirectICB.extLocation);
 
                                 if (ie->indirectICB.extLength &&
-                                    (nbh = udf_read_ptagged(inode->i_sb, loc, 0, &ident))) {
+                                    (nbh = udf_read_ptagged(inode->i_sb, loc, 0,
+                                                            &ident))) {
                                         if (ident == TAG_IDENT_FE ||
                                             ident == TAG_IDENT_EFE) {
-                                                memcpy(&UDF_I_LOCATION(inode), &loc,
+                                                memcpy(&iinfo->i_location,
+                                                       &loc,
                                                        sizeof(kernel_lb_addr));
                                                 brelse(bh);
                                                 brelse(ibh);
@@ -1062,7 +1152,7 @@ static void __udf_read_inode(struct inode *inode)
                 } else {
                         brelse(ibh);
                 }
-        } else if (le16_to_cpu(fe->icbTag.strategyType) != 4) {
+        } else if (fe->icbTag.strategyType != cpu_to_le16(4)) {
                 printk(KERN_ERR "udf: unsupported strategy type: %d\n",
                        le16_to_cpu(fe->icbTag.strategyType));
                 brelse(bh);
@@ -1081,51 +1171,63 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         time_t convtime;
         long convtime_usec;
         int offset;
+        struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         fe = (struct fileEntry *)bh->b_data;
         efe = (struct extendedFileEntry *)bh->b_data;
 
-        if (le16_to_cpu(fe->icbTag.strategyType) == 4)
-                UDF_I_STRAT4096(inode) = 0;
-        else /* if (le16_to_cpu(fe->icbTag.strategyType) == 4096) */
-                UDF_I_STRAT4096(inode) = 1;
-
-        UDF_I_ALLOCTYPE(inode) = le16_to_cpu(fe->icbTag.flags) & ICBTAG_FLAG_AD_MASK;
-        UDF_I_UNIQUE(inode) = 0;
-        UDF_I_LENEATTR(inode) = 0;
-        UDF_I_LENEXTENTS(inode) = 0;
-        UDF_I_LENALLOC(inode) = 0;
-        UDF_I_NEXT_ALLOC_BLOCK(inode) = 0;
-        UDF_I_NEXT_ALLOC_GOAL(inode) = 0;
-        if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_EFE) {
-                UDF_I_EFE(inode) = 1;
-                UDF_I_USE(inode) = 0;
-                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry))) {
+        if (fe->icbTag.strategyType == cpu_to_le16(4))
+                iinfo->i_strat4096 = 0;
+        else /* if (fe->icbTag.strategyType == cpu_to_le16(4096)) */
+                iinfo->i_strat4096 = 1;
+
+        iinfo->i_alloc_type = le16_to_cpu(fe->icbTag.flags) &
+                                                        ICBTAG_FLAG_AD_MASK;
+        iinfo->i_unique = 0;
+        iinfo->i_lenEAttr = 0;
+        iinfo->i_lenExtents = 0;
+        iinfo->i_lenAlloc = 0;
+        iinfo->i_next_alloc_block = 0;
+        iinfo->i_next_alloc_goal = 0;
+        if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_EFE)) {
+                iinfo->i_efe = 1;
+                iinfo->i_use = 0;
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
+                                        sizeof(struct extendedFileEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct extendedFileEntry),
-                       inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
-        } else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_FE) {
-                UDF_I_EFE(inode) = 0;
-                UDF_I_USE(inode) = 0;
-                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct fileEntry))) {
+                memcpy(iinfo->i_ext.i_data,
+                       bh->b_data + sizeof(struct extendedFileEntry),
+                       inode->i_sb->s_blocksize -
+                                        sizeof(struct extendedFileEntry));
+        } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_FE)) {
+                iinfo->i_efe = 0;
+                iinfo->i_use = 0;
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
+                                                sizeof(struct fileEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct fileEntry),
+                memcpy(iinfo->i_ext.i_data,
+                       bh->b_data + sizeof(struct fileEntry),
                        inode->i_sb->s_blocksize - sizeof(struct fileEntry));
-        } else if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) {
-                UDF_I_EFE(inode) = 0;
-                UDF_I_USE(inode) = 1;
-                UDF_I_LENALLOC(inode) =
-                    le32_to_cpu(((struct unallocSpaceEntry *)bh->b_data)->lengthAllocDescs);
-                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry))) {
+        } else if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
+                iinfo->i_efe = 0;
+                iinfo->i_use = 1;
+                iinfo->i_lenAlloc = le32_to_cpu(
+                                ((struct unallocSpaceEntry *)bh->b_data)->
+                                 lengthAllocDescs);
+                if (udf_alloc_i_data(inode, inode->i_sb->s_blocksize -
+                                        sizeof(struct unallocSpaceEntry))) {
                         make_bad_inode(inode);
                         return;
                 }
-                memcpy(UDF_I_DATA(inode), bh->b_data + sizeof(struct unallocSpaceEntry),
-                       inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
+                memcpy(iinfo->i_ext.i_data,
+                       bh->b_data + sizeof(struct unallocSpaceEntry),
+                       inode->i_sb->s_blocksize -
+                                        sizeof(struct unallocSpaceEntry));
                 return;
         }
 
@@ -1146,12 +1248,12 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                 inode->i_nlink = 1;
 
         inode->i_size = le64_to_cpu(fe->informationLength);
-        UDF_I_LENEXTENTS(inode) = inode->i_size;
+        iinfo->i_lenExtents = inode->i_size;
 
         inode->i_mode = udf_convert_permissions(fe);
         inode->i_mode &= ~UDF_SB(inode->i_sb)->s_umask;
 
-        if (UDF_I_EFE(inode) == 0) {
+        if (iinfo->i_efe == 0) {
                 inode->i_blocks = le64_to_cpu(fe->logicalBlocksRecorded) <<
                         (inode->i_sb->s_blocksize_bits - 9);
 
@@ -1160,7 +1262,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_atime.tv_sec = convtime;
                         inode->i_atime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
+                        inode->i_atime = sbi->s_record_time;
                 }
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1168,7 +1270,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_mtime.tv_sec = convtime;
                         inode->i_mtime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
+                        inode->i_mtime = sbi->s_record_time;
                 }
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1176,13 +1278,13 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_ctime.tv_sec = convtime;
                         inode->i_ctime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
+                        inode->i_ctime = sbi->s_record_time;
                 }
 
-                UDF_I_UNIQUE(inode) = le64_to_cpu(fe->uniqueID);
-                UDF_I_LENEATTR(inode) = le32_to_cpu(fe->lengthExtendedAttr);
-                UDF_I_LENALLOC(inode) = le32_to_cpu(fe->lengthAllocDescs);
-                offset = sizeof(struct fileEntry) + UDF_I_LENEATTR(inode);
+                iinfo->i_unique = le64_to_cpu(fe->uniqueID);
+                iinfo->i_lenEAttr = le32_to_cpu(fe->lengthExtendedAttr);
+                iinfo->i_lenAlloc = le32_to_cpu(fe->lengthAllocDescs);
+                offset = sizeof(struct fileEntry) + iinfo->i_lenEAttr;
         } else {
                 inode->i_blocks = le64_to_cpu(efe->logicalBlocksRecorded) <<
                     (inode->i_sb->s_blocksize_bits - 9);
@@ -1192,7 +1294,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_atime.tv_sec = convtime;
                         inode->i_atime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        inode->i_atime = UDF_SB_RECORDTIME(inode->i_sb);
+                        inode->i_atime = sbi->s_record_time;
                 }
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1200,15 +1302,15 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_mtime.tv_sec = convtime;
                         inode->i_mtime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        inode->i_mtime = UDF_SB_RECORDTIME(inode->i_sb);
+                        inode->i_mtime = sbi->s_record_time;
                 }
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
                                       lets_to_cpu(efe->createTime))) {
-                        UDF_I_CRTIME(inode).tv_sec = convtime;
-                        UDF_I_CRTIME(inode).tv_nsec = convtime_usec * 1000;
+                        iinfo->i_crtime.tv_sec = convtime;
+                        iinfo->i_crtime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        UDF_I_CRTIME(inode) = UDF_SB_RECORDTIME(inode->i_sb);
+                        iinfo->i_crtime = sbi->s_record_time;
                 }
 
                 if (udf_stamp_to_time(&convtime, &convtime_usec,
@@ -1216,13 +1318,14 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                         inode->i_ctime.tv_sec = convtime;
                         inode->i_ctime.tv_nsec = convtime_usec * 1000;
                 } else {
-                        inode->i_ctime = UDF_SB_RECORDTIME(inode->i_sb);
+                        inode->i_ctime = sbi->s_record_time;
                 }
 
-                UDF_I_UNIQUE(inode) = le64_to_cpu(efe->uniqueID);
-                UDF_I_LENEATTR(inode) = le32_to_cpu(efe->lengthExtendedAttr);
-                UDF_I_LENALLOC(inode) = le32_to_cpu(efe->lengthAllocDescs);
-                offset = sizeof(struct extendedFileEntry) + UDF_I_LENEATTR(inode);
+                iinfo->i_unique = le64_to_cpu(efe->uniqueID);
+                iinfo->i_lenEAttr = le32_to_cpu(efe->lengthExtendedAttr);
+                iinfo->i_lenAlloc = le32_to_cpu(efe->lengthAllocDescs);
+                offset = sizeof(struct extendedFileEntry) +
+                                                        iinfo->i_lenEAttr;
         }
 
         switch (fe->icbTag.fileType) {
@@ -1235,7 +1338,7 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
         case ICBTAG_FILE_TYPE_REALTIME:
         case ICBTAG_FILE_TYPE_REGULAR:
         case ICBTAG_FILE_TYPE_UNDEF:
-                if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
+                if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                         inode->i_data.a_ops = &udf_adinicb_aops;
                 else
                         inode->i_data.a_ops = &udf_aops;
@@ -1261,31 +1364,33 @@ static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
                 inode->i_mode = S_IFLNK | S_IRWXUGO;
                 break;
         default:
-                printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown file type=%d\n",
-                       inode->i_ino, fe->icbTag.fileType);
+                printk(KERN_ERR "udf: udf_fill_inode(ino %ld) failed unknown "
+                                "file type=%d\n", inode->i_ino,
+                                fe->icbTag.fileType);
                 make_bad_inode(inode);
                 return;
         }
         if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
-                struct deviceSpec *dsea = (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
+                struct deviceSpec *dsea =
+                        (struct deviceSpec *)udf_get_extendedattr(inode, 12, 1);
                 if (dsea) {
                         init_special_inode(inode, inode->i_mode,
-                                           MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
-                                                 le32_to_cpu(dsea->minorDeviceIdent)));
+                                MKDEV(le32_to_cpu(dsea->majorDeviceIdent),
+                                      le32_to_cpu(dsea->minorDeviceIdent)));
                         /* Developer ID ??? */
-                } else {
+                } else
                         make_bad_inode(inode);
-                }
         }
 }
 
 static int udf_alloc_i_data(struct inode *inode, size_t size)
 {
-        UDF_I_DATA(inode) = kmalloc(size, GFP_KERNEL);
+        struct udf_inode_info *iinfo = UDF_I(inode);
+        iinfo->i_ext.i_data = kmalloc(size, GFP_KERNEL);
 
-        if (!UDF_I_DATA(inode)) {
-                printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) no free memory\n",
-                       inode->i_ino);
+        if (!iinfo->i_ext.i_data) {
+                printk(KERN_ERR "udf:udf_alloc_i_data (ino %ld) "
+                                "no free memory\n", inode->i_ino);
                 return -ENOMEM;
         }
 
@@ -1301,12 +1406,12 @@ static mode_t udf_convert_permissions(struct fileEntry *fe)
         permissions = le32_to_cpu(fe->permissions);
         flags = le16_to_cpu(fe->icbTag.flags);
 
-        mode =  (( permissions      ) & S_IRWXO) |
-                (( permissions >> 2 ) & S_IRWXG) |
-                (( permissions >> 4 ) & S_IRWXU) |
-                (( flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
-                (( flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
-                (( flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
+        mode =  ((permissions) & S_IRWXO) |
+                ((permissions >> 2) & S_IRWXG) |
+                ((permissions >> 4) & S_IRWXU) |
+                ((flags & ICBTAG_FLAG_SETUID) ? S_ISUID : 0) |
+                ((flags & ICBTAG_FLAG_SETGID) ? S_ISGID : 0) |
+                ((flags & ICBTAG_FLAG_STICKY) ? S_ISVTX : 0);
 
         return mode;
 }
@@ -1350,11 +1455,15 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         uint32_t udfperms;
         uint16_t icbflags;
         uint16_t crclen;
-        int i;
         kernel_timestamp cpu_time;
         int err = 0;
+        struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
+        unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
-        bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, UDF_I_LOCATION(inode), 0));
+        bh = udf_tread(inode->i_sb,
+                        udf_get_lb_pblock(inode->i_sb,
+                                          iinfo->i_location, 0));
         if (!bh) {
                 udf_debug("bread failure\n");
                 return -EIO;
@@ -1365,23 +1474,24 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         fe = (struct fileEntry *)bh->b_data;
         efe = (struct extendedFileEntry *)bh->b_data;
 
-        if (le16_to_cpu(fe->descTag.tagIdent) == TAG_IDENT_USE) {
+        if (fe->descTag.tagIdent == cpu_to_le16(TAG_IDENT_USE)) {
                 struct unallocSpaceEntry *use =
                         (struct unallocSpaceEntry *)bh->b_data;
 
-                use->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
-                memcpy(bh->b_data + sizeof(struct unallocSpaceEntry), UDF_I_DATA(inode),
-                       inode->i_sb->s_blocksize - sizeof(struct unallocSpaceEntry));
-                crclen = sizeof(struct unallocSpaceEntry) + UDF_I_LENALLOC(inode) - sizeof(tag);
-                use->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
+                use->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
+                memcpy(bh->b_data + sizeof(struct unallocSpaceEntry),
+                       iinfo->i_ext.i_data, inode->i_sb->s_blocksize -
+                                        sizeof(struct unallocSpaceEntry));
+                crclen = sizeof(struct unallocSpaceEntry) +
+                                iinfo->i_lenAlloc - sizeof(tag);
+                use->descTag.tagLocation = cpu_to_le32(
+                                                iinfo->i_location.
+                                                        logicalBlockNum);
                 use->descTag.descCRCLength = cpu_to_le16(crclen);
-                use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use + sizeof(tag), crclen, 0));
-
-                use->descTag.tagChecksum = 0;
-                for (i = 0; i < 16; i++) {
-                        if (i != 4)
-                                use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];
-                }
+                use->descTag.descCRC = cpu_to_le16(udf_crc((char *)use +
+                                                           sizeof(tag), crclen,
+                                                           0));
+                use->descTag.tagChecksum = udf_tag_checksum(&use->descTag);
 
                 mark_buffer_dirty(bh);
                 brelse(bh);
@@ -1398,14 +1508,14 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         else
                 fe->gid = cpu_to_le32(inode->i_gid);
 
-        udfperms =      ((inode->i_mode & S_IRWXO)     ) |
-                        ((inode->i_mode & S_IRWXG) << 2) |
-                        ((inode->i_mode & S_IRWXU) << 4);
+        udfperms = ((inode->i_mode & S_IRWXO)) |
+                   ((inode->i_mode & S_IRWXG) << 2) |
+                   ((inode->i_mode & S_IRWXU) << 4);
 
-        udfperms |=     (le32_to_cpu(fe->permissions) &
-                        (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
-                         FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
-                         FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
+        udfperms |= (le32_to_cpu(fe->permissions) &
+                    (FE_PERM_O_DELETE | FE_PERM_O_CHATTR |
+                     FE_PERM_G_DELETE | FE_PERM_G_CHATTR |
+                     FE_PERM_U_DELETE | FE_PERM_U_CHATTR));
         fe->permissions = cpu_to_le32(udfperms);
 
         if (S_ISDIR(inode->i_mode))
@@ -1426,8 +1536,9 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                                                      sizeof(regid), 12, 0x3);
                         dsea->attrType = cpu_to_le32(12);
                         dsea->attrSubtype = 1;
-                        dsea->attrLength = cpu_to_le32(sizeof(struct deviceSpec) +
-                                                       sizeof(regid));
+                        dsea->attrLength = cpu_to_le32(
+                                                sizeof(struct deviceSpec) +
+                                                sizeof(regid));
                         dsea->impUseLength = cpu_to_le32(sizeof(regid));
                 }
                 eid = (regid *)dsea->impUse;
@@ -1439,12 +1550,13 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 dsea->minorDeviceIdent = cpu_to_le32(iminor(inode));
         }
 
-        if (UDF_I_EFE(inode) == 0) {
-                memcpy(bh->b_data + sizeof(struct fileEntry), UDF_I_DATA(inode),
+        if (iinfo->i_efe == 0) {
+                memcpy(bh->b_data + sizeof(struct fileEntry),
+                       iinfo->i_ext.i_data,
                        inode->i_sb->s_blocksize - sizeof(struct fileEntry));
                 fe->logicalBlocksRecorded = cpu_to_le64(
-                        (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
-                        (inode->i_sb->s_blocksize_bits - 9));
+                        (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
+                        (blocksize_bits - 9));
 
                 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
                         fe->accessTime = cpu_to_lets(cpu_time);
@@ -1456,40 +1568,41 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 strcpy(fe->impIdent.ident, UDF_ID_DEVELOPER);
                 fe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
                 fe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
-                fe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
-                fe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
-                fe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
+                fe->uniqueID = cpu_to_le64(iinfo->i_unique);
+                fe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
+                fe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
                 fe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_FE);
                 crclen = sizeof(struct fileEntry);
         } else {
-                memcpy(bh->b_data + sizeof(struct extendedFileEntry), UDF_I_DATA(inode),
-                       inode->i_sb->s_blocksize - sizeof(struct extendedFileEntry));
+                memcpy(bh->b_data + sizeof(struct extendedFileEntry),
+                       iinfo->i_ext.i_data,
+                       inode->i_sb->s_blocksize -
+                                        sizeof(struct extendedFileEntry));
                 efe->objectSize = cpu_to_le64(inode->i_size);
                 efe->logicalBlocksRecorded = cpu_to_le64(
-                        (inode->i_blocks + (1 << (inode->i_sb->s_blocksize_bits - 9)) - 1) >>
-                        (inode->i_sb->s_blocksize_bits - 9));
+                        (inode->i_blocks + (1 << (blocksize_bits - 9)) - 1) >>
+                        (blocksize_bits - 9));
 
-                if (UDF_I_CRTIME(inode).tv_sec > inode->i_atime.tv_sec ||
-                    (UDF_I_CRTIME(inode).tv_sec == inode->i_atime.tv_sec &&
-                     UDF_I_CRTIME(inode).tv_nsec > inode->i_atime.tv_nsec)) {
-                        UDF_I_CRTIME(inode) = inode->i_atime;
-                }
-                if (UDF_I_CRTIME(inode).tv_sec > inode->i_mtime.tv_sec ||
-                    (UDF_I_CRTIME(inode).tv_sec == inode->i_mtime.tv_sec &&
-                     UDF_I_CRTIME(inode).tv_nsec > inode->i_mtime.tv_nsec)) {
-                        UDF_I_CRTIME(inode) = inode->i_mtime;
-                }
-                if (UDF_I_CRTIME(inode).tv_sec > inode->i_ctime.tv_sec ||
-                    (UDF_I_CRTIME(inode).tv_sec == inode->i_ctime.tv_sec &&
-                     UDF_I_CRTIME(inode).tv_nsec > inode->i_ctime.tv_nsec)) {
-                        UDF_I_CRTIME(inode) = inode->i_ctime;
-                }
+                if (iinfo->i_crtime.tv_sec > inode->i_atime.tv_sec ||
+                    (iinfo->i_crtime.tv_sec == inode->i_atime.tv_sec &&
+                     iinfo->i_crtime.tv_nsec > inode->i_atime.tv_nsec))
+                        iinfo->i_crtime = inode->i_atime;
+
+                if (iinfo->i_crtime.tv_sec > inode->i_mtime.tv_sec ||
+                    (iinfo->i_crtime.tv_sec == inode->i_mtime.tv_sec &&
+                     iinfo->i_crtime.tv_nsec > inode->i_mtime.tv_nsec))
+                        iinfo->i_crtime = inode->i_mtime;
+
+                if (iinfo->i_crtime.tv_sec > inode->i_ctime.tv_sec ||
+                    (iinfo->i_crtime.tv_sec == inode->i_ctime.tv_sec &&
+                     iinfo->i_crtime.tv_nsec > inode->i_ctime.tv_nsec))
+                        iinfo->i_crtime = inode->i_ctime;
 
                 if (udf_time_to_stamp(&cpu_time, inode->i_atime))
                         efe->accessTime = cpu_to_lets(cpu_time);
                 if (udf_time_to_stamp(&cpu_time, inode->i_mtime))
                         efe->modificationTime = cpu_to_lets(cpu_time);
-                if (udf_time_to_stamp(&cpu_time, UDF_I_CRTIME(inode)))
+                if (udf_time_to_stamp(&cpu_time, iinfo->i_crtime))
                         efe->createTime = cpu_to_lets(cpu_time);
                 if (udf_time_to_stamp(&cpu_time, inode->i_ctime))
                         efe->attrTime = cpu_to_lets(cpu_time);
@@ -1498,13 +1611,13 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                 strcpy(efe->impIdent.ident, UDF_ID_DEVELOPER);
                 efe->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
                 efe->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
-                efe->uniqueID = cpu_to_le64(UDF_I_UNIQUE(inode));
-                efe->lengthExtendedAttr = cpu_to_le32(UDF_I_LENEATTR(inode));
-                efe->lengthAllocDescs = cpu_to_le32(UDF_I_LENALLOC(inode));
+                efe->uniqueID = cpu_to_le64(iinfo->i_unique);
+                efe->lengthExtendedAttr = cpu_to_le32(iinfo->i_lenEAttr);
+                efe->lengthAllocDescs = cpu_to_le32(iinfo->i_lenAlloc);
                 efe->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EFE);
                 crclen = sizeof(struct extendedFileEntry);
         }
-        if (UDF_I_STRAT4096(inode)) {
+        if (iinfo->i_strat4096) {
                 fe->icbTag.strategyType = cpu_to_le16(4096);
                 fe->icbTag.strategyParameter = cpu_to_le16(1);
                 fe->icbTag.numEntries = cpu_to_le16(2);
@@ -1528,7 +1641,7 @@ static int udf_update_inode(struct inode *inode, int do_sync)
         else if (S_ISSOCK(inode->i_mode))
                 fe->icbTag.fileType = ICBTAG_FILE_TYPE_SOCKET;
 
-        icbflags =      UDF_I_ALLOCTYPE(inode) |
+        icbflags =      iinfo->i_alloc_type |
                         ((inode->i_mode & S_ISUID) ? ICBTAG_FLAG_SETUID : 0) |
                         ((inode->i_mode & S_ISGID) ? ICBTAG_FLAG_SETGID : 0) |
                         ((inode->i_mode & S_ISVTX) ? ICBTAG_FLAG_STICKY : 0) |
@@ -1537,29 +1650,28 @@ static int udf_update_inode(struct inode *inode, int do_sync)
                                 ICBTAG_FLAG_SETGID | ICBTAG_FLAG_STICKY));
 
         fe->icbTag.flags = cpu_to_le16(icbflags);
-        if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
+        if (sbi->s_udfrev >= 0x0200)
                 fe->descTag.descVersion = cpu_to_le16(3);
         else
                 fe->descTag.descVersion = cpu_to_le16(2);
-        fe->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
-        fe->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
-        crclen += UDF_I_LENEATTR(inode) + UDF_I_LENALLOC(inode) - sizeof(tag);
+        fe->descTag.tagSerialNum = cpu_to_le16(sbi->s_serial_number);
+        fe->descTag.tagLocation = cpu_to_le32(
+                                        iinfo->i_location.logicalBlockNum);
+        crclen += iinfo->i_lenEAttr + iinfo->i_lenAlloc -
+                                                                sizeof(tag);
         fe->descTag.descCRCLength = cpu_to_le16(crclen);
-        fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag), crclen, 0));
-
-        fe->descTag.tagChecksum = 0;
-        for (i = 0; i < 16; i++) {
-                if (i != 4)
-                        fe->descTag.tagChecksum += ((uint8_t *)&(fe->descTag))[i];
-        }
+        fe->descTag.descCRC = cpu_to_le16(udf_crc((char *)fe + sizeof(tag),
+                                                  crclen, 0));
+        fe->descTag.tagChecksum = udf_tag_checksum(&fe->descTag);
 
         /* write the data blocks */
         mark_buffer_dirty(bh);
         if (do_sync) {
                 sync_dirty_buffer(bh);
                 if (buffer_req(bh) && !buffer_uptodate(bh)) {
-                        printk("IO error syncing udf inode [%s:%08lx]\n",
-                               inode->i_sb->s_id, inode->i_ino);
+                        printk(KERN_WARNING "IO error syncing udf inode "
+                                "[%s:%08lx]\n", inode->i_sb->s_id,
+                                inode->i_ino);
                         err = -EIO;
                 }
         }
@@ -1577,7 +1689,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
                 return NULL;
 
         if (inode->i_state & I_NEW) {
-                memcpy(&UDF_I_LOCATION(inode), &ino, sizeof(kernel_lb_addr));
+                memcpy(&UDF_I(inode)->i_location, &ino, sizeof(kernel_lb_addr));
                 __udf_read_inode(inode);
                 unlock_new_inode(inode);
         }
@@ -1585,7 +1697,8 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
         if (is_bad_inode(inode))
                 goto out_iput;
 
-        if (ino.logicalBlockNum >= UDF_SB_PARTLEN(sb, ino.partitionReferenceNum)) {
+        if (ino.logicalBlockNum >= UDF_SB(sb)->
+                        s_partmaps[ino.partitionReferenceNum].s_partition_len) {
                 udf_debug("block=%d, partition=%d out of range\n",
                           ino.logicalBlockNum, ino.partitionReferenceNum);
                 make_bad_inode(inode);
@@ -1599,7 +1712,7 @@ struct inode *udf_iget(struct super_block *sb, kernel_lb_addr ino)
         return NULL;
 }
 
-int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
+int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
                     kernel_lb_addr eloc, uint32_t elen, int inc)
 {
         int adsize;
@@ -1608,15 +1721,18 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
         struct allocExtDesc *aed;
         int8_t etype;
         uint8_t *ptr;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (!epos->bh)
-                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
+                ptr = iinfo->i_ext.i_data + epos->offset -
+                        udf_file_entry_alloc_offset(inode) +
+                        iinfo->i_lenEAttr;
         else
                 ptr = epos->bh->b_data + epos->offset;
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 return -1;
@@ -1627,15 +1743,16 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
                 int err, loffset;
                 kernel_lb_addr obloc = epos->block;
 
-                if (!(epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
-                                                                  obloc.partitionReferenceNum,
-                                                                  obloc.logicalBlockNum, &err))) {
+                epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
+                                                obloc.partitionReferenceNum,
+                                                obloc.logicalBlockNum, &err);
+                if (!epos->block.logicalBlockNum)
                         return -1;
-                }
-                if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
-                                                                       epos->block, 0)))) {
+                nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
+                                                                 epos->block,
+                                                                 0));
+                if (!nbh)
                         return -1;
-                }
                 lock_buffer(nbh);
                 memset(nbh->b_data, 0x00, inode->i_sb->s_blocksize);
                 set_buffer_uptodate(nbh);
@@ -1644,7 +1761,8 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
 
                 aed = (struct allocExtDesc *)(nbh->b_data);
                 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
-                        aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
+                        aed->previousAllocExtLocation =
+                                        cpu_to_le32(obloc.logicalBlockNum);
                 if (epos->offset + adsize > inode->i_sb->s_blocksize) {
                         loffset = epos->offset;
                         aed->lengthAllocDescs = cpu_to_le32(adsize);
@@ -1661,24 +1779,26 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
                         if (epos->bh) {
                                 aed = (struct allocExtDesc *)epos->bh->b_data;
                                 aed->lengthAllocDescs =
-                                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
+                                        cpu_to_le32(le32_to_cpu(
+                                        aed->lengthAllocDescs) + adsize);
                         } else {
-                                UDF_I_LENALLOC(inode) += adsize;
+                                iinfo->i_lenAlloc += adsize;
                                 mark_inode_dirty(inode);
                         }
                 }
-                if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
+                if (UDF_SB(inode->i_sb)->s_udfrev >= 0x0200)
                         udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
                                     epos->block.logicalBlockNum, sizeof(tag));
                 else
                         udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
                                     epos->block.logicalBlockNum, sizeof(tag));
-                switch (UDF_I_ALLOCTYPE(inode)) {
+                switch (iinfo->i_alloc_type) {
                 case ICBTAG_FLAG_AD_SHORT:
                         sad = (short_ad *)sptr;
                         sad->extLength = cpu_to_le32(EXT_NEXT_EXTENT_ALLOCDECS |
                                                      inode->i_sb->s_blocksize);
-                        sad->extPosition = cpu_to_le32(epos->block.logicalBlockNum);
+                        sad->extPosition =
+                                cpu_to_le32(epos->block.logicalBlockNum);
                         break;
                 case ICBTAG_FLAG_AD_LONG:
                         lad = (long_ad *)sptr;
@@ -1690,10 +1810,11 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
                 }
                 if (epos->bh) {
                         if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
-                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                            UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
                                 udf_update_tag(epos->bh->b_data, loffset);
                         else
-                                udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
+                                udf_update_tag(epos->bh->b_data,
+                                                sizeof(struct allocExtDesc));
                         mark_buffer_dirty_inode(epos->bh, inode);
                         brelse(epos->bh);
                 } else {
@@ -1705,36 +1826,43 @@ int8_t udf_add_aext(struct inode * inode, struct extent_position * epos,
         etype = udf_write_aext(inode, epos, eloc, elen, inc);
 
         if (!epos->bh) {
-                UDF_I_LENALLOC(inode) += adsize;
+                iinfo->i_lenAlloc += adsize;
                 mark_inode_dirty(inode);
         } else {
                 aed = (struct allocExtDesc *)epos->bh->b_data;
                 aed->lengthAllocDescs =
-                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
-                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
-                        udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
+                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) +
+                                    adsize);
+                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
+                                UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
+                        udf_update_tag(epos->bh->b_data,
+                                        epos->offset + (inc ? 0 : adsize));
                 else
-                        udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
+                        udf_update_tag(epos->bh->b_data,
+                                        sizeof(struct allocExtDesc));
                 mark_buffer_dirty_inode(epos->bh, inode);
         }
 
         return etype;
 }
 
-int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,
+int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
                       kernel_lb_addr eloc, uint32_t elen, int inc)
 {
         int adsize;
         uint8_t *ptr;
         short_ad *sad;
         long_ad *lad;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (!epos->bh)
-                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
+                ptr = iinfo->i_ext.i_data + epos->offset -
+                        udf_file_entry_alloc_offset(inode) +
+                        iinfo->i_lenEAttr;
         else
                 ptr = epos->bh->b_data + epos->offset;
 
-        switch (UDF_I_ALLOCTYPE(inode)) {
+        switch (iinfo->i_alloc_type) {
         case ICBTAG_FLAG_AD_SHORT:
                 sad = (short_ad *)ptr;
                 sad->extLength = cpu_to_le32(elen);
@@ -1754,10 +1882,12 @@ int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,
 
         if (epos->bh) {
                 if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
-                    UDF_SB_UDFREV(inode->i_sb) >= 0x0201) {
-                        struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
+                    UDF_SB(inode->i_sb)->s_udfrev >= 0x0201) {
+                        struct allocExtDesc *aed =
+                                (struct allocExtDesc *)epos->bh->b_data;
                         udf_update_tag(epos->bh->b_data,
-                                       le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
+                                       le32_to_cpu(aed->lengthAllocDescs) +
+                                       sizeof(struct allocExtDesc));
                 }
                 mark_buffer_dirty_inode(epos->bh, inode);
         } else {
@@ -1770,19 +1900,21 @@ int8_t udf_write_aext(struct inode * inode, struct extent_position * epos,
         return (elen >> 30);
 }
 
-int8_t udf_next_aext(struct inode * inode, struct extent_position * epos,
-                     kernel_lb_addr * eloc, uint32_t * elen, int inc)
+int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
+                     kernel_lb_addr *eloc, uint32_t *elen, int inc)
 {
         int8_t etype;
 
         while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
                (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
+                int block;
                 epos->block = *eloc;
                 epos->offset = sizeof(struct allocExtDesc);
                 brelse(epos->bh);
-                if (!(epos->bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, epos->block, 0)))) {
-                        udf_debug("reading block %d failed!\n",
-                                  udf_get_lb_pblock(inode->i_sb, epos->block, 0));
+                block = udf_get_lb_pblock(inode->i_sb, epos->block, 0);
+                epos->bh = udf_tread(inode->i_sb, block);
+                if (!epos->bh) {
+                        udf_debug("reading block %d failed!\n", block);
                         return -1;
                 }
         }
@@ -1790,47 +1922,55 @@ int8_t udf_next_aext(struct inode * inode, struct extent_position * epos,
         return etype;
 }
 
-int8_t udf_current_aext(struct inode * inode, struct extent_position * epos,
-                        kernel_lb_addr * eloc, uint32_t * elen, int inc)
+int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
+                        kernel_lb_addr *eloc, uint32_t *elen, int inc)
 {
         int alen;
         int8_t etype;
         uint8_t *ptr;
         short_ad *sad;
         long_ad *lad;
-
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
         if (!epos->bh) {
                 if (!epos->offset)
                         epos->offset = udf_file_entry_alloc_offset(inode);
-                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
-                alen = udf_file_entry_alloc_offset(inode) + UDF_I_LENALLOC(inode);
+                ptr = iinfo->i_ext.i_data + epos->offset -
+                        udf_file_entry_alloc_offset(inode) +
+                        iinfo->i_lenEAttr;
+                alen = udf_file_entry_alloc_offset(inode) +
+                                                        iinfo->i_lenAlloc;
         } else {
                 if (!epos->offset)
                         epos->offset = sizeof(struct allocExtDesc);
                 ptr = epos->bh->b_data + epos->offset;
                 alen = sizeof(struct allocExtDesc) +
-                        le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->lengthAllocDescs);
+                        le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->
+                                                        lengthAllocDescs);
         }
 
-        switch (UDF_I_ALLOCTYPE(inode)) {
+        switch (iinfo->i_alloc_type) {
         case ICBTAG_FLAG_AD_SHORT:
-                if (!(sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc)))
+                sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc);
+                if (!sad)
                         return -1;
                 etype = le32_to_cpu(sad->extLength) >> 30;
                 eloc->logicalBlockNum = le32_to_cpu(sad->extPosition);
-                eloc->partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
+                eloc->partitionReferenceNum =
+                                iinfo->i_location.partitionReferenceNum;
                 *elen = le32_to_cpu(sad->extLength) & UDF_EXTENT_LENGTH_MASK;
                 break;
         case ICBTAG_FLAG_AD_LONG:
-                if (!(lad = udf_get_filelongad(ptr, alen, &epos->offset, inc)))
+                lad = udf_get_filelongad(ptr, alen, &epos->offset, inc);
+                if (!lad)
                         return -1;
                 etype = le32_to_cpu(lad->extLength) >> 30;
                 *eloc = lelb_to_cpu(lad->extLocation);
                 *elen = le32_to_cpu(lad->extLength) & UDF_EXTENT_LENGTH_MASK;
                 break;
         default:
-                udf_debug("alloc_type = %d unsupported\n", UDF_I_ALLOCTYPE(inode));
+                udf_debug("alloc_type = %d unsupported\n",
+                                iinfo->i_alloc_type);
                 return -1;
         }
 
@@ -1858,22 +1998,24 @@ static int8_t udf_insert_aext(struct inode *inode, struct extent_position epos,
         return (nelen >> 30);
 }
 
-int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
+int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
                        kernel_lb_addr eloc, uint32_t elen)
 {
         struct extent_position oepos;
         int adsize;
         int8_t etype;
         struct allocExtDesc *aed;
+        struct udf_inode_info *iinfo;
 
         if (epos.bh) {
                 get_bh(epos.bh);
                 get_bh(epos.bh);
         }
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
+        iinfo = UDF_I(inode);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 adsize = 0;
@@ -1900,33 +2042,39 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
                 udf_write_aext(inode, &oepos, eloc, elen, 1);
                 udf_write_aext(inode, &oepos, eloc, elen, 1);
                 if (!oepos.bh) {
-                        UDF_I_LENALLOC(inode) -= (adsize * 2);
+                        iinfo->i_lenAlloc -= (adsize * 2);
                         mark_inode_dirty(inode);
                 } else {
                         aed = (struct allocExtDesc *)oepos.bh->b_data;
                         aed->lengthAllocDescs =
-                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - (2 * adsize));
+                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
+                                            (2 * adsize));
                         if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
-                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
-                                udf_update_tag(oepos.bh->b_data, oepos.offset - (2 * adsize));
+                            UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
+                                udf_update_tag(oepos.bh->b_data,
+                                                oepos.offset - (2 * adsize));
                         else
-                                udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
+                                udf_update_tag(oepos.bh->b_data,
+                                                sizeof(struct allocExtDesc));
                         mark_buffer_dirty_inode(oepos.bh, inode);
                 }
         } else {
                 udf_write_aext(inode, &oepos, eloc, elen, 1);
                 if (!oepos.bh) {
-                        UDF_I_LENALLOC(inode) -= adsize;
+                        iinfo->i_lenAlloc -= adsize;
                         mark_inode_dirty(inode);
                 } else {
                         aed = (struct allocExtDesc *)oepos.bh->b_data;
                         aed->lengthAllocDescs =
-                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) - adsize);
+                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) -
+                                            adsize);
                         if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
-                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
-                                udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
+                            UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
+                                udf_update_tag(oepos.bh->b_data,
+                                                epos.offset - adsize);
                         else
-                                udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
+                                udf_update_tag(oepos.bh->b_data,
+                                                sizeof(struct allocExtDesc));
                         mark_buffer_dirty_inode(oepos.bh, inode);
                 }
         }
@@ -1937,34 +2085,38 @@ int8_t udf_delete_aext(struct inode * inode, struct extent_position epos,
         return (elen >> 30);
 }
 
-int8_t inode_bmap(struct inode * inode, sector_t block,
-                  struct extent_position * pos, kernel_lb_addr * eloc,
-                  uint32_t * elen, sector_t * offset)
+int8_t inode_bmap(struct inode *inode, sector_t block,
+                  struct extent_position *pos, kernel_lb_addr *eloc,
+                  uint32_t *elen, sector_t *offset)
 {
+        unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
         loff_t lbcount = 0, bcount =
-            (loff_t) block << inode->i_sb->s_blocksize_bits;
+            (loff_t) block << blocksize_bits;
         int8_t etype;
+        struct udf_inode_info *iinfo;
 
         if (block < 0) {
                 printk(KERN_ERR "udf: inode_bmap: block < 0\n");
                 return -1;
         }
 
+        iinfo = UDF_I(inode);
         pos->offset = 0;
-        pos->block = UDF_I_LOCATION(inode);
+        pos->block = iinfo->i_location;
         pos->bh = NULL;
         *elen = 0;
 
         do {
-                if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1) {
-                        *offset = (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
-                        UDF_I_LENEXTENTS(inode) = lbcount;
+                etype = udf_next_aext(inode, pos, eloc, elen, 1);
+                if (etype == -1) {
+                        *offset = (bcount - lbcount) >> blocksize_bits;
+                        iinfo->i_lenExtents = lbcount;
                         return -1;
                 }
                 lbcount += *elen;
         } while (lbcount <= bcount);
 
-        *offset = (bcount + *elen - lbcount) >> inode->i_sb->s_blocksize_bits;
+        *offset = (bcount + *elen - lbcount) >> blocksize_bits;
 
         return etype;
 }
@@ -1979,7 +2131,8 @@ long udf_block_map(struct inode *inode, sector_t block)
 
         lock_kernel();
 
-        if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
+        if (inode_bmap(inode, block, &epos, &eloc, &elen, &offset) ==
+                                                (EXT_RECORDED_ALLOCATED >> 30))
                 ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
         else
                 ret = 0;
diff --git a/fs/udf/misc.c b/fs/udf/misc.c
index 15297deb5051..a1d6da0caf71 100644
--- a/fs/udf/misc.c
+++ b/fs/udf/misc.c
@@ -51,18 +51,18 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
         uint8_t *ea = NULL, *ad = NULL;
         int offset;
         uint16_t crclen;
-        int i;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
-        ea = UDF_I_DATA(inode);
-        if (UDF_I_LENEATTR(inode)) {
-                ad = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
+        ea = iinfo->i_ext.i_data;
+        if (iinfo->i_lenEAttr) {
+                ad = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
         } else {
                 ad = ea;
                 size += sizeof(struct extendedAttrHeaderDesc);
         }
 
         offset = inode->i_sb->s_blocksize - udf_file_entry_alloc_offset(inode) -
-                UDF_I_LENALLOC(inode);
+                iinfo->i_lenAlloc;
 
         /* TODO - Check for FreeEASpace */
 
@@ -70,69 +70,80 @@ struct genericFormat *udf_add_extendedattr(struct inode *inode, uint32_t size,
                 struct extendedAttrHeaderDesc *eahd;
                 eahd = (struct extendedAttrHeaderDesc *)ea;
 
-                if (UDF_I_LENALLOC(inode)) {
-                        memmove(&ad[size], ad, UDF_I_LENALLOC(inode));
-                }
+                if (iinfo->i_lenAlloc)
+                        memmove(&ad[size], ad, iinfo->i_lenAlloc);
 
-                if (UDF_I_LENEATTR(inode)) {
+                if (iinfo->i_lenEAttr) {
                         /* check checksum/crc */
-                        if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
-                            le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) {
+                        if (eahd->descTag.tagIdent !=
+                                        cpu_to_le16(TAG_IDENT_EAHD) ||
+                            le32_to_cpu(eahd->descTag.tagLocation) !=
+                                        iinfo->i_location.logicalBlockNum)
                                 return NULL;
-                        }
                 } else {
+                        struct udf_sb_info *sbi = UDF_SB(inode->i_sb);
+
                         size -= sizeof(struct extendedAttrHeaderDesc);
-                        UDF_I_LENEATTR(inode) += sizeof(struct extendedAttrHeaderDesc);
+                        iinfo->i_lenEAttr +=
+                                sizeof(struct extendedAttrHeaderDesc);
                         eahd->descTag.tagIdent = cpu_to_le16(TAG_IDENT_EAHD);
-                        if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
+                        if (sbi->s_udfrev >= 0x0200)
                                 eahd->descTag.descVersion = cpu_to_le16(3);
                         else
                                 eahd->descTag.descVersion = cpu_to_le16(2);
-                        eahd->descTag.tagSerialNum = cpu_to_le16(UDF_SB_SERIALNUM(inode->i_sb));
-                        eahd->descTag.tagLocation = cpu_to_le32(UDF_I_LOCATION(inode).logicalBlockNum);
+                        eahd->descTag.tagSerialNum =
+                                        cpu_to_le16(sbi->s_serial_number);
+                        eahd->descTag.tagLocation = cpu_to_le32(
+                                        iinfo->i_location.logicalBlockNum);
                         eahd->impAttrLocation = cpu_to_le32(0xFFFFFFFF);
                         eahd->appAttrLocation = cpu_to_le32(0xFFFFFFFF);
                 }
 
-                offset = UDF_I_LENEATTR(inode);
+                offset = iinfo->i_lenEAttr;
                 if (type < 2048) {
-                        if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) {
-                                uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
+                        if (le32_to_cpu(eahd->appAttrLocation) <
+                                        iinfo->i_lenEAttr) {
+                                uint32_t aal =
+                                        le32_to_cpu(eahd->appAttrLocation);
                                 memmove(&ea[offset - aal + size],
                                         &ea[aal], offset - aal);
                                 offset -= aal;
-                                eahd->appAttrLocation = cpu_to_le32(aal + size);
+                                eahd->appAttrLocation =
+                                                cpu_to_le32(aal + size);
                         }
-                        if (le32_to_cpu(eahd->impAttrLocation) < UDF_I_LENEATTR(inode)) {
-                                uint32_t ial = le32_to_cpu(eahd->impAttrLocation);
+                        if (le32_to_cpu(eahd->impAttrLocation) <
+                                        iinfo->i_lenEAttr) {
+                                uint32_t ial =
+                                        le32_to_cpu(eahd->impAttrLocation);
                                 memmove(&ea[offset - ial + size],
                                         &ea[ial], offset - ial);
                                 offset -= ial;
-                                eahd->impAttrLocation = cpu_to_le32(ial + size);
+                                eahd->impAttrLocation =
+                                                cpu_to_le32(ial + size);
                         }
                 } else if (type < 65536) {
-                        if (le32_to_cpu(eahd->appAttrLocation) < UDF_I_LENEATTR(inode)) {
-                                uint32_t aal = le32_to_cpu(eahd->appAttrLocation);
+                        if (le32_to_cpu(eahd->appAttrLocation) <
+                                        iinfo->i_lenEAttr) {
+                                uint32_t aal =
+                                        le32_to_cpu(eahd->appAttrLocation);
                                 memmove(&ea[offset - aal + size],
                                         &ea[aal], offset - aal);
                                 offset -= aal;
-                                eahd->appAttrLocation = cpu_to_le32(aal + size);
+                                eahd->appAttrLocation =
+                                                cpu_to_le32(aal + size);
                         }
                 }
                 /* rewrite CRC + checksum of eahd */
                 crclen = sizeof(struct extendedAttrHeaderDesc) - sizeof(tag);
                 eahd->descTag.descCRCLength = cpu_to_le16(crclen);
                 eahd->descTag.descCRC = cpu_to_le16(udf_crc((char *)eahd +
-                                                            sizeof(tag), crclen, 0));
-                eahd->descTag.tagChecksum = 0;
-                for (i = 0; i < 16; i++)
-                        if (i != 4)
-                                eahd->descTag.tagChecksum += ((uint8_t *)&(eahd->descTag))[i];
-                UDF_I_LENEATTR(inode) += size;
+                                                sizeof(tag), crclen, 0));
+                eahd->descTag.tagChecksum = udf_tag_checksum(&eahd->descTag);
+                iinfo->i_lenEAttr += size;
                 return (struct genericFormat *)&ea[offset];
         }
-        if (loc & 0x02) {
-        }
+        if (loc & 0x02)
+                ;
 
         return NULL;
 }
@@ -143,18 +154,20 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
         struct genericFormat *gaf;
         uint8_t *ea = NULL;
         uint32_t offset;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
-        ea = UDF_I_DATA(inode);
+        ea = iinfo->i_ext.i_data;
 
-        if (UDF_I_LENEATTR(inode)) {
+        if (iinfo->i_lenEAttr) {
                 struct extendedAttrHeaderDesc *eahd;
                 eahd = (struct extendedAttrHeaderDesc *)ea;
 
                 /* check checksum/crc */
-                if (le16_to_cpu(eahd->descTag.tagIdent) != TAG_IDENT_EAHD ||
-                    le32_to_cpu(eahd->descTag.tagLocation) != UDF_I_LOCATION(inode).logicalBlockNum) {
+                if (eahd->descTag.tagIdent !=
+                                cpu_to_le16(TAG_IDENT_EAHD) ||
+                    le32_to_cpu(eahd->descTag.tagLocation) !=
+                                iinfo->i_location.logicalBlockNum)
                         return NULL;
-                }
 
                 if (type < 2048)
                         offset = sizeof(struct extendedAttrHeaderDesc);
@@ -163,9 +176,10 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
                 else
                         offset = le32_to_cpu(eahd->appAttrLocation);
 
-                while (offset < UDF_I_LENEATTR(inode)) {
+                while (offset < iinfo->i_lenEAttr) {
                         gaf = (struct genericFormat *)&ea[offset];
-                        if (le32_to_cpu(gaf->attrType) == type && gaf->attrSubtype == subtype)
+                        if (le32_to_cpu(gaf->attrType) == type &&
+                                        gaf->attrSubtype == subtype)
                                 return gaf;
                         else
                                 offset += le32_to_cpu(gaf->attrLength);
@@ -186,21 +200,20 @@ struct genericFormat *udf_get_extendedattr(struct inode *inode, uint32_t type,
  *      Written, tested, and released.
  */
 struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
-                                    uint32_t location, uint16_t * ident)
+                                    uint32_t location, uint16_t *ident)
 {
         tag *tag_p;
         struct buffer_head *bh = NULL;
-        register uint8_t checksum;
-        register int i;
+        struct udf_sb_info *sbi = UDF_SB(sb);
 
         /* Read the block */
         if (block == 0xFFFFFFFF)
                 return NULL;
 
-        bh = udf_tread(sb, block + UDF_SB_SESSION(sb));
+        bh = udf_tread(sb, block + sbi->s_session);
         if (!bh) {
                 udf_debug("block=%d, location=%d: read failed\n",
-                          block + UDF_SB_SESSION(sb), location);
+                          block + sbi->s_session, location);
                 return NULL;
         }
 
@@ -210,24 +223,20 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
 
         if (location != le32_to_cpu(tag_p->tagLocation)) {
                 udf_debug("location mismatch block %u, tag %u != %u\n",
-                          block + UDF_SB_SESSION(sb), le32_to_cpu(tag_p->tagLocation), location);
+                          block + sbi->s_session,
+                          le32_to_cpu(tag_p->tagLocation), location);
                 goto error_out;
         }
 
         /* Verify the tag checksum */
-        checksum = 0U;
-        for (i = 0; i < 4; i++)
-                checksum += (uint8_t)(bh->b_data[i]);
-        for (i = 5; i < 16; i++)
-                checksum += (uint8_t)(bh->b_data[i]);
-        if (checksum != tag_p->tagChecksum) {
+        if (udf_tag_checksum(tag_p) != tag_p->tagChecksum) {
                 printk(KERN_ERR "udf: tag checksum failed block %d\n", block);
                 goto error_out;
         }
 
         /* Verify the tag version */
-        if (le16_to_cpu(tag_p->descVersion) != 0x0002U &&
-            le16_to_cpu(tag_p->descVersion) != 0x0003U) {
+        if (tag_p->descVersion != cpu_to_le16(0x0002U) &&
+            tag_p->descVersion != cpu_to_le16(0x0003U)) {
                 udf_debug("tag version 0x%04x != 0x0002 || 0x0003 block %d\n",
                           le16_to_cpu(tag_p->descVersion), block);
                 goto error_out;
@@ -236,11 +245,11 @@ struct buffer_head *udf_read_tagged(struct super_block *sb, uint32_t block,
         /* Verify the descriptor CRC */
         if (le16_to_cpu(tag_p->descCRCLength) + sizeof(tag) > sb->s_blocksize ||
             le16_to_cpu(tag_p->descCRC) == udf_crc(bh->b_data + sizeof(tag),
-                                                   le16_to_cpu(tag_p->descCRCLength), 0)) {
+                                        le16_to_cpu(tag_p->descCRCLength), 0))
                 return bh;
-        }
+
         udf_debug("Crc failure block %d: crc = %d, crclen = %d\n",
-                  block + UDF_SB_SESSION(sb), le16_to_cpu(tag_p->descCRC),
+                  block + sbi->s_session, le16_to_cpu(tag_p->descCRC),
                   le16_to_cpu(tag_p->descCRCLength));
 
 error_out:
@@ -249,7 +258,7 @@ error_out:
 }
 
 struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
-                                     uint32_t offset, uint16_t * ident)
+                                     uint32_t offset, uint16_t *ident)
 {
         return udf_read_tagged(sb, udf_get_lb_pblock(sb, loc, offset),
                                loc.logicalBlockNum + offset, ident);
@@ -258,17 +267,11 @@ struct buffer_head *udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc,
 void udf_update_tag(char *data, int length)
 {
         tag *tptr = (tag *)data;
-        int i;
-
         length -= sizeof(tag);
 
-        tptr->tagChecksum = 0;
         tptr->descCRCLength = cpu_to_le16(length);
         tptr->descCRC = cpu_to_le16(udf_crc(data + sizeof(tag), length, 0));
-
-        for (i = 0; i < 16; i++)
-                if (i != 4)
-                        tptr->tagChecksum += (uint8_t)(data[i]);
+        tptr->tagChecksum = udf_tag_checksum(tptr);
 }
 
 void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
@@ -281,3 +284,14 @@ void udf_new_tag(char *data, uint16_t ident, uint16_t version, uint16_t snum,
         tptr->tagLocation = cpu_to_le32(loc);
         udf_update_tag(data, length);
 }
+
+u8 udf_tag_checksum(const tag *t)
+{
+        u8 *data = (u8 *)t;
+        u8 checksum = 0;
+        int i;
+        for (i = 0; i < sizeof(tag); ++i)
+                if (i != 4) /* position of checksum */
+                        checksum += data[i];
+        return checksum;
+}
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index bec96a6b3343..112a5fb0b27b 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -43,12 +43,10 @@ static inline int udf_match(int len1, const char *name1, int len2,
 
 int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
                  struct fileIdentDesc *sfi, struct udf_fileident_bh *fibh,
-                 uint8_t * impuse, uint8_t * fileident)
+                 uint8_t *impuse, uint8_t *fileident)
 {
         uint16_t crclen = fibh->eoffset - fibh->soffset - sizeof(tag);
         uint16_t crc;
-        uint8_t checksum = 0;
-        int i;
         int offset;
         uint16_t liu = le16_to_cpu(cfi->lengthOfImpUse);
         uint8_t lfi = cfi->lengthFileIdent;
@@ -56,7 +54,7 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
                 sizeof(struct fileIdentDesc);
         int adinicb = 0;
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
+        if (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 adinicb = 1;
 
         offset = fibh->soffset + sizeof(struct fileIdentDesc);
@@ -68,7 +66,8 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
                         memcpy(fibh->ebh->b_data + offset, impuse, liu);
                 } else {
                         memcpy((uint8_t *)sfi->impUse, impuse, -offset);
-                        memcpy(fibh->ebh->b_data, impuse - offset, liu + offset);
+                        memcpy(fibh->ebh->b_data, impuse - offset,
+                                liu + offset);
                 }
         }
 
@@ -80,8 +79,10 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
                 } else if (offset >= 0) {
                         memcpy(fibh->ebh->b_data + offset, fileident, lfi);
                 } else {
-                        memcpy((uint8_t *)sfi->fileIdent + liu, fileident, -offset);
-                        memcpy(fibh->ebh->b_data, fileident - offset, lfi + offset);
+                        memcpy((uint8_t *)sfi->fileIdent + liu, fileident,
+                                -offset);
+                        memcpy(fibh->ebh->b_data, fileident - offset,
+                                lfi + offset);
                 }
         }
 
@@ -101,27 +102,29 @@ int udf_write_fi(struct inode *inode, struct fileIdentDesc *cfi,
 
         if (fibh->sbh == fibh->ebh) {
                 crc = udf_crc((uint8_t *)sfi->impUse,
-                              crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
+                              crclen + sizeof(tag) -
+                              sizeof(struct fileIdentDesc), crc);
         } else if (sizeof(struct fileIdentDesc) >= -fibh->soffset) {
-                crc = udf_crc(fibh->ebh->b_data + sizeof(struct fileIdentDesc) + fibh->soffset,
-                              crclen + sizeof(tag) - sizeof(struct fileIdentDesc), crc);
+                crc = udf_crc(fibh->ebh->b_data +
+                                        sizeof(struct fileIdentDesc) +
+                                        fibh->soffset,
+                              crclen + sizeof(tag) -
+                                        sizeof(struct fileIdentDesc),
+                              crc);
         } else {
                 crc = udf_crc((uint8_t *)sfi->impUse,
-                              -fibh->soffset - sizeof(struct fileIdentDesc), crc);
+                              -fibh->soffset - sizeof(struct fileIdentDesc),
+                              crc);
                 crc = udf_crc(fibh->ebh->b_data, fibh->eoffset, crc);
         }
 
         cfi->descTag.descCRC = cpu_to_le16(crc);
         cfi->descTag.descCRCLength = cpu_to_le16(crclen);
+        cfi->descTag.tagChecksum = udf_tag_checksum(&cfi->descTag);
 
-        for (i = 0; i < 16; i++) {
-                if (i != 4)
-                        checksum += ((uint8_t *)&cfi->descTag)[i];
-        }
-
-        cfi->descTag.tagChecksum = checksum;
         if (adinicb || (sizeof(struct fileIdentDesc) <= -fibh->soffset)) {
-                memcpy((uint8_t *)sfi, (uint8_t *)cfi, sizeof(struct fileIdentDesc));
+                memcpy((uint8_t *)sfi, (uint8_t *)cfi,
+                        sizeof(struct fileIdentDesc));
         } else {
                 memcpy((uint8_t *)sfi, (uint8_t *)cfi, -fibh->soffset);
                 memcpy(fibh->ebh->b_data, (uint8_t *)cfi - fibh->soffset,
@@ -155,26 +158,28 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
         uint32_t elen;
         sector_t offset;
         struct extent_position epos = {};
+        struct udf_inode_info *dinfo = UDF_I(dir);
 
-        size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
-        f_pos = (udf_ext0_offset(dir) >> 2);
+        size = udf_ext0_offset(dir) + dir->i_size;
+        f_pos = udf_ext0_offset(dir);
 
-        fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
+        if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 fibh->sbh = fibh->ebh = NULL;
-        } else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
+        else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits,
+                              &epos, &eloc, &elen, &offset) ==
+                                        (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
+                        if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
-                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
+                        else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
-                } else {
+                } else
                         offset = 0;
-                }
 
-                if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
+                fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
+                if (!fibh->sbh) {
                         brelse(epos.bh);
                         return NULL;
                 }
@@ -183,7 +188,7 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
                 return NULL;
         }
 
-        while ((f_pos < size)) {
+        while (f_pos < size) {
                 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
                                         &elen, &offset);
                 if (!fi) {
@@ -202,14 +207,18 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
                 } else {
                         int poffset;    /* Unpaded ending offset */
 
-                        poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
+                        poffset = fibh->soffset + sizeof(struct fileIdentDesc) +
+                                        liu + lfi;
 
-                        if (poffset >= lfi) {
-                                nameptr = (uint8_t *)(fibh->ebh->b_data + poffset - lfi);
-                        } else {
+                        if (poffset >= lfi)
+                                nameptr = (uint8_t *)(fibh->ebh->b_data +
+                                                      poffset - lfi);
+                        else {
                                 nameptr = fname;
-                                memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
-                                memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
+                                memcpy(nameptr, fi->fileIdent + liu,
+                                        lfi - poffset);
+                                memcpy(nameptr + lfi - poffset,
+                                        fibh->ebh->b_data, poffset);
                         }
                 }
 
@@ -226,11 +235,11 @@ static struct fileIdentDesc *udf_find_entry(struct inode *dir,
                 if (!lfi)
                         continue;
 
-                if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi))) {
-                        if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) {
-                                brelse(epos.bh);
-                                return fi;
-                        }
+                flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi);
+                if (flen && udf_match(flen, fname, dentry->d_name.len,
+                                      dentry->d_name.name)) {
+                        brelse(epos.bh);
+                        return fi;
                 }
         }
 
@@ -291,16 +300,16 @@ static struct dentry *udf_lookup(struct inode *dir, struct dentry *dentry,
         if (!strncmp(dentry->d_name.name, ".B=", 3)) {
                 kernel_lb_addr lb = {
                         .logicalBlockNum = 0,
-                        .partitionReferenceNum = simple_strtoul(dentry->d_name.name + 3,
-                                                                NULL, 0),
+                        .partitionReferenceNum =
+                                simple_strtoul(dentry->d_name.name + 3,
+                                                NULL, 0),
                 };
                 inode = udf_iget(dir->i_sb, lb);
                 if (!inode) {
                         unlock_kernel();
                         return ERR_PTR(-EACCES);
                 }
-        }
-        else
+        } else
 #endif /* UDF_RECOVERY */
 
         if (udf_find_entry(dir, dentry, &fibh, &cfi)) {
@@ -325,14 +334,14 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                                            struct udf_fileident_bh *fibh,
                                            struct fileIdentDesc *cfi, int *err)
 {
-        struct super_block *sb;
+        struct super_block *sb = dir->i_sb;
         struct fileIdentDesc *fi = NULL;
         char name[UDF_NAME_LEN], fname[UDF_NAME_LEN];
         int namelen;
         loff_t f_pos;
         int flen;
         char *nameptr;
-        loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
+        loff_t size = udf_ext0_offset(dir) + dir->i_size;
         int nfidlen;
         uint8_t lfi;
         uint16_t liu;
@@ -341,16 +350,16 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
         uint32_t elen;
         sector_t offset;
         struct extent_position epos = {};
-
-        sb = dir->i_sb;
+        struct udf_inode_info *dinfo;
 
         if (dentry) {
                 if (!dentry->d_name.len) {
                         *err = -EINVAL;
                         return NULL;
                 }
-                if (!(namelen = udf_put_filename(sb, dentry->d_name.name, name,
-                                                 dentry->d_name.len))) {
+                namelen = udf_put_filename(sb, dentry->d_name.name, name,
+                                                 dentry->d_name.len);
+                if (!namelen) {
                         *err = -ENAMETOOLONG;
                         return NULL;
                 }
@@ -360,39 +369,40 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
 
         nfidlen = (sizeof(struct fileIdentDesc) + namelen + 3) & ~3;
 
-        f_pos = (udf_ext0_offset(dir) >> 2);
+        f_pos = udf_ext0_offset(dir);
 
-        fibh->soffset = fibh->eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        fibh->soffset = fibh->eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
+        dinfo = UDF_I(dir);
+        if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 fibh->sbh = fibh->ebh = NULL;
-        } else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
+        else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits,
+                              &epos, &eloc, &elen, &offset) ==
+                                        (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
+                        if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
-                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
+                        else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
-                } else {
+                } else
                         offset = 0;
-                }
 
-                if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block))) {
+                fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block);
+                if (!fibh->sbh) {
                         brelse(epos.bh);
                         *err = -EIO;
                         return NULL;
                 }
 
-                block = UDF_I_LOCATION(dir).logicalBlockNum;
-
+                block = dinfo->i_location.logicalBlockNum;
         } else {
-                block = udf_get_lb_pblock(dir->i_sb, UDF_I_LOCATION(dir), 0);
+                block = udf_get_lb_pblock(dir->i_sb, dinfo->i_location, 0);
                 fibh->sbh = fibh->ebh = NULL;
                 fibh->soffset = fibh->eoffset = sb->s_blocksize;
                 goto add;
         }
 
-        while ((f_pos < size)) {
+        while (f_pos < size) {
                 fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc,
                                         &elen, &offset);
 
@@ -408,33 +418,39 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                 liu = le16_to_cpu(cfi->lengthOfImpUse);
                 lfi = cfi->lengthFileIdent;
 
-                if (fibh->sbh == fibh->ebh) {
+                if (fibh->sbh == fibh->ebh)
                         nameptr = fi->fileIdent + liu;
-                } else {
+                else {
                         int poffset;    /* Unpaded ending offset */
 
-                        poffset = fibh->soffset + sizeof(struct fileIdentDesc) + liu + lfi;
+                        poffset = fibh->soffset + sizeof(struct fileIdentDesc) +
+                                        liu + lfi;
 
-                        if (poffset >= lfi) {
-                                nameptr = (char *)(fibh->ebh->b_data + poffset - lfi);
-                        } else {
+                        if (poffset >= lfi)
+                                nameptr = (char *)(fibh->ebh->b_data +
+                                                   poffset - lfi);
+                        else {
                                 nameptr = fname;
-                                memcpy(nameptr, fi->fileIdent + liu, lfi - poffset);
-                                memcpy(nameptr + lfi - poffset, fibh->ebh->b_data, poffset);
+                                memcpy(nameptr, fi->fileIdent + liu,
+                                        lfi - poffset);
+                                memcpy(nameptr + lfi - poffset,
+                                        fibh->ebh->b_data, poffset);
                         }
                 }
 
                 if ((cfi->fileCharacteristics & FID_FILE_CHAR_DELETED) != 0) {
-                        if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen) {
+                        if (((sizeof(struct fileIdentDesc) +
+                                        liu + lfi + 3) & ~3) == nfidlen) {
                                 brelse(epos.bh);
                                 cfi->descTag.tagSerialNum = cpu_to_le16(1);
                                 cfi->fileVersionNum = cpu_to_le16(1);
                                 cfi->fileCharacteristics = 0;
                                 cfi->lengthFileIdent = namelen;
                                 cfi->lengthOfImpUse = cpu_to_le16(0);
-                                if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
+                                if (!udf_write_fi(dir, cfi, fi, fibh, NULL,
+                                                  name))
                                         return fi;
-                                } else {
+                                else {
                                         *err = -EIO;
                                         return NULL;
                                 }
@@ -444,8 +460,9 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
                 if (!lfi || !dentry)
                         continue;
 
-                if ((flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi)) &&
-                    udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name)) {
+                flen = udf_get_filename(dir->i_sb, nameptr, fname, lfi);
+                if (flen && udf_match(flen, fname, dentry->d_name.len,
+                                      dentry->d_name.name)) {
                         if (fibh->sbh != fibh->ebh)
                                 brelse(fibh->ebh);
                         brelse(fibh->sbh);
@@ -456,29 +473,34 @@ static struct fileIdentDesc *udf_add_entry(struct inode *dir,
         }
 
 add:
+        if (dinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
+                elen = (elen + sb->s_blocksize - 1) & ~(sb->s_blocksize - 1);
+                if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
+                        epos.offset -= sizeof(short_ad);
+                else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
+                        epos.offset -= sizeof(long_ad);
+                udf_write_aext(dir, &epos, eloc, elen, 1);
+        }
         f_pos += nfidlen;
 
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
+        if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB &&
             sb->s_blocksize - fibh->eoffset < nfidlen) {
                 brelse(epos.bh);
                 epos.bh = NULL;
                 fibh->soffset -= udf_ext0_offset(dir);
                 fibh->eoffset -= udf_ext0_offset(dir);
-                f_pos -= (udf_ext0_offset(dir) >> 2);
+                f_pos -= udf_ext0_offset(dir);
                 if (fibh->sbh != fibh->ebh)
                         brelse(fibh->ebh);
                 brelse(fibh->sbh);
-                if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err)))
+                fibh->sbh = fibh->ebh =
+                                udf_expand_dir_adinicb(dir, &block, err);
+                if (!fibh->sbh)
                         return NULL;
-                epos.block = UDF_I_LOCATION(dir);
-                eloc.logicalBlockNum = block;
-                eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
-                elen = dir->i_sb->s_blocksize;
+                epos.block = dinfo->i_location;
                 epos.offset = udf_file_entry_alloc_offset(dir);
-                if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
-                        epos.offset += sizeof(short_ad);
-                else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
-                        epos.offset += sizeof(long_ad);
+                /* Load extent udf_expand_dir_adinicb() has created */
+                udf_current_aext(dir, &epos, &eloc, &elen, 1);
         }
 
         if (sb->s_blocksize - fibh->eoffset >= nfidlen) {
@@ -489,15 +511,19 @@ add:
                         fibh->sbh = fibh->ebh;
                 }
 
-                if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
-                        block = UDF_I_LOCATION(dir).logicalBlockNum;
-                        fi = (struct fileIdentDesc *)(UDF_I_DATA(dir) + fibh->soffset -
-                                                      udf_ext0_offset(dir) +
-                                                      UDF_I_LENEATTR(dir));
+                if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                        block = dinfo->i_location.logicalBlockNum;
+                        fi = (struct fileIdentDesc *)
+                                        (dinfo->i_ext.i_data +
+                                         fibh->soffset -
+                                         udf_ext0_offset(dir) +
+                                         dinfo->i_lenEAttr);
                 } else {
-                        block = eloc.logicalBlockNum + ((elen - 1) >>
-                                                        dir->i_sb->s_blocksize_bits);
-                        fi = (struct fileIdentDesc *)(fibh->sbh->b_data + fibh->soffset);
+                        block = eloc.logicalBlockNum +
+                                        ((elen - 1) >>
+                                                dir->i_sb->s_blocksize_bits);
+                        fi = (struct fileIdentDesc *)
+                                (fibh->sbh->b_data + fibh->soffset);
                 }
         } else {
                 fibh->soffset = fibh->eoffset - sb->s_blocksize;
@@ -509,7 +535,8 @@ add:
 
                 block = eloc.logicalBlockNum + ((elen - 1) >>
                                                 dir->i_sb->s_blocksize_bits);
-                fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err);
+                fibh->ebh = udf_bread(dir,
+                                f_pos >> dir->i_sb->s_blocksize_bits, 1, err);
                 if (!fibh->ebh) {
                         brelse(epos.bh);
                         brelse(fibh->sbh);
@@ -521,32 +548,34 @@ add:
                             (EXT_RECORDED_ALLOCATED >> 30)) {
                                 block = eloc.logicalBlockNum + ((elen - 1) >>
                                         dir->i_sb->s_blocksize_bits);
-                        } else {
+                        } else
                                 block++;
-                        }
 
                         brelse(fibh->sbh);
                         fibh->sbh = fibh->ebh;
                         fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
                 } else {
                         fi = (struct fileIdentDesc *)
-                                (fibh->sbh->b_data + sb->s_blocksize + fibh->soffset);
+                                (fibh->sbh->b_data + sb->s_blocksize +
+                                        fibh->soffset);
                 }
         }
 
         memset(cfi, 0, sizeof(struct fileIdentDesc));
-        if (UDF_SB_UDFREV(sb) >= 0x0200)
-                udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block, sizeof(tag));
+        if (UDF_SB(sb)->s_udfrev >= 0x0200)
+                udf_new_tag((char *)cfi, TAG_IDENT_FID, 3, 1, block,
+                            sizeof(tag));
         else
-                udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block, sizeof(tag));
+                udf_new_tag((char *)cfi, TAG_IDENT_FID, 2, 1, block,
+                            sizeof(tag));
         cfi->fileVersionNum = cpu_to_le16(1);
         cfi->lengthFileIdent = namelen;
         cfi->lengthOfImpUse = cpu_to_le16(0);
         if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name)) {
                 brelse(epos.bh);
                 dir->i_size += nfidlen;
-                if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
-                        UDF_I_LENALLOC(dir) += nfidlen;
+                if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+                        dinfo->i_lenAlloc += nfidlen;
                 mark_inode_dirty(dir);
                 return fi;
         } else {
@@ -578,6 +607,7 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
         struct inode *inode;
         struct fileIdentDesc cfi, *fi;
         int err;
+        struct udf_inode_info *iinfo;
 
         lock_kernel();
         inode = udf_new_inode(dir, mode, &err);
@@ -586,7 +616,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
                 return err;
         }
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
+        iinfo = UDF_I(inode);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 inode->i_data.a_ops = &udf_adinicb_aops;
         else
                 inode->i_data.a_ops = &udf_aops;
@@ -595,7 +626,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
         inode->i_mode = mode;
         mark_inode_dirty(inode);
 
-        if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
+        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
+        if (!fi) {
                 inode->i_nlink--;
                 mark_inode_dirty(inode);
                 iput(inode);
@@ -603,13 +635,12 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode,
                 return err;
         }
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-        cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
+        cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
         *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-                cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
+                cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 mark_inode_dirty(dir);
-        }
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
@@ -626,6 +657,7 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
         struct udf_fileident_bh fibh;
         struct fileIdentDesc cfi, *fi;
         int err;
+        struct udf_inode_info *iinfo;
 
         if (!old_valid_dev(rdev))
                 return -EINVAL;
@@ -636,9 +668,11 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
         if (!inode)
                 goto out;
 
+        iinfo = UDF_I(inode);
         inode->i_uid = current->fsuid;
         init_special_inode(inode, mode, rdev);
-        if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
+        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
+        if (!fi) {
                 inode->i_nlink--;
                 mark_inode_dirty(inode);
                 iput(inode);
@@ -646,13 +680,12 @@ static int udf_mknod(struct inode *dir, struct dentry *dentry, int mode,
                 return err;
         }
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-        cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
+        cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
         *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-                cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
+                cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 mark_inode_dirty(dir);
-        }
         mark_inode_dirty(inode);
 
         if (fibh.sbh != fibh.ebh)
@@ -672,6 +705,8 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         struct udf_fileident_bh fibh;
         struct fileIdentDesc cfi, *fi;
         int err;
+        struct udf_inode_info *dinfo = UDF_I(dir);
+        struct udf_inode_info *iinfo;
 
         lock_kernel();
         err = -EMLINK;
@@ -683,9 +718,11 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         if (!inode)
                 goto out;
 
+        iinfo = UDF_I(inode);
         inode->i_op = &udf_dir_inode_operations;
         inode->i_fop = &udf_dir_operations;
-        if (!(fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err))) {
+        fi = udf_add_entry(inode, NULL, &fibh, &cfi, &err);
+        if (!fi) {
                 inode->i_nlink--;
                 mark_inode_dirty(inode);
                 iput(inode);
@@ -693,10 +730,11 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
         }
         inode->i_nlink = 2;
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-        cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(dir));
+        cfi.icb.extLocation = cpu_to_lelb(dinfo->i_location);
         *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-                cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
-        cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
+                cpu_to_le32(dinfo->i_unique & 0x00000000FFFFFFFFUL);
+        cfi.fileCharacteristics =
+                        FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
         udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
         brelse(fibh.sbh);
         inode->i_mode = S_IFDIR | mode;
@@ -704,16 +742,17 @@ static int udf_mkdir(struct inode *dir, struct dentry *dentry, int mode)
                 inode->i_mode |= S_ISGID;
         mark_inode_dirty(inode);
 
-        if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
+        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
+        if (!fi) {
                 inode->i_nlink = 0;
                 mark_inode_dirty(inode);
                 iput(inode);
                 goto out;
         }
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-        cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
+        cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
         *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
-                cpu_to_le32(UDF_I_UNIQUE(inode) & 0x00000000FFFFFFFFUL);
+                cpu_to_le32(iinfo->i_unique & 0x00000000FFFFFFFFUL);
         cfi.fileCharacteristics |= FID_FILE_CHAR_DIRECTORY;
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
         inc_nlink(dir);
@@ -734,32 +773,33 @@ static int empty_dir(struct inode *dir)
         struct fileIdentDesc *fi, cfi;
         struct udf_fileident_bh fibh;
         loff_t f_pos;
-        loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
+        loff_t size = udf_ext0_offset(dir) + dir->i_size;
         int block;
         kernel_lb_addr eloc;
         uint32_t elen;
         sector_t offset;
         struct extent_position epos = {};
+        struct udf_inode_info *dinfo = UDF_I(dir);
 
-        f_pos = (udf_ext0_offset(dir) >> 2);
+        f_pos = udf_ext0_offset(dir);
+        fibh.soffset = fibh.eoffset = f_pos & (dir->i_sb->s_blocksize - 1);
 
-        fibh.soffset = fibh.eoffset = (f_pos & ((dir->i_sb->s_blocksize - 1) >> 2)) << 2;
-
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 fibh.sbh = fibh.ebh = NULL;
-        } else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                              &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30)) {
+        else if (inode_bmap(dir, f_pos >> dir->i_sb->s_blocksize_bits,
+                              &epos, &eloc, &elen, &offset) ==
+                                        (EXT_RECORDED_ALLOCATED >> 30)) {
                 block = udf_get_lb_pblock(dir->i_sb, eloc, offset);
                 if ((++offset << dir->i_sb->s_blocksize_bits) < elen) {
-                        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
+                        if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                                 epos.offset -= sizeof(short_ad);
-                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
+                        else if (dinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                                 epos.offset -= sizeof(long_ad);
-                } else {
+                } else
                         offset = 0;
-                }
 
-                if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block))) {
+                fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block);
+                if (!fibh.sbh) {
                         brelse(epos.bh);
                         return 0;
                 }
@@ -768,7 +808,7 @@ static int empty_dir(struct inode *dir)
                 return 0;
         }
 
-        while ((f_pos < size)) {
+        while (f_pos < size) {
                 fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc,
                                         &elen, &offset);
                 if (!fi) {
@@ -828,7 +868,8 @@ static int udf_rmdir(struct inode *dir, struct dentry *dentry)
         clear_nlink(inode);
         inode->i_size = 0;
         inode_dec_link_count(dir);
-        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
+        inode->i_ctime = dir->i_ctime = dir->i_mtime =
+                                                current_fs_time(dir->i_sb);
         mark_inode_dirty(dir);
 
 end_rmdir:
@@ -901,36 +942,42 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
         int block;
         char name[UDF_NAME_LEN];
         int namelen;
+        struct buffer_head *bh;
+        struct udf_inode_info *iinfo;
 
         lock_kernel();
-        if (!(inode = udf_new_inode(dir, S_IFLNK, &err)))
+        inode = udf_new_inode(dir, S_IFLNK, &err);
+        if (!inode)
                 goto out;
 
+        iinfo = UDF_I(inode);
         inode->i_mode = S_IFLNK | S_IRWXUGO;
         inode->i_data.a_ops = &udf_symlink_aops;
         inode->i_op = &page_symlink_inode_operations;
 
-        if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB) {
+        if (iinfo->i_alloc_type != ICBTAG_FLAG_AD_IN_ICB) {
                 kernel_lb_addr eloc;
                 uint32_t elen;
 
                 block = udf_new_block(inode->i_sb, inode,
-                                      UDF_I_LOCATION(inode).partitionReferenceNum,
-                                      UDF_I_LOCATION(inode).logicalBlockNum, &err);
+                                iinfo->i_location.partitionReferenceNum,
+                                iinfo->i_location.logicalBlockNum, &err);
                 if (!block)
                         goto out_no_entry;
-                epos.block = UDF_I_LOCATION(inode);
+                epos.block = iinfo->i_location;
                 epos.offset = udf_file_entry_alloc_offset(inode);
                 epos.bh = NULL;
                 eloc.logicalBlockNum = block;
-                eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
+                eloc.partitionReferenceNum =
+                                iinfo->i_location.partitionReferenceNum;
                 elen = inode->i_sb->s_blocksize;
-                UDF_I_LENEXTENTS(inode) = elen;
+                iinfo->i_lenExtents = elen;
                 udf_add_aext(inode, &epos, eloc, elen, 0);
                 brelse(epos.bh);
 
                 block = udf_get_pblock(inode->i_sb, block,
-                                       UDF_I_LOCATION(inode).partitionReferenceNum, 0);
+                                iinfo->i_location.partitionReferenceNum,
+                                0);
                 epos.bh = udf_tread(inode->i_sb, block);
                 lock_buffer(epos.bh);
                 memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
@@ -938,9 +985,8 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
                 unlock_buffer(epos.bh);
                 mark_buffer_dirty_inode(epos.bh, inode);
                 ea = epos.bh->b_data + udf_ext0_offset(inode);
-        } else {
-                ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
-        }
+        } else
+                ea = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
 
         eoffset = inode->i_sb->s_blocksize - udf_ext0_offset(inode);
         pc = (struct pathComponent *)ea;
@@ -977,7 +1023,8 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
                 if (compstart[0] == '.') {
                         if ((symname - compstart) == 1)
                                 pc->componentType = 4;
-                        else if ((symname - compstart) == 2 && compstart[1] == '.')
+                        else if ((symname - compstart) == 2 &&
+                                        compstart[1] == '.')
                                 pc->componentType = 3;
                 }
 
@@ -987,7 +1034,8 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
                         if (!namelen)
                                 goto out_no_entry;
 
-                        if (elen + sizeof(struct pathComponent) + namelen > eoffset)
+                        if (elen + sizeof(struct pathComponent) + namelen >
+                                        eoffset)
                                 goto out_no_entry;
                         else
                                 pc->lengthComponentIdent = namelen;
@@ -1006,30 +1054,34 @@ static int udf_symlink(struct inode *dir, struct dentry *dentry,
 
         brelse(epos.bh);
         inode->i_size = elen;
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
-                UDF_I_LENALLOC(inode) = inode->i_size;
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
+                iinfo->i_lenAlloc = inode->i_size;
         mark_inode_dirty(inode);
 
-        if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err)))
+        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
+        if (!fi)
                 goto out_no_entry;
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-        cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
-        if (UDF_SB_LVIDBH(inode->i_sb)) {
+        cfi.icb.extLocation = cpu_to_lelb(iinfo->i_location);
+        bh = UDF_SB(inode->i_sb)->s_lvid_bh;
+        if (bh) {
+                struct logicalVolIntegrityDesc *lvid =
+                                (struct logicalVolIntegrityDesc *)bh->b_data;
                 struct logicalVolHeaderDesc *lvhd;
                 uint64_t uniqueID;
-                lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
+                lvhd = (struct logicalVolHeaderDesc *)
+                                lvid->logicalVolContentsUse;
                 uniqueID = le64_to_cpu(lvhd->uniqueID);
                 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
                         cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
                 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
                         uniqueID += 16;
                 lvhd->uniqueID = cpu_to_le64(uniqueID);
-                mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
+                mark_buffer_dirty(bh);
         }
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 mark_inode_dirty(dir);
-        }
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
         brelse(fibh.sbh);
@@ -1053,6 +1105,7 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
         struct udf_fileident_bh fibh;
         struct fileIdentDesc cfi, *fi;
         int err;
+        struct buffer_head *bh;
 
         lock_kernel();
         if (inode->i_nlink >= (256 << sizeof(inode->i_nlink)) - 1) {
@@ -1060,28 +1113,32 @@ static int udf_link(struct dentry *old_dentry, struct inode *dir,
                 return -EMLINK;
         }
 
-        if (!(fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err))) {
+        fi = udf_add_entry(dir, dentry, &fibh, &cfi, &err);
+        if (!fi) {
                 unlock_kernel();
                 return err;
         }
         cfi.icb.extLength = cpu_to_le32(inode->i_sb->s_blocksize);
-        cfi.icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(inode));
-        if (UDF_SB_LVIDBH(inode->i_sb)) {
+        cfi.icb.extLocation = cpu_to_lelb(UDF_I(inode)->i_location);
+        bh = UDF_SB(inode->i_sb)->s_lvid_bh;
+        if (bh) {
+                struct logicalVolIntegrityDesc *lvid =
+                                (struct logicalVolIntegrityDesc *)bh->b_data;
                 struct logicalVolHeaderDesc *lvhd;
                 uint64_t uniqueID;
-                lvhd = (struct logicalVolHeaderDesc *)(UDF_SB_LVID(inode->i_sb)->logicalVolContentsUse);
+                lvhd = (struct logicalVolHeaderDesc *)
+                                (lvid->logicalVolContentsUse);
                 uniqueID = le64_to_cpu(lvhd->uniqueID);
                 *(__le32 *)((struct allocDescImpUse *)cfi.icb.impUse)->impUse =
                         cpu_to_le32(uniqueID & 0x00000000FFFFFFFFUL);
                 if (!(++uniqueID & 0x00000000FFFFFFFFUL))
                         uniqueID += 16;
                 lvhd->uniqueID = cpu_to_le64(uniqueID);
-                mark_buffer_dirty(UDF_SB_LVIDBH(inode->i_sb));
+                mark_buffer_dirty(bh);
         }
         udf_write_fi(dir, &cfi, fi, &fibh, NULL, NULL);
-        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB) {
+        if (UDF_I(dir)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                 mark_inode_dirty(dir);
-        }
 
         if (fibh.sbh != fibh.ebh)
                 brelse(fibh.ebh);
@@ -1105,13 +1162,16 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
         struct inode *old_inode = old_dentry->d_inode;
         struct inode *new_inode = new_dentry->d_inode;
         struct udf_fileident_bh ofibh, nfibh;
-        struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL, ocfi, ncfi;
+        struct fileIdentDesc *ofi = NULL, *nfi = NULL, *dir_fi = NULL;
+        struct fileIdentDesc ocfi, ncfi;
         struct buffer_head *dir_bh = NULL;
         int retval = -ENOENT;
         kernel_lb_addr tloc;
+        struct udf_inode_info *old_iinfo = UDF_I(old_inode);
 
         lock_kernel();
-        if ((ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi))) {
+        ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi);
+        if (ofi) {
                 if (ofibh.sbh != ofibh.ebh)
                         brelse(ofibh.ebh);
                 brelse(ofibh.sbh);
@@ -1131,7 +1191,7 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                 }
         }
         if (S_ISDIR(old_inode->i_mode)) {
-                uint32_t offset = udf_ext0_offset(old_inode);
+                int offset = udf_ext0_offset(old_inode);
 
                 if (new_inode) {
                         retval = -ENOTEMPTY;
@@ -1139,30 +1199,36 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
                                 goto end_rename;
                 }
                 retval = -EIO;
-                if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
-                        dir_fi = udf_get_fileident(UDF_I_DATA(old_inode) -
-                                                   (UDF_I_EFE(old_inode) ?
-                                                    sizeof(struct extendedFileEntry) :
-                                                    sizeof(struct fileEntry)),
-                                                   old_inode->i_sb->s_blocksize, &offset);
+                if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                        dir_fi = udf_get_fileident(
+                                        old_iinfo->i_ext.i_data -
+                                          (old_iinfo->i_efe ?
+                                           sizeof(struct extendedFileEntry) :
+                                           sizeof(struct fileEntry)),
+                                        old_inode->i_sb->s_blocksize, &offset);
                 } else {
                         dir_bh = udf_bread(old_inode, 0, 0, &retval);
                         if (!dir_bh)
                                 goto end_rename;
-                        dir_fi = udf_get_fileident(dir_bh->b_data, old_inode->i_sb->s_blocksize, &offset);
+                        dir_fi = udf_get_fileident(dir_bh->b_data,
+                                        old_inode->i_sb->s_blocksize, &offset);
                 }
                 if (!dir_fi)
                         goto end_rename;
                 tloc = lelb_to_cpu(dir_fi->icb.extLocation);
-                if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0) != old_dir->i_ino)
+                if (udf_get_lb_pblock(old_inode->i_sb, tloc, 0) !=
+                                old_dir->i_ino)
                         goto end_rename;
 
                 retval = -EMLINK;
-                if (!new_inode && new_dir->i_nlink >= (256 << sizeof(new_dir->i_nlink)) - 1)
+                if (!new_inode &&
+                        new_dir->i_nlink >=
+                                (256 << sizeof(new_dir->i_nlink)) - 1)
                         goto end_rename;
         }
         if (!nfi) {
-                nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi, &retval);
+                nfi = udf_add_entry(new_dir, new_dentry, &nfibh, &ncfi,
+                                    &retval);
                 if (!nfi)
                         goto end_rename;
         }
@@ -1194,18 +1260,19 @@ static int udf_rename(struct inode *old_dir, struct dentry *old_dentry,
         mark_inode_dirty(old_dir);
 
         if (dir_fi) {
-                dir_fi->icb.extLocation = cpu_to_lelb(UDF_I_LOCATION(new_dir));
-                udf_update_tag((char *)dir_fi, (sizeof(struct fileIdentDesc) +
-                                                le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
-                if (UDF_I_ALLOCTYPE(old_inode) == ICBTAG_FLAG_AD_IN_ICB) {
+                dir_fi->icb.extLocation = cpu_to_lelb(UDF_I(new_dir)->i_location);
+                udf_update_tag((char *)dir_fi,
+                                (sizeof(struct fileIdentDesc) +
+                                le16_to_cpu(dir_fi->lengthOfImpUse) + 3) & ~3);
+                if (old_iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB)
                         mark_inode_dirty(old_inode);
-                } else {
+                else
                         mark_buffer_dirty_inode(dir_bh, old_inode);
-                }
+
                 inode_dec_link_count(old_dir);
-                if (new_inode) {
+                if (new_inode)
                         inode_dec_link_count(new_inode);
-                } else {
+                else {
                         inc_nlink(new_dir);
                         mark_inode_dirty(new_dir);
                 }
diff --git a/fs/udf/partition.c b/fs/udf/partition.c
index aaab24c8c498..fc533345ab89 100644
--- a/fs/udf/partition.c
+++ b/fs/udf/partition.c
@@ -31,15 +31,18 @@
 inline uint32_t udf_get_pblock(struct super_block *sb, uint32_t block,
                                uint16_t partition, uint32_t offset)
 {
-        if (partition >= UDF_SB_NUMPARTS(sb)) {
-                udf_debug("block=%d, partition=%d, offset=%d: invalid partition\n",
-                          block, partition, offset);
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct udf_part_map *map;
+        if (partition >= sbi->s_partitions) {
+                udf_debug("block=%d, partition=%d, offset=%d: "
+                          "invalid partition\n", block, partition, offset);
                 return 0xFFFFFFFF;
         }
-        if (UDF_SB_PARTFUNC(sb, partition))
-                return UDF_SB_PARTFUNC(sb, partition)(sb, block, partition, offset);
+        map = &sbi->s_partmaps[partition];
+        if (map->s_partition_func)
+                return map->s_partition_func(sb, block, partition, offset);
         else
-                return UDF_SB_PARTROOT(sb, partition) + block + offset;
+                return map->s_partition_root + block + offset;
 }
 
 uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
@@ -49,12 +52,18 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
         uint32_t newblock;
         uint32_t index;
         uint32_t loc;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct udf_part_map *map;
+        struct udf_virtual_data *vdata;
+        struct udf_inode_info *iinfo;
 
-        index = (sb->s_blocksize - UDF_SB_TYPEVIRT(sb,partition).s_start_offset) / sizeof(uint32_t);
+        map = &sbi->s_partmaps[partition];
+        vdata = &map->s_type_specific.s_virtual;
+        index = (sb->s_blocksize - vdata->s_start_offset) / sizeof(uint32_t);
 
-        if (block > UDF_SB_TYPEVIRT(sb,partition).s_num_entries) {
-                udf_debug("Trying to access block beyond end of VAT (%d max %d)\n",
-                          block, UDF_SB_TYPEVIRT(sb,partition).s_num_entries);
+        if (block > vdata->s_num_entries) {
+                udf_debug("Trying to access block beyond end of VAT "
+                          "(%d max %d)\n", block, vdata->s_num_entries);
                 return 0xFFFFFFFF;
         }
 
@@ -64,12 +73,13 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
                 index = block % (sb->s_blocksize / sizeof(uint32_t));
         } else {
                 newblock = 0;
-                index = UDF_SB_TYPEVIRT(sb,partition).s_start_offset / sizeof(uint32_t) + block;
+                index = vdata->s_start_offset / sizeof(uint32_t) + block;
         }
 
-        loc = udf_block_map(UDF_SB_VAT(sb), newblock);
+        loc = udf_block_map(sbi->s_vat_inode, newblock);
 
-        if (!(bh = sb_bread(sb, loc))) {
+        bh = sb_bread(sb, loc);
+        if (!bh) {
                 udf_debug("get_pblock(UDF_VIRTUAL_MAP:%p,%d,%d) VAT: %d[%d]\n",
                           sb, block, partition, loc, index);
                 return 0xFFFFFFFF;
@@ -79,50 +89,61 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block,
 
         brelse(bh);
 
-        if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition) {
+        iinfo = UDF_I(sbi->s_vat_inode);
+        if (iinfo->i_location.partitionReferenceNum == partition) {
                 udf_debug("recursive call to udf_get_pblock!\n");
                 return 0xFFFFFFFF;
         }
 
         return udf_get_pblock(sb, loc,
-                              UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum,
+                              iinfo->i_location.partitionReferenceNum,
                               offset);
 }
 
-inline uint32_t udf_get_pblock_virt20(struct super_block * sb, uint32_t block,
+inline uint32_t udf_get_pblock_virt20(struct super_block *sb, uint32_t block,
                                       uint16_t partition, uint32_t offset)
 {
         return udf_get_pblock_virt15(sb, block, partition, offset);
 }
 
-uint32_t udf_get_pblock_spar15(struct super_block * sb, uint32_t block,
+uint32_t udf_get_pblock_spar15(struct super_block *sb, uint32_t block,
                                uint16_t partition, uint32_t offset)
 {
         int i;
         struct sparingTable *st = NULL;
-        uint32_t packet = (block + offset) & ~(UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1);
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct udf_part_map *map;
+        uint32_t packet;
+        struct udf_sparing_data *sdata;
+
+        map = &sbi->s_partmaps[partition];
+        sdata = &map->s_type_specific.s_sparing;
+        packet = (block + offset) & ~(sdata->s_packet_len - 1);
 
         for (i = 0; i < 4; i++) {
-                if (UDF_SB_TYPESPAR(sb,partition).s_spar_map[i] != NULL) {
-                        st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,partition).s_spar_map[i]->b_data;
+                if (sdata->s_spar_map[i] != NULL) {
+                        st = (struct sparingTable *)
+                                        sdata->s_spar_map[i]->b_data;
                         break;
                 }
         }
 
         if (st) {
                 for (i = 0; i < le16_to_cpu(st->reallocationTableLen); i++) {
-                        if (le32_to_cpu(st->mapEntry[i].origLocation) >= 0xFFFFFFF0) {
+                        struct sparingEntry *entry = &st->mapEntry[i];
+                        u32 origLoc = le32_to_cpu(entry->origLocation);
+                        if (origLoc >= 0xFFFFFFF0)
                                 break;
-                        } else if (le32_to_cpu(st->mapEntry[i].origLocation) == packet) {
-                                return le32_to_cpu(st->mapEntry[i].mappedLocation) +
-                                        ((block + offset) & (UDF_SB_TYPESPAR(sb,partition).s_packet_len - 1));
-                        } else if (le32_to_cpu(st->mapEntry[i].origLocation) > packet) {
+                        else if (origLoc == packet)
+                                return le32_to_cpu(entry->mappedLocation) +
+                                        ((block + offset) &
+                                                (sdata->s_packet_len - 1));
+                        else if (origLoc > packet)
                                 break;
-                        }
                 }
         }
 
-        return UDF_SB_PARTROOT(sb,partition) + block + offset;
+        return map->s_partition_root + block + offset;
 }
 
 int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
@@ -132,69 +153,109 @@ int udf_relocate_blocks(struct super_block *sb, long old_block, long *new_block)
         struct sparingEntry mapEntry;
         uint32_t packet;
         int i, j, k, l;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        u16 reallocationTableLen;
+        struct buffer_head *bh;
 
-        for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
-                if (old_block > UDF_SB_PARTROOT(sb,i) &&
-                    old_block < UDF_SB_PARTROOT(sb,i) + UDF_SB_PARTLEN(sb,i)) {
-                        sdata = &UDF_SB_TYPESPAR(sb,i);
-                        packet = (old_block - UDF_SB_PARTROOT(sb,i)) & ~(sdata->s_packet_len - 1);
+        for (i = 0; i < sbi->s_partitions; i++) {
+                struct udf_part_map *map = &sbi->s_partmaps[i];
+                if (old_block > map->s_partition_root &&
+                    old_block < map->s_partition_root + map->s_partition_len) {
+                        sdata = &map->s_type_specific.s_sparing;
+                        packet = (old_block - map->s_partition_root) &
+                                                ~(sdata->s_packet_len - 1);
 
-                        for (j = 0; j < 4; j++) {
-                                if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
-                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
+                        for (j = 0; j < 4; j++)
+                                if (sdata->s_spar_map[j] != NULL) {
+                                        st = (struct sparingTable *)
+                                                sdata->s_spar_map[j]->b_data;
                                         break;
                                 }
-                        }
 
                         if (!st)
                                 return 1;
 
-                        for (k = 0; k < le16_to_cpu(st->reallocationTableLen); k++) {
-                                if (le32_to_cpu(st->mapEntry[k].origLocation) == 0xFFFFFFFF) {
+                        reallocationTableLen =
+                                        le16_to_cpu(st->reallocationTableLen);
+                        for (k = 0; k < reallocationTableLen; k++) {
+                                struct sparingEntry *entry = &st->mapEntry[k];
+                                u32 origLoc = le32_to_cpu(entry->origLocation);
+
+                                if (origLoc == 0xFFFFFFFF) {
                                         for (; j < 4; j++) {
-                                                if (sdata->s_spar_map[j]) {
-                                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
-                                                        st->mapEntry[k].origLocation = cpu_to_le32(packet);
-                                                        udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
-                                                        mark_buffer_dirty(sdata->s_spar_map[j]);
-                                                }
+                                                int len;
+                                                bh = sdata->s_spar_map[j];
+                                                if (!bh)
+                                                        continue;
+
+                                                st = (struct sparingTable *)
+                                                                bh->b_data;
+                                                entry->origLocation =
+                                                        cpu_to_le32(packet);
+                                                len =
+                                                  sizeof(struct sparingTable) +
+                                                  reallocationTableLen *
+                                                  sizeof(struct sparingEntry);
+                                                udf_update_tag((char *)st, len);
+                                                mark_buffer_dirty(bh);
                                         }
-                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
-                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
+                                        *new_block = le32_to_cpu(
+                                                        entry->mappedLocation) +
+                                                     ((old_block -
+                                                        map->s_partition_root) &
+                                                     (sdata->s_packet_len - 1));
                                         return 0;
-                                } else if (le32_to_cpu(st->mapEntry[k].origLocation) == packet) {
-                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
-                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
+                                } else if (origLoc == packet) {
+                                        *new_block = le32_to_cpu(
+                                                        entry->mappedLocation) +
+                                                     ((old_block -
+                                                        map->s_partition_root) &
+                                                     (sdata->s_packet_len - 1));
                                         return 0;
-                                } else if (le32_to_cpu(st->mapEntry[k].origLocation) > packet) {
+                                } else if (origLoc > packet)
                                         break;
-                                }
                         }
 
-                        for (l = k; l < le16_to_cpu(st->reallocationTableLen); l++) {
-                                if (le32_to_cpu(st->mapEntry[l].origLocation) == 0xFFFFFFFF) {
-                                        for (; j < 4; j++) {
-                                                if (sdata->s_spar_map[j]) {
-                                                        st = (struct sparingTable *)sdata->s_spar_map[j]->b_data;
-                                                        mapEntry = st->mapEntry[l];
-                                                        mapEntry.origLocation = cpu_to_le32(packet);
-                                                        memmove(&st->mapEntry[k + 1], &st->mapEntry[k], (l - k) * sizeof(struct sparingEntry));
-                                                        st->mapEntry[k] = mapEntry;
-                                                        udf_update_tag((char *)st, sizeof(struct sparingTable) + le16_to_cpu(st->reallocationTableLen) * sizeof(struct sparingEntry));
-                                                        mark_buffer_dirty(sdata->s_spar_map[j]);
-                                                }
-                                        }
-                                        *new_block = le32_to_cpu(st->mapEntry[k].mappedLocation) +
-                                                ((old_block - UDF_SB_PARTROOT(sb,i)) & (sdata->s_packet_len - 1));
-                                        return 0;
+                        for (l = k; l < reallocationTableLen; l++) {
+                                struct sparingEntry *entry = &st->mapEntry[l];
+                                u32 origLoc = le32_to_cpu(entry->origLocation);
+
+                                if (origLoc != 0xFFFFFFFF)
+                                        continue;
+
+                                for (; j < 4; j++) {
+                                        bh = sdata->s_spar_map[j];
+                                        if (!bh)
+                                                continue;
+
+                                        st = (struct sparingTable *)bh->b_data;
+                                        mapEntry = st->mapEntry[l];
+                                        mapEntry.origLocation =
+                                                        cpu_to_le32(packet);
+                                        memmove(&st->mapEntry[k + 1],
+                                                &st->mapEntry[k],
+                                                (l - k) *
+                                                sizeof(struct sparingEntry));
+                                        st->mapEntry[k] = mapEntry;
+                                        udf_update_tag((char *)st,
+                                                sizeof(struct sparingTable) +
+                                                reallocationTableLen *
+                                                sizeof(struct sparingEntry));
+                                        mark_buffer_dirty(bh);
                                 }
+                                *new_block =
+                                        le32_to_cpu(
+                                              st->mapEntry[k].mappedLocation) +
+                                        ((old_block - map->s_partition_root) &
+                                         (sdata->s_packet_len - 1));
+                                return 0;
                         }
 
                         return 1;
                 } /* if old_block */
         }
 
-        if (i == UDF_SB_NUMPARTS(sb)) {
+        if (i == sbi->s_partitions) {
                 /* outside of partitions */
                 /* for now, fail =) */
                 return 1;
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 4360c7a05743..f3ac4abfc946 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -33,8 +33,8 @@
  *  10/17/98      added freespace count for "df"
  *  11/11/98 gr   added novrs option
  *  11/26/98 dgb  added fileset,anchor mount options
- *  12/06/98 blf  really hosed things royally. vat/sparing support. sequenced vol descs
- *                rewrote option handling based on isofs
+ *  12/06/98 blf  really hosed things royally. vat/sparing support. sequenced
+ *                vol descs. rewrote option handling based on isofs
  *  12/20/98      find the free space bitmap (if it exists)
  */
 
@@ -52,6 +52,9 @@
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
 #include <linux/vmalloc.h>
+#include <linux/errno.h>
+#include <linux/mount.h>
+#include <linux/seq_file.h>
 #include <asm/byteorder.h>
 
 #include <linux/udf_fs.h>
@@ -70,6 +73,8 @@
 #define VDS_POS_TERMINATING_DESC        6
 #define VDS_POS_LENGTH                  7
 
+#define UDF_DEFAULT_BLOCKSIZE 2048
+
 static char error_buf[1024];
 
 /* These are the "meat" - everything else is stuffing */
@@ -94,6 +99,17 @@ static void udf_open_lvid(struct super_block *);
 static void udf_close_lvid(struct super_block *);
 static unsigned int udf_count_free(struct super_block *);
 static int udf_statfs(struct dentry *, struct kstatfs *);
+static int udf_show_options(struct seq_file *, struct vfsmount *);
+
+struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi)
+{
+        struct logicalVolIntegrityDesc *lvid =
+                (struct logicalVolIntegrityDesc *)sbi->s_lvid_bh->b_data;
+        __u32 number_of_partitions = le32_to_cpu(lvid->numOfPartitions);
+        __u32 offset = number_of_partitions * 2 *
+                                sizeof(uint32_t)/sizeof(uint8_t);
+        return (struct logicalVolIntegrityDescImpUse *)&(lvid->impUse[offset]);
+}
 
 /* UDF filesystem type */
 static int udf_get_sb(struct file_system_type *fs_type,
@@ -116,7 +132,7 @@ static struct kmem_cache *udf_inode_cachep;
 static struct inode *udf_alloc_inode(struct super_block *sb)
 {
         struct udf_inode_info *ei;
-        ei = (struct udf_inode_info *)kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
+        ei = kmem_cache_alloc(udf_inode_cachep, GFP_KERNEL);
         if (!ei)
                 return NULL;
 
@@ -170,6 +186,7 @@ static const struct super_operations udf_sb_ops = {
         .write_super    = udf_write_super,
         .statfs         = udf_statfs,
         .remount_fs     = udf_remount_fs,
+        .show_options   = udf_show_options,
 };
 
 struct udf_options {
@@ -218,6 +235,79 @@ static void __exit exit_udf_fs(void)
 module_init(init_udf_fs)
 module_exit(exit_udf_fs)
 
+static int udf_sb_alloc_partition_maps(struct super_block *sb, u32 count)
+{
+        struct udf_sb_info *sbi = UDF_SB(sb);
+
+        sbi->s_partmaps = kcalloc(count, sizeof(struct udf_part_map),
+                                  GFP_KERNEL);
+        if (!sbi->s_partmaps) {
+                udf_error(sb, __FUNCTION__,
+                          "Unable to allocate space for %d partition maps",
+                          count);
+                sbi->s_partitions = 0;
+                return -ENOMEM;
+        }
+
+        sbi->s_partitions = count;
+        return 0;
+}
+
+static int udf_show_options(struct seq_file *seq, struct vfsmount *mnt)
+{
+        struct super_block *sb = mnt->mnt_sb;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+
+        if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT))
+                seq_puts(seq, ",nostrict");
+        if (sb->s_blocksize != UDF_DEFAULT_BLOCKSIZE)
+                seq_printf(seq, ",bs=%lu", sb->s_blocksize);
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNHIDE))
+                seq_puts(seq, ",unhide");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UNDELETE))
+                seq_puts(seq, ",undelete");
+        if (!UDF_QUERY_FLAG(sb, UDF_FLAG_USE_AD_IN_ICB))
+                seq_puts(seq, ",noadinicb");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_USE_SHORT_AD))
+                seq_puts(seq, ",shortad");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_FORGET))
+                seq_puts(seq, ",uid=forget");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_IGNORE))
+                seq_puts(seq, ",uid=ignore");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_FORGET))
+                seq_puts(seq, ",gid=forget");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_IGNORE))
+                seq_puts(seq, ",gid=ignore");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UID_SET))
+                seq_printf(seq, ",uid=%u", sbi->s_uid);
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_GID_SET))
+                seq_printf(seq, ",gid=%u", sbi->s_gid);
+        if (sbi->s_umask != 0)
+                seq_printf(seq, ",umask=%o", sbi->s_umask);
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_SESSION_SET))
+                seq_printf(seq, ",session=%u", sbi->s_session);
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_LASTBLOCK_SET))
+                seq_printf(seq, ",lastblock=%u", sbi->s_last_block);
+        /*
+         * s_anchor[2] could be zeroed out in case there is no anchor
+         * in the specified block, but then the "anchor=N" option
+         * originally given by the user wasn't effective, so it's OK
+         * if we don't show it.
+         */
+        if (sbi->s_anchor[2] != 0)
+                seq_printf(seq, ",anchor=%u", sbi->s_anchor[2]);
+        /*
+         * volume, partition, fileset and rootdir seem to be ignored
+         * currently
+         */
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8))
+                seq_puts(seq, ",utf8");
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP) && sbi->s_nls_map)
+                seq_printf(seq, ",iocharset=%s", sbi->s_nls_map->charset);
+
+        return 0;
+}
+
 /*
  * udf_parse_options
  *
@@ -310,13 +400,14 @@ static match_table_t tokens = {
         {Opt_err,       NULL}
 };
 
-static int udf_parse_options(char *options, struct udf_options *uopt)
+static int udf_parse_options(char *options, struct udf_options *uopt,
+                             bool remount)
 {
         char *p;
         int option;
 
         uopt->novrs = 0;
-        uopt->blocksize = 2048;
+        uopt->blocksize = UDF_DEFAULT_BLOCKSIZE;
         uopt->partition = 0xFFFF;
         uopt->session = 0xFFFFFFFF;
         uopt->lastblock = 0;
@@ -386,11 +477,15 @@ static int udf_parse_options(char *options, struct udf_options *uopt)
                         if (match_int(args, &option))
                                 return 0;
                         uopt->session = option;
+                        if (!remount)
+                                uopt->flags |= (1 << UDF_FLAG_SESSION_SET);
                         break;
                 case Opt_lastblock:
                         if (match_int(args, &option))
                                 return 0;
                         uopt->lastblock = option;
+                        if (!remount)
+                                uopt->flags |= (1 << UDF_FLAG_LASTBLOCK_SET);
                         break;
                 case Opt_anchor:
                         if (match_int(args, &option))
@@ -447,7 +542,7 @@ static int udf_parse_options(char *options, struct udf_options *uopt)
         return 1;
 }
 
-void udf_write_super(struct super_block *sb)
+static void udf_write_super(struct super_block *sb)
 {
         lock_kernel();
 
@@ -461,22 +556,23 @@ void udf_write_super(struct super_block *sb)
 static int udf_remount_fs(struct super_block *sb, int *flags, char *options)
 {
         struct udf_options uopt;
+        struct udf_sb_info *sbi = UDF_SB(sb);
 
-        uopt.flags = UDF_SB(sb)->s_flags;
-        uopt.uid   = UDF_SB(sb)->s_uid;
-        uopt.gid   = UDF_SB(sb)->s_gid;
-        uopt.umask = UDF_SB(sb)->s_umask;
+        uopt.flags = sbi->s_flags;
+        uopt.uid   = sbi->s_uid;
+        uopt.gid   = sbi->s_gid;
+        uopt.umask = sbi->s_umask;
 
-        if (!udf_parse_options(options, &uopt))
+        if (!udf_parse_options(options, &uopt, true))
                 return -EINVAL;
 
-        UDF_SB(sb)->s_flags = uopt.flags;
-        UDF_SB(sb)->s_uid   = uopt.uid;
-        UDF_SB(sb)->s_gid   = uopt.gid;
-        UDF_SB(sb)->s_umask = uopt.umask;
+        sbi->s_flags = uopt.flags;
+        sbi->s_uid   = uopt.uid;
+        sbi->s_gid   = uopt.gid;
+        sbi->s_umask = uopt.umask;
 
-        if (UDF_SB_LVIDBH(sb)) {
-                int write_rev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
+        if (sbi->s_lvid_bh) {
+                int write_rev = le16_to_cpu(udf_sb_lvidiu(sbi)->minUDFWriteRev);
                 if (write_rev > UDF_MAX_WRITE_VERSION)
                         *flags |= MS_RDONLY;
         }
@@ -538,17 +634,19 @@ static int udf_vrs(struct super_block *sb, int silent)
         int iso9660 = 0;
         int nsr02 = 0;
         int nsr03 = 0;
+        struct udf_sb_info *sbi;
 
         /* Block size must be a multiple of 512 */
         if (sb->s_blocksize & 511)
                 return 0;
+        sbi = UDF_SB(sb);
 
         if (sb->s_blocksize < sizeof(struct volStructDesc))
                 sectorsize = sizeof(struct volStructDesc);
         else
                 sectorsize = sb->s_blocksize;
 
-        sector += (UDF_SB_SESSION(sb) << sb->s_blocksize_bits);
+        sector += (sbi->s_session << sb->s_blocksize_bits);
 
         udf_debug("Starting at sector %u (%ld byte sectors)\n",
                   (sector >> sb->s_blocksize_bits), sb->s_blocksize);
@@ -561,47 +659,52 @@ static int udf_vrs(struct super_block *sb, int silent)
 
                 /* Look for ISO  descriptors */
                 vsd = (struct volStructDesc *)(bh->b_data +
-                                               (sector & (sb->s_blocksize - 1)));
+                                              (sector & (sb->s_blocksize - 1)));
 
                 if (vsd->stdIdent[0] == 0) {
                         brelse(bh);
                         break;
-                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001,
+                                    VSD_STD_ID_LEN)) {
                         iso9660 = sector;
                         switch (vsd->structType) {
                         case 0:
                                 udf_debug("ISO9660 Boot Record found\n");
                                 break;
                         case 1:
-                                udf_debug
-                                    ("ISO9660 Primary Volume Descriptor found\n");
+                                udf_debug("ISO9660 Primary Volume Descriptor "
+                                          "found\n");
                                 break;
                         case 2:
-                                udf_debug
-                                    ("ISO9660 Supplementary Volume Descriptor found\n");
+                                udf_debug("ISO9660 Supplementary Volume "
+                                          "Descriptor found\n");
                                 break;
                         case 3:
-                                udf_debug
-                                    ("ISO9660 Volume Partition Descriptor found\n");
+                                udf_debug("ISO9660 Volume Partition Descriptor "
+                                          "found\n");
                                 break;
                         case 255:
-                                udf_debug
-                                    ("ISO9660 Volume Descriptor Set Terminator found\n");
+                                udf_debug("ISO9660 Volume Descriptor Set "
+                                          "Terminator found\n");
                                 break;
                         default:
                                 udf_debug("ISO9660 VRS (%u) found\n",
                                           vsd->structType);
                                 break;
                         }
-                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01, VSD_STD_ID_LEN)) {
-                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_BEA01,
+                                    VSD_STD_ID_LEN))
+                        ; /* nothing */
+                else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01,
+                                    VSD_STD_ID_LEN)) {
                         brelse(bh);
                         break;
-                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN)) {
+                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02,
+                                    VSD_STD_ID_LEN))
                         nsr02 = sector;
-                } else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03, VSD_STD_ID_LEN)) {
+                else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR03,
+                                    VSD_STD_ID_LEN))
                         nsr03 = sector;
-                }
                 brelse(bh);
         }
 
@@ -609,7 +712,7 @@ static int udf_vrs(struct super_block *sb, int silent)
                 return nsr03;
         else if (nsr02)
                 return nsr02;
-        else if (sector - (UDF_SB_SESSION(sb) << sb->s_blocksize_bits) == 32768)
+        else if (sector - (sbi->s_session << sb->s_blocksize_bits) == 32768)
                 return -1;
         else
                 return 0;
@@ -634,11 +737,15 @@ static int udf_vrs(struct super_block *sb, int silent)
  */
 static void udf_find_anchor(struct super_block *sb)
 {
-        int lastblock = UDF_SB_LASTBLOCK(sb);
+        int lastblock;
         struct buffer_head *bh = NULL;
         uint16_t ident;
         uint32_t location;
         int i;
+        struct udf_sb_info *sbi;
+
+        sbi = UDF_SB(sb);
+        lastblock = sbi->s_last_block;
 
         if (lastblock) {
                 int varlastblock = udf_variable_to_fixed(lastblock);
@@ -658,57 +765,83 @@ static void udf_find_anchor(struct super_block *sb)
                  *  however, if the disc isn't closed, it could be 512 */
 
                 for (i = 0; !lastblock && i < ARRAY_SIZE(last); i++) {
-                        if (last[i] < 0 || !(bh = sb_bread(sb, last[i]))) {
-                                ident = location = 0;
-                        } else {
-                                ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
-                                location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
-                                brelse(bh);
+                        ident = location = 0;
+                        if (last[i] >= 0) {
+                                bh = sb_bread(sb, last[i]);
+                                if (bh) {
+                                        tag *t = (tag *)bh->b_data;
+                                        ident = le16_to_cpu(t->tagIdent);
+                                        location = le32_to_cpu(t->tagLocation);
+                                        brelse(bh);
+                                }
                         }
 
                         if (ident == TAG_IDENT_AVDP) {
-                                if (location == last[i] - UDF_SB_SESSION(sb)) {
-                                        lastblock = UDF_SB_ANCHOR(sb)[0] = last[i] - UDF_SB_SESSION(sb);
-                                        UDF_SB_ANCHOR(sb)[1] = last[i] - 256 - UDF_SB_SESSION(sb);
-                                } else if (location == udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb)) {
+                                if (location == last[i] - sbi->s_session) {
+                                        lastblock = last[i] - sbi->s_session;
+                                        sbi->s_anchor[0] = lastblock;
+                                        sbi->s_anchor[1] = lastblock - 256;
+                                } else if (location ==
+                                                udf_variable_to_fixed(last[i]) -
+                                                        sbi->s_session) {
                                         UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
-                                        lastblock = UDF_SB_ANCHOR(sb)[0] = udf_variable_to_fixed(last[i]) - UDF_SB_SESSION(sb);
-                                        UDF_SB_ANCHOR(sb)[1] = lastblock - 256 - UDF_SB_SESSION(sb);
+                                        lastblock =
+                                                udf_variable_to_fixed(last[i]) -
+                                                        sbi->s_session;
+                                        sbi->s_anchor[0] = lastblock;
+                                        sbi->s_anchor[1] = lastblock - 256 -
+                                                                sbi->s_session;
                                 } else {
-                                        udf_debug("Anchor found at block %d, location mismatch %d.\n",
+                                        udf_debug("Anchor found at block %d, "
+                                                  "location mismatch %d.\n",
                                                   last[i], location);
                                 }
-                        } else if (ident == TAG_IDENT_FE || ident == TAG_IDENT_EFE) {
+                        } else if (ident == TAG_IDENT_FE ||
+                                        ident == TAG_IDENT_EFE) {
                                 lastblock = last[i];
-                                UDF_SB_ANCHOR(sb)[3] = 512;
+                                sbi->s_anchor[3] = 512;
                         } else {
-                                if (last[i] < 256 || !(bh = sb_bread(sb, last[i] - 256))) {
-                                        ident = location = 0;
-                                } else {
-                                        ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
-                                        location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
-                                        brelse(bh);
+                                ident = location = 0;
+                                if (last[i] >= 256) {
+                                        bh = sb_bread(sb, last[i] - 256);
+                                        if (bh) {
+                                                tag *t = (tag *)bh->b_data;
+                                                ident = le16_to_cpu(
+                                                                t->tagIdent);
+                                                location = le32_to_cpu(
+                                                                t->tagLocation);
+                                                brelse(bh);
+                                        }
                                 }
 
                                 if (ident == TAG_IDENT_AVDP &&
-                                    location == last[i] - 256 - UDF_SB_SESSION(sb)) {
+                                    location == last[i] - 256 -
+                                                sbi->s_session) {
                                         lastblock = last[i];
-                                        UDF_SB_ANCHOR(sb)[1] = last[i] - 256;
+                                        sbi->s_anchor[1] = last[i] - 256;
                                 } else {
-                                        if (last[i] < 312 + UDF_SB_SESSION(sb) ||
-                                            !(bh = sb_bread(sb, last[i] - 312 - UDF_SB_SESSION(sb)))) {
-                                                ident = location = 0;
-                                        } else {
-                                                ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
-                                                location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
-                                                brelse(bh);
+                                        ident = location = 0;
+                                        if (last[i] >= 312 + sbi->s_session) {
+                                                bh = sb_bread(sb,
+                                                                last[i] - 312 -
+                                                                sbi->s_session);
+                                                if (bh) {
+                                                        tag *t = (tag *)
+                                                                 bh->b_data;
+                                                        ident = le16_to_cpu(
+                                                                t->tagIdent);
+                                                        location = le32_to_cpu(
+                                                                t->tagLocation);
+                                                        brelse(bh);
+                                                }
                                         }
 
                                         if (ident == TAG_IDENT_AVDP &&
                                             location == udf_variable_to_fixed(last[i]) - 256) {
-                                                UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
+                                                UDF_SET_FLAG(sb,
+                                                             UDF_FLAG_VARCONV);
                                                 lastblock = udf_variable_to_fixed(last[i]);
-                                                UDF_SB_ANCHOR(sb)[1] = lastblock - 256;
+                                                sbi->s_anchor[1] = lastblock - 256;
                                         }
                                 }
                         }
@@ -716,10 +849,12 @@ static void udf_find_anchor(struct super_block *sb)
         }
 
         if (!lastblock) {
-                /* We havn't found the lastblock. check 312 */
-                if ((bh = sb_bread(sb, 312 + UDF_SB_SESSION(sb)))) {
-                        ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
-                        location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
+                /* We haven't found the lastblock. check 312 */
+                bh = sb_bread(sb, 312 + sbi->s_session);
+                if (bh) {
+                        tag *t = (tag *)bh->b_data;
+                        ident = le16_to_cpu(t->tagIdent);
+                        location = le32_to_cpu(t->tagLocation);
                         brelse(bh);
 
                         if (ident == TAG_IDENT_AVDP && location == 256)
@@ -727,29 +862,33 @@ static void udf_find_anchor(struct super_block *sb)
                 }
         }
 
-        for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
-                if (UDF_SB_ANCHOR(sb)[i]) {
-                        if (!(bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
-                                                   UDF_SB_ANCHOR(sb)[i], &ident))) {
-                                UDF_SB_ANCHOR(sb)[i] = 0;
-                        } else {
+        for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
+                if (sbi->s_anchor[i]) {
+                        bh = udf_read_tagged(sb, sbi->s_anchor[i],
+                                             sbi->s_anchor[i], &ident);
+                        if (!bh)
+                                sbi->s_anchor[i] = 0;
+                        else {
                                 brelse(bh);
                                 if ((ident != TAG_IDENT_AVDP) &&
-                                    (i || (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE))) {
-                                        UDF_SB_ANCHOR(sb)[i] = 0;
-                                }
+                                    (i || (ident != TAG_IDENT_FE &&
+                                           ident != TAG_IDENT_EFE)))
+                                        sbi->s_anchor[i] = 0;
                         }
                 }
         }
 
-        UDF_SB_LASTBLOCK(sb) = lastblock;
+        sbi->s_last_block = lastblock;
 }
 
-static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr *root)
+static int udf_find_fileset(struct super_block *sb,
+                            kernel_lb_addr *fileset,
+                            kernel_lb_addr *root)
 {
         struct buffer_head *bh = NULL;
         long lastblock;
         uint16_t ident;
+        struct udf_sb_info *sbi;
 
         if (fileset->logicalBlockNum != 0xFFFFFFFF ||
             fileset->partitionReferenceNum != 0xFFFF) {
@@ -764,22 +903,27 @@ static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, ker
 
         }
 
-        if (!bh) { /* Search backwards through the partitions */
+        sbi = UDF_SB(sb);
+        if (!bh) {
+                /* Search backwards through the partitions */
                 kernel_lb_addr newfileset;
 
 /* --> cvg: FIXME - is it reasonable? */
                 return 1;
 
-                for (newfileset.partitionReferenceNum = UDF_SB_NUMPARTS(sb) - 1;
+                for (newfileset.partitionReferenceNum = sbi->s_partitions - 1;
                      (newfileset.partitionReferenceNum != 0xFFFF &&
                       fileset->logicalBlockNum == 0xFFFFFFFF &&
                       fileset->partitionReferenceNum == 0xFFFF);
                      newfileset.partitionReferenceNum--) {
-                        lastblock = UDF_SB_PARTLEN(sb, newfileset.partitionReferenceNum);
+                        lastblock = sbi->s_partmaps
+                                        [newfileset.partitionReferenceNum]
+                                                .s_partition_len;
                         newfileset.logicalBlockNum = 0;
 
                         do {
-                                bh = udf_read_ptagged(sb, newfileset, 0, &ident);
+                                bh = udf_read_ptagged(sb, newfileset, 0,
+                                                      &ident);
                                 if (!bh) {
                                         newfileset.logicalBlockNum++;
                                         continue;
@@ -789,11 +933,12 @@ static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, ker
                                 case TAG_IDENT_SBD:
                                 {
                                         struct spaceBitmapDesc *sp;
-                                        sp = (struct spaceBitmapDesc *)bh->b_data;
+                                        sp = (struct spaceBitmapDesc *)
+                                                                bh->b_data;
                                         newfileset.logicalBlockNum += 1 +
                                                 ((le32_to_cpu(sp->numOfBytes) +
-                                                  sizeof(struct spaceBitmapDesc) - 1)
-                                                 >> sb->s_blocksize_bits);
+                                                  sizeof(struct spaceBitmapDesc)
+                                                  - 1) >> sb->s_blocksize_bits);
                                         brelse(bh);
                                         break;
                                 }
@@ -818,7 +963,7 @@ static int udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, ker
                           fileset->logicalBlockNum,
                           fileset->partitionReferenceNum);
 
-                UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
+                sbi->s_partition = fileset->partitionReferenceNum;
                 udf_load_fileset(sb, bh, root);
                 brelse(bh);
                 return 0;
@@ -840,26 +985,26 @@ static void udf_load_pvoldesc(struct super_block *sb, struct buffer_head *bh)
                               lets_to_cpu(pvoldesc->recordingDateAndTime))) {
                 kernel_timestamp ts;
                 ts = lets_to_cpu(pvoldesc->recordingDateAndTime);
-                udf_debug("recording time %ld/%ld, %04u/%02u/%02u %02u:%02u (%x)\n",
+                udf_debug("recording time %ld/%ld, %04u/%02u/%02u"
+                          " %02u:%02u (%x)\n",
                           recording, recording_usec,
                           ts.year, ts.month, ts.day, ts.hour,
                           ts.minute, ts.typeAndTimezone);
-                UDF_SB_RECORDTIME(sb).tv_sec = recording;
-                UDF_SB_RECORDTIME(sb).tv_nsec = recording_usec * 1000;
+                UDF_SB(sb)->s_record_time.tv_sec = recording;
+                UDF_SB(sb)->s_record_time.tv_nsec = recording_usec * 1000;
         }
 
-        if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32)) {
+        if (!udf_build_ustr(&instr, pvoldesc->volIdent, 32))
                 if (udf_CS0toUTF8(&outstr, &instr)) {
-                        strncpy(UDF_SB_VOLIDENT(sb), outstr.u_name,
+                        strncpy(UDF_SB(sb)->s_volume_ident, outstr.u_name,
                                 outstr.u_len > 31 ? 31 : outstr.u_len);
-                        udf_debug("volIdent[] = '%s'\n", UDF_SB_VOLIDENT(sb));
+                        udf_debug("volIdent[] = '%s'\n",
+                                        UDF_SB(sb)->s_volume_ident);
                 }
-        }
 
-        if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128)) {
+        if (!udf_build_ustr(&instr, pvoldesc->volSetIdent, 128))
                 if (udf_CS0toUTF8(&outstr, &instr))
                         udf_debug("volSetIdent[] = '%s'\n", outstr.u_name);
-        }
 }
 
 static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
@@ -871,65 +1016,124 @@ static void udf_load_fileset(struct super_block *sb, struct buffer_head *bh,
 
         *root = lelb_to_cpu(fset->rootDirectoryICB.extLocation);
 
-        UDF_SB_SERIALNUM(sb) = le16_to_cpu(fset->descTag.tagSerialNum);
+        UDF_SB(sb)->s_serial_number = le16_to_cpu(fset->descTag.tagSerialNum);
 
         udf_debug("Rootdir at block=%d, partition=%d\n",
                   root->logicalBlockNum, root->partitionReferenceNum);
 }
 
+int udf_compute_nr_groups(struct super_block *sb, u32 partition)
+{
+        struct udf_part_map *map = &UDF_SB(sb)->s_partmaps[partition];
+        return (map->s_partition_len +
+                (sizeof(struct spaceBitmapDesc) << 3) +
+                (sb->s_blocksize * 8) - 1) /
+                (sb->s_blocksize * 8);
+}
+
+static struct udf_bitmap *udf_sb_alloc_bitmap(struct super_block *sb, u32 index)
+{
+        struct udf_bitmap *bitmap;
+        int nr_groups;
+        int size;
+
+        nr_groups = udf_compute_nr_groups(sb, index);
+        size = sizeof(struct udf_bitmap) +
+                (sizeof(struct buffer_head *) * nr_groups);
+
+        if (size <= PAGE_SIZE)
+                bitmap = kmalloc(size, GFP_KERNEL);
+        else
+                bitmap = vmalloc(size); /* TODO: get rid of vmalloc */
+
+        if (bitmap == NULL) {
+                udf_error(sb, __FUNCTION__,
+                          "Unable to allocate space for bitmap "
+                          "and %d buffer_head pointers", nr_groups);
+                return NULL;
+        }
+
+        memset(bitmap, 0x00, size);
+        bitmap->s_block_bitmap = (struct buffer_head **)(bitmap + 1);
+        bitmap->s_nr_groups = nr_groups;
+        return bitmap;
+}
+
 static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
 {
         struct partitionDesc *p;
         int i;
+        struct udf_part_map *map;
+        struct udf_sb_info *sbi;
 
         p = (struct partitionDesc *)bh->b_data;
+        sbi = UDF_SB(sb);
 
-        for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
+        for (i = 0; i < sbi->s_partitions; i++) {
+                map = &sbi->s_partmaps[i];
                 udf_debug("Searching map: (%d == %d)\n",
-                          UDF_SB_PARTMAPS(sb)[i].s_partition_num, le16_to_cpu(p->partitionNumber));
-                if (UDF_SB_PARTMAPS(sb)[i].s_partition_num == le16_to_cpu(p->partitionNumber)) {
-                        UDF_SB_PARTLEN(sb,i) = le32_to_cpu(p->partitionLength); /* blocks */
-                        UDF_SB_PARTROOT(sb,i) = le32_to_cpu(p->partitionStartingLocation);
-                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_READ_ONLY)
-                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_READ_ONLY;
-                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_WRITE_ONCE)
-                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_WRITE_ONCE;
-                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_REWRITABLE)
-                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_REWRITABLE;
-                        if (le32_to_cpu(p->accessType) == PD_ACCESS_TYPE_OVERWRITABLE)
-                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_OVERWRITABLE;
-
-                        if (!strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR02) ||
-                            !strcmp(p->partitionContents.ident, PD_PARTITION_CONTENTS_NSR03)) {
+                          map->s_partition_num,
+                          le16_to_cpu(p->partitionNumber));
+                if (map->s_partition_num ==
+                                le16_to_cpu(p->partitionNumber)) {
+                        map->s_partition_len =
+                                le32_to_cpu(p->partitionLength); /* blocks */
+                        map->s_partition_root =
+                                le32_to_cpu(p->partitionStartingLocation);
+                        if (p->accessType ==
+                                        cpu_to_le32(PD_ACCESS_TYPE_READ_ONLY))
+                                map->s_partition_flags |=
+                                                UDF_PART_FLAG_READ_ONLY;
+                        if (p->accessType ==
+                                        cpu_to_le32(PD_ACCESS_TYPE_WRITE_ONCE))
+                                map->s_partition_flags |=
+                                                UDF_PART_FLAG_WRITE_ONCE;
+                        if (p->accessType ==
+                                        cpu_to_le32(PD_ACCESS_TYPE_REWRITABLE))
+                                map->s_partition_flags |=
+                                                UDF_PART_FLAG_REWRITABLE;
+                        if (p->accessType ==
+                                    cpu_to_le32(PD_ACCESS_TYPE_OVERWRITABLE))
+                                map->s_partition_flags |=
+                                                UDF_PART_FLAG_OVERWRITABLE;
+
+                        if (!strcmp(p->partitionContents.ident,
+                                    PD_PARTITION_CONTENTS_NSR02) ||
+                            !strcmp(p->partitionContents.ident,
+                                    PD_PARTITION_CONTENTS_NSR03)) {
                                 struct partitionHeaderDesc *phd;
 
-                                phd = (struct partitionHeaderDesc *)(p->partitionContentsUse);
+                                phd = (struct partitionHeaderDesc *)
+                                                (p->partitionContentsUse);
                                 if (phd->unallocSpaceTable.extLength) {
                                         kernel_lb_addr loc = {
                                                 .logicalBlockNum = le32_to_cpu(phd->unallocSpaceTable.extPosition),
                                                 .partitionReferenceNum = i,
                                         };
 
-                                        UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table =
+                                        map->s_uspace.s_table =
                                                 udf_iget(sb, loc);
-                                        if (!UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table) {
+                                        if (!map->s_uspace.s_table) {
                                                 udf_debug("cannot load unallocSpaceTable (part %d)\n", i);
                                                 return 1;
                                         }
-                                        UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_TABLE;
+                                        map->s_partition_flags |=
+                                                UDF_PART_FLAG_UNALLOC_TABLE;
                                         udf_debug("unallocSpaceTable (part %d) @ %ld\n",
-                                                  i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_table->i_ino);
+                                                  i, map->s_uspace.s_table->i_ino);
                                 }
                                 if (phd->unallocSpaceBitmap.extLength) {
-                                        UDF_SB_ALLOC_BITMAP(sb, i, s_uspace);
-                                        if (UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap != NULL) {
-                                                UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extLength =
+                                        struct udf_bitmap *bitmap =
+                                                udf_sb_alloc_bitmap(sb, i);
+                                        map->s_uspace.s_bitmap = bitmap;
+                                        if (bitmap != NULL) {
+                                                bitmap->s_extLength =
                                                         le32_to_cpu(phd->unallocSpaceBitmap.extLength);
-                                                UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition =
+                                                bitmap->s_extPosition =
                                                         le32_to_cpu(phd->unallocSpaceBitmap.extPosition);
-                                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_UNALLOC_BITMAP;
+                                                map->s_partition_flags |= UDF_PART_FLAG_UNALLOC_BITMAP;
                                                 udf_debug("unallocSpaceBitmap (part %d) @ %d\n",
-                                                          i, UDF_SB_PARTMAPS(sb)[i].s_uspace.s_bitmap->s_extPosition);
+                                                          i, bitmap->s_extPosition);
                                         }
                                 }
                                 if (phd->partitionIntegrityTable.extLength)
@@ -940,40 +1144,45 @@ static int udf_load_partdesc(struct super_block *sb, struct buffer_head *bh)
                                                 .partitionReferenceNum = i,
                                         };
 
-                                        UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table =
+                                        map->s_fspace.s_table =
                                                 udf_iget(sb, loc);
-                                        if (!UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table) {
+                                        if (!map->s_fspace.s_table) {
                                                 udf_debug("cannot load freedSpaceTable (part %d)\n", i);
                                                 return 1;
                                         }
-                                        UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_TABLE;
+                                        map->s_partition_flags |=
+                                                UDF_PART_FLAG_FREED_TABLE;
                                         udf_debug("freedSpaceTable (part %d) @ %ld\n",
-                                                  i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_table->i_ino);
+                                                  i, map->s_fspace.s_table->i_ino);
                                 }
                                 if (phd->freedSpaceBitmap.extLength) {
-                                        UDF_SB_ALLOC_BITMAP(sb, i, s_fspace);
-                                        if (UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap != NULL) {
-                                                UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extLength =
+                                        struct udf_bitmap *bitmap =
+                                                udf_sb_alloc_bitmap(sb, i);
+                                        map->s_fspace.s_bitmap = bitmap;
+                                        if (bitmap != NULL) {
+                                                bitmap->s_extLength =
                                                         le32_to_cpu(phd->freedSpaceBitmap.extLength);
-                                                UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition =
+                                                bitmap->s_extPosition =
                                                         le32_to_cpu(phd->freedSpaceBitmap.extPosition);
-                                                UDF_SB_PARTFLAGS(sb,i) |= UDF_PART_FLAG_FREED_BITMAP;
+                                                map->s_partition_flags |= UDF_PART_FLAG_FREED_BITMAP;
                                                 udf_debug("freedSpaceBitmap (part %d) @ %d\n",
-                                                          i, UDF_SB_PARTMAPS(sb)[i].s_fspace.s_bitmap->s_extPosition);
+                                                          i, bitmap->s_extPosition);
                                         }
                                 }
                         }
                         break;
                 }
         }
-        if (i == UDF_SB_NUMPARTS(sb)) {
+        if (i == sbi->s_partitions)
                 udf_debug("Partition (%d) not found in partition map\n",
                           le16_to_cpu(p->partitionNumber));
-        } else {
-                udf_debug("Partition (%d:%d type %x) starts at physical %d, block length %d\n",
-                          le16_to_cpu(p->partitionNumber), i, UDF_SB_PARTTYPE(sb,i),
-                          UDF_SB_PARTROOT(sb,i), UDF_SB_PARTLEN(sb,i));
-        }
+        else
+                udf_debug("Partition (%d:%d type %x) starts at physical %d, "
+                          "block length %d\n",
+                          le16_to_cpu(p->partitionNumber), i,
+                          map->s_partition_type,
+                          map->s_partition_root,
+                          map->s_partition_len);
         return 0;
 }
 
@@ -983,70 +1192,105 @@ static int udf_load_logicalvol(struct super_block *sb, struct buffer_head *bh,
         struct logicalVolDesc *lvd;
         int i, j, offset;
         uint8_t type;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct genericPartitionMap *gpm;
 
         lvd = (struct logicalVolDesc *)bh->b_data;
 
-        UDF_SB_ALLOC_PARTMAPS(sb, le32_to_cpu(lvd->numPartitionMaps));
+        i = udf_sb_alloc_partition_maps(sb, le32_to_cpu(lvd->numPartitionMaps));
+        if (i != 0)
+                return i;
 
         for (i = 0, offset = 0;
-             i < UDF_SB_NUMPARTS(sb) && offset < le32_to_cpu(lvd->mapTableLength);
-             i++, offset += ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapLength) {
-                type = ((struct genericPartitionMap *)&(lvd->partitionMaps[offset]))->partitionMapType;
+             i < sbi->s_partitions && offset < le32_to_cpu(lvd->mapTableLength);
+             i++, offset += gpm->partitionMapLength) {
+                struct udf_part_map *map = &sbi->s_partmaps[i];
+                gpm = (struct genericPartitionMap *)
+                                &(lvd->partitionMaps[offset]);
+                type = gpm->partitionMapType;
                 if (type == 1) {
-                        struct genericPartitionMap1 *gpm1 = (struct genericPartitionMap1 *)&(lvd->partitionMaps[offset]);
-                        UDF_SB_PARTTYPE(sb,i) = UDF_TYPE1_MAP15;
-                        UDF_SB_PARTVSN(sb,i) = le16_to_cpu(gpm1->volSeqNum);
-                        UDF_SB_PARTNUM(sb,i) = le16_to_cpu(gpm1->partitionNum);
-                        UDF_SB_PARTFUNC(sb,i) = NULL;
+                        struct genericPartitionMap1 *gpm1 =
+                                (struct genericPartitionMap1 *)gpm;
+                        map->s_partition_type = UDF_TYPE1_MAP15;
+                        map->s_volumeseqnum = le16_to_cpu(gpm1->volSeqNum);
+                        map->s_partition_num = le16_to_cpu(gpm1->partitionNum);
+                        map->s_partition_func = NULL;
                 } else if (type == 2) {
-                        struct udfPartitionMap2 *upm2 = (struct udfPartitionMap2 *)&(lvd->partitionMaps[offset]);
-                        if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL, strlen(UDF_ID_VIRTUAL))) {
-                                if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0150) {
-                                        UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP15;
-                                        UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt15;
-                                } else if (le16_to_cpu(((__le16 *)upm2->partIdent.identSuffix)[0]) == 0x0200) {
-                                        UDF_SB_PARTTYPE(sb,i) = UDF_VIRTUAL_MAP20;
-                                        UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_virt20;
+                        struct udfPartitionMap2 *upm2 =
+                                                (struct udfPartitionMap2 *)gpm;
+                        if (!strncmp(upm2->partIdent.ident, UDF_ID_VIRTUAL,
+                                                strlen(UDF_ID_VIRTUAL))) {
+                                u16 suf =
+                                        le16_to_cpu(((__le16 *)upm2->partIdent.
+                                                        identSuffix)[0]);
+                                if (suf == 0x0150) {
+                                        map->s_partition_type =
+                                                        UDF_VIRTUAL_MAP15;
+                                        map->s_partition_func =
+                                                        udf_get_pblock_virt15;
+                                } else if (suf == 0x0200) {
+                                        map->s_partition_type =
+                                                        UDF_VIRTUAL_MAP20;
+                                        map->s_partition_func =
+                                                        udf_get_pblock_virt20;
                                 }
-                        } else if (!strncmp(upm2->partIdent.ident, UDF_ID_SPARABLE, strlen(UDF_ID_SPARABLE))) {
+                        } else if (!strncmp(upm2->partIdent.ident,
+                                                UDF_ID_SPARABLE,
+                                                strlen(UDF_ID_SPARABLE))) {
                                 uint32_t loc;
                                 uint16_t ident;
                                 struct sparingTable *st;
-                                struct sparablePartitionMap *spm = (struct sparablePartitionMap *)&(lvd->partitionMaps[offset]);
+                                struct sparablePartitionMap *spm =
+                                        (struct sparablePartitionMap *)gpm;
 
-                                UDF_SB_PARTTYPE(sb,i) = UDF_SPARABLE_MAP15;
-                                UDF_SB_TYPESPAR(sb,i).s_packet_len = le16_to_cpu(spm->packetLength);
+                                map->s_partition_type = UDF_SPARABLE_MAP15;
+                                map->s_type_specific.s_sparing.s_packet_len =
+                                                le16_to_cpu(spm->packetLength);
                                 for (j = 0; j < spm->numSparingTables; j++) {
-                                        loc = le32_to_cpu(spm->locSparingTable[j]);
-                                        UDF_SB_TYPESPAR(sb,i).s_spar_map[j] =
-                                                udf_read_tagged(sb, loc, loc, &ident);
-                                        if (UDF_SB_TYPESPAR(sb,i).s_spar_map[j] != NULL) {
-                                                st = (struct sparingTable *)UDF_SB_TYPESPAR(sb,i).s_spar_map[j]->b_data;
-                                                if (ident != 0 ||
-                                                    strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING))) {
-                                                        brelse(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
-                                                        UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;
+                                        struct buffer_head *bh2;
+
+                                        loc = le32_to_cpu(
+                                                spm->locSparingTable[j]);
+                                        bh2 = udf_read_tagged(sb, loc, loc,
+                                                             &ident);
+                                        map->s_type_specific.s_sparing.
+                                                        s_spar_map[j] = bh2;
+
+                                        if (bh2 != NULL) {
+                                                st = (struct sparingTable *)
+                                                                bh2->b_data;
+                                                if (ident != 0 || strncmp(
+                                                        st->sparingIdent.ident,
+                                                        UDF_ID_SPARING,
+                                                        strlen(UDF_ID_SPARING))) {
+                                                        brelse(bh2);
+                                                        map->s_type_specific.
+                                                                s_sparing.
+                                                                s_spar_map[j] =
+                                                                        NULL;
                                                 }
                                         }
                                 }
-                                UDF_SB_PARTFUNC(sb,i) = udf_get_pblock_spar15;
+                                map->s_partition_func = udf_get_pblock_spar15;
                         } else {
-                                udf_debug("Unknown ident: %s\n", upm2->partIdent.ident);
+                                udf_debug("Unknown ident: %s\n",
+                                          upm2->partIdent.ident);
                                 continue;
                         }
-                        UDF_SB_PARTVSN(sb,i) = le16_to_cpu(upm2->volSeqNum);
-                        UDF_SB_PARTNUM(sb,i) = le16_to_cpu(upm2->partitionNum);
+                        map->s_volumeseqnum = le16_to_cpu(upm2->volSeqNum);
+                        map->s_partition_num = le16_to_cpu(upm2->partitionNum);
                 }
                 udf_debug("Partition (%d:%d) type %d on volume %d\n",
-                          i, UDF_SB_PARTNUM(sb,i), type, UDF_SB_PARTVSN(sb,i));
+                          i, map->s_partition_num, type,
+                          map->s_volumeseqnum);
         }
 
         if (fileset) {
                 long_ad *la = (long_ad *)&(lvd->logicalVolContentsUse[0]);
 
                 *fileset = lelb_to_cpu(la->extLocation);
-                udf_debug("FileSet found in LogicalVolDesc at block=%d, partition=%d\n",
-                          fileset->logicalBlockNum,
+                udf_debug("FileSet found in LogicalVolDesc at block=%d, "
+                          "partition=%d\n", fileset->logicalBlockNum,
                           fileset->partitionReferenceNum);
         }
         if (lvd->integritySeqExt.extLength)
@@ -1063,22 +1307,26 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
 {
         struct buffer_head *bh = NULL;
         uint16_t ident;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct logicalVolIntegrityDesc *lvid;
 
         while (loc.extLength > 0 &&
                (bh = udf_read_tagged(sb, loc.extLocation,
                                      loc.extLocation, &ident)) &&
                ident == TAG_IDENT_LVID) {
-                UDF_SB_LVIDBH(sb) = bh;
+                sbi->s_lvid_bh = bh;
+                lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
 
-                if (UDF_SB_LVID(sb)->nextIntegrityExt.extLength)
-                        udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
+                if (lvid->nextIntegrityExt.extLength)
+                        udf_load_logicalvolint(sb,
+                                leea_to_cpu(lvid->nextIntegrityExt));
 
-                if (UDF_SB_LVIDBH(sb) != bh)
+                if (sbi->s_lvid_bh != bh)
                         brelse(bh);
                 loc.extLength -= sb->s_blocksize;
                 loc.extLocation++;
         }
-        if (UDF_SB_LVIDBH(sb) != bh)
+        if (sbi->s_lvid_bh != bh)
                 brelse(bh);
 }
 
@@ -1097,11 +1345,12 @@ static void udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
  *      July 1, 1997 - Andrew E. Mileski
  *      Written, tested, and released.
  */
-static int udf_process_sequence(struct super_block *sb, long block, long lastblock,
-                                 kernel_lb_addr *fileset)
+static int udf_process_sequence(struct super_block *sb, long block,
+                                long lastblock, kernel_lb_addr *fileset)
 {
         struct buffer_head *bh = NULL;
         struct udf_vds_record vds[VDS_POS_LENGTH];
+        struct udf_vds_record *curr;
         struct generic_desc *gd;
         struct volDescPtr *vdp;
         int done = 0;
@@ -1124,43 +1373,51 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblo
                 vdsn = le32_to_cpu(gd->volDescSeqNum);
                 switch (ident) {
                 case TAG_IDENT_PVD: /* ISO 13346 3/10.1 */
-                        if (vdsn >= vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum) {
-                                vds[VDS_POS_PRIMARY_VOL_DESC].volDescSeqNum = vdsn;
-                                vds[VDS_POS_PRIMARY_VOL_DESC].block = block;
+                        curr = &vds[VDS_POS_PRIMARY_VOL_DESC];
+                        if (vdsn >= curr->volDescSeqNum) {
+                                curr->volDescSeqNum = vdsn;
+                                curr->block = block;
                         }
                         break;
                 case TAG_IDENT_VDP: /* ISO 13346 3/10.3 */
-                        if (vdsn >= vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum) {
-                                vds[VDS_POS_VOL_DESC_PTR].volDescSeqNum = vdsn;
-                                vds[VDS_POS_VOL_DESC_PTR].block = block;
+                        curr = &vds[VDS_POS_VOL_DESC_PTR];
+                        if (vdsn >= curr->volDescSeqNum) {
+                                curr->volDescSeqNum = vdsn;
+                                curr->block = block;
 
                                 vdp = (struct volDescPtr *)bh->b_data;
-                                next_s = le32_to_cpu(vdp->nextVolDescSeqExt.extLocation);
-                                next_e = le32_to_cpu(vdp->nextVolDescSeqExt.extLength);
+                                next_s = le32_to_cpu(
+                                        vdp->nextVolDescSeqExt.extLocation);
+                                next_e = le32_to_cpu(
+                                        vdp->nextVolDescSeqExt.extLength);
                                 next_e = next_e >> sb->s_blocksize_bits;
                                 next_e += next_s;
                         }
                         break;
                 case TAG_IDENT_IUVD: /* ISO 13346 3/10.4 */
-                        if (vdsn >= vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum) {
-                                vds[VDS_POS_IMP_USE_VOL_DESC].volDescSeqNum = vdsn;
-                                vds[VDS_POS_IMP_USE_VOL_DESC].block = block;
+                        curr = &vds[VDS_POS_IMP_USE_VOL_DESC];
+                        if (vdsn >= curr->volDescSeqNum) {
+                                curr->volDescSeqNum = vdsn;
+                                curr->block = block;
                         }
                         break;
                 case TAG_IDENT_PD: /* ISO 13346 3/10.5 */
-                        if (!vds[VDS_POS_PARTITION_DESC].block)
-                                vds[VDS_POS_PARTITION_DESC].block = block;
+                        curr = &vds[VDS_POS_PARTITION_DESC];
+                        if (!curr->block)
+                                curr->block = block;
                         break;
                 case TAG_IDENT_LVD: /* ISO 13346 3/10.6 */
-                        if (vdsn >= vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum) {
-                                vds[VDS_POS_LOGICAL_VOL_DESC].volDescSeqNum = vdsn;
-                                vds[VDS_POS_LOGICAL_VOL_DESC].block = block;
+                        curr = &vds[VDS_POS_LOGICAL_VOL_DESC];
+                        if (vdsn >= curr->volDescSeqNum) {
+                                curr->volDescSeqNum = vdsn;
+                                curr->block = block;
                         }
                         break;
                 case TAG_IDENT_USD: /* ISO 13346 3/10.8 */
-                        if (vdsn >= vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum) {
-                                vds[VDS_POS_UNALLOC_SPACE_DESC].volDescSeqNum = vdsn;
-                                vds[VDS_POS_UNALLOC_SPACE_DESC].block = block;
+                        curr = &vds[VDS_POS_UNALLOC_SPACE_DESC];
+                        if (vdsn >= curr->volDescSeqNum) {
+                                curr->volDescSeqNum = vdsn;
+                                curr->block = block;
                         }
                         break;
                 case TAG_IDENT_TD: /* ISO 13346 3/10.9 */
@@ -1169,32 +1426,38 @@ static int udf_process_sequence(struct super_block *sb, long block, long lastblo
                                 block = next_s;
                                 lastblock = next_e;
                                 next_s = next_e = 0;
-                        } else {
+                        } else
                                 done = 1;
-                        }
                         break;
                 }
                 brelse(bh);
         }
         for (i = 0; i < VDS_POS_LENGTH; i++) {
                 if (vds[i].block) {
-                        bh = udf_read_tagged(sb, vds[i].block, vds[i].block, &ident);
+                        bh = udf_read_tagged(sb, vds[i].block, vds[i].block,
+                                             &ident);
 
                         if (i == VDS_POS_PRIMARY_VOL_DESC) {
                                 udf_load_pvoldesc(sb, bh);
                         } else if (i == VDS_POS_LOGICAL_VOL_DESC) {
-                                udf_load_logicalvol(sb, bh, fileset);
+                                if (udf_load_logicalvol(sb, bh, fileset)) {
+                                        brelse(bh);
+                                        return 1;
+                                }
                         } else if (i == VDS_POS_PARTITION_DESC) {
                                 struct buffer_head *bh2 = NULL;
                                 if (udf_load_partdesc(sb, bh)) {
                                         brelse(bh);
                                         return 1;
                                 }
-                                for (j = vds[i].block + 1; j <  vds[VDS_POS_TERMINATING_DESC].block; j++) {
+                                for (j = vds[i].block + 1;
+                                     j <  vds[VDS_POS_TERMINATING_DESC].block;
+                                     j++) {
                                         bh2 = udf_read_tagged(sb, j, j, &ident);
                                         gd = (struct generic_desc *)bh2->b_data;
                                         if (ident == TAG_IDENT_PD)
-                                                if (udf_load_partdesc(sb, bh2)) {
+                                                if (udf_load_partdesc(sb,
+                                                                      bh2)) {
                                                         brelse(bh);
                                                         brelse(bh2);
                                                         return 1;
@@ -1222,14 +1485,17 @@ static int udf_check_valid(struct super_block *sb, int novrs, int silent)
         }
         /* Check that it is NSR02 compliant */
         /* Process any "CD-ROM Volume Descriptor Set" (ECMA 167 2/8.3.1) */
-        else if ((block = udf_vrs(sb, silent)) == -1) {
-                udf_debug("Failed to read byte 32768. Assuming open disc. "
-                          "Skipping validity check\n");
-                if (!UDF_SB_LASTBLOCK(sb))
-                        UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
-                return 0;
-        } else {
-                return !block;
+        else {
+                block = udf_vrs(sb, silent);
+                if (block == -1) {
+                        struct udf_sb_info *sbi = UDF_SB(sb);
+                        udf_debug("Failed to read byte 32768. Assuming open "
+                                  "disc. Skipping validity check\n");
+                        if (!sbi->s_last_block)
+                                sbi->s_last_block = udf_get_last_block(sb);
+                        return 0;
+                } else
+                        return !block;
         }
 }
 
@@ -1240,100 +1506,121 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
         struct buffer_head *bh;
         long main_s, main_e, reserve_s, reserve_e;
         int i, j;
+        struct udf_sb_info *sbi;
 
         if (!sb)
                 return 1;
+        sbi = UDF_SB(sb);
 
-        for (i = 0; i < ARRAY_SIZE(UDF_SB_ANCHOR(sb)); i++) {
-                if (UDF_SB_ANCHOR(sb)[i] &&
-                    (bh = udf_read_tagged(sb, UDF_SB_ANCHOR(sb)[i],
-                                          UDF_SB_ANCHOR(sb)[i], &ident))) {
-                        anchor = (struct anchorVolDescPtr *)bh->b_data;
+        for (i = 0; i < ARRAY_SIZE(sbi->s_anchor); i++) {
+                if (!sbi->s_anchor[i])
+                        continue;
+                bh = udf_read_tagged(sb, sbi->s_anchor[i], sbi->s_anchor[i],
+                                     &ident);
+                if (!bh)
+                        continue;
 
-                        /* Locate the main sequence */
-                        main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
-                        main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength );
-                        main_e = main_e >> sb->s_blocksize_bits;
-                        main_e += main_s;
+                anchor = (struct anchorVolDescPtr *)bh->b_data;
 
-                        /* Locate the reserve sequence */
-                        reserve_s = le32_to_cpu(anchor->reserveVolDescSeqExt.extLocation);
-                        reserve_e = le32_to_cpu(anchor->reserveVolDescSeqExt.extLength);
-                        reserve_e = reserve_e >> sb->s_blocksize_bits;
-                        reserve_e += reserve_s;
+                /* Locate the main sequence */
+                main_s = le32_to_cpu(anchor->mainVolDescSeqExt.extLocation);
+                main_e = le32_to_cpu(anchor->mainVolDescSeqExt.extLength);
+                main_e = main_e >> sb->s_blocksize_bits;
+                main_e += main_s;
 
-                        brelse(bh);
+                /* Locate the reserve sequence */
+                reserve_s = le32_to_cpu(
+                                anchor->reserveVolDescSeqExt.extLocation);
+                reserve_e = le32_to_cpu(
+                                anchor->reserveVolDescSeqExt.extLength);
+                reserve_e = reserve_e >> sb->s_blocksize_bits;
+                reserve_e += reserve_s;
 
-                        /* Process the main & reserve sequences */
-                        /* responsible for finding the PartitionDesc(s) */
-                        if (!(udf_process_sequence(sb, main_s, main_e, fileset) &&
-                              udf_process_sequence(sb, reserve_s, reserve_e, fileset))) {
-                                break;
-                        }
-                }
+                brelse(bh);
+
+                /* Process the main & reserve sequences */
+                /* responsible for finding the PartitionDesc(s) */
+                if (!(udf_process_sequence(sb, main_s, main_e,
+                                           fileset) &&
+                      udf_process_sequence(sb, reserve_s, reserve_e,
+                                           fileset)))
+                        break;
         }
 
-        if (i == ARRAY_SIZE(UDF_SB_ANCHOR(sb))) {
+        if (i == ARRAY_SIZE(sbi->s_anchor)) {
                 udf_debug("No Anchor block found\n");
                 return 1;
-        } else
-                udf_debug("Using anchor in block %d\n", UDF_SB_ANCHOR(sb)[i]);
+        }
+        udf_debug("Using anchor in block %d\n", sbi->s_anchor[i]);
 
-        for (i = 0; i < UDF_SB_NUMPARTS(sb); i++) {
+        for (i = 0; i < sbi->s_partitions; i++) {
                 kernel_lb_addr uninitialized_var(ino);
-                switch (UDF_SB_PARTTYPE(sb, i)) {
+                struct udf_part_map *map = &sbi->s_partmaps[i];
+                switch (map->s_partition_type) {
                 case UDF_VIRTUAL_MAP15:
                 case UDF_VIRTUAL_MAP20:
-                        if (!UDF_SB_LASTBLOCK(sb)) {
-                                UDF_SB_LASTBLOCK(sb) = udf_get_last_block(sb);
+                        if (!sbi->s_last_block) {
+                                sbi->s_last_block = udf_get_last_block(sb);
                                 udf_find_anchor(sb);
                         }
 
-                        if (!UDF_SB_LASTBLOCK(sb)) {
+                        if (!sbi->s_last_block) {
                                 udf_debug("Unable to determine Lastblock (For "
                                           "Virtual Partition)\n");
                                 return 1;
                         }
 
-                        for (j = 0; j < UDF_SB_NUMPARTS(sb); j++) {
+                        for (j = 0; j < sbi->s_partitions; j++) {
+                                struct udf_part_map *map2 = &sbi->s_partmaps[j];
                                 if (j != i &&
-                                    UDF_SB_PARTVSN(sb, i) == UDF_SB_PARTVSN(sb, j) &&
-                                    UDF_SB_PARTNUM(sb, i) == UDF_SB_PARTNUM(sb, j)) {
+                                    map->s_volumeseqnum ==
+                                                map2->s_volumeseqnum &&
+                                    map->s_partition_num ==
+                                                map2->s_partition_num) {
                                         ino.partitionReferenceNum = j;
-                                        ino.logicalBlockNum = UDF_SB_LASTBLOCK(sb) - UDF_SB_PARTROOT(sb, j);
+                                        ino.logicalBlockNum =
+                                                sbi->s_last_block -
+                                                        map2->s_partition_root;
                                         break;
                                 }
                         }
 
-                        if (j == UDF_SB_NUMPARTS(sb))
+                        if (j == sbi->s_partitions)
                                 return 1;
 
-                        if (!(UDF_SB_VAT(sb) = udf_iget(sb, ino)))
+                        sbi->s_vat_inode = udf_iget(sb, ino);
+                        if (!sbi->s_vat_inode)
                                 return 1;
 
-                        if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP15) {
-                                UDF_SB_TYPEVIRT(sb, i).s_start_offset =
-                                        udf_ext0_offset(UDF_SB_VAT(sb));
-                                UDF_SB_TYPEVIRT(sb, i).s_num_entries =
-                                        (UDF_SB_VAT(sb)->i_size - 36) >> 2;
-                        } else if (UDF_SB_PARTTYPE(sb, i) == UDF_VIRTUAL_MAP20) {
-                                struct buffer_head *bh = NULL;
+                        if (map->s_partition_type == UDF_VIRTUAL_MAP15) {
+                                map->s_type_specific.s_virtual.s_start_offset =
+                                        udf_ext0_offset(sbi->s_vat_inode);
+                                map->s_type_specific.s_virtual.s_num_entries =
+                                        (sbi->s_vat_inode->i_size - 36) >> 2;
+                        } else if (map->s_partition_type == UDF_VIRTUAL_MAP20) {
                                 uint32_t pos;
+                                struct virtualAllocationTable20 *vat20;
 
-                                pos = udf_block_map(UDF_SB_VAT(sb), 0);
+                                pos = udf_block_map(sbi->s_vat_inode, 0);
                                 bh = sb_bread(sb, pos);
                                 if (!bh)
                                         return 1;
-                                UDF_SB_TYPEVIRT(sb, i).s_start_offset =
-                                        le16_to_cpu(((struct virtualAllocationTable20 *)bh->b_data +
-                                                     udf_ext0_offset(UDF_SB_VAT(sb)))->lengthHeader) +
-                                        udf_ext0_offset(UDF_SB_VAT(sb));
-                                UDF_SB_TYPEVIRT(sb, i).s_num_entries = (UDF_SB_VAT(sb)->i_size -
-                                                                        UDF_SB_TYPEVIRT(sb, i).s_start_offset) >> 2;
+                                vat20 = (struct virtualAllocationTable20 *)
+                                        bh->b_data +
+                                        udf_ext0_offset(sbi->s_vat_inode);
+                                map->s_type_specific.s_virtual.s_start_offset =
+                                        le16_to_cpu(vat20->lengthHeader) +
+                                        udf_ext0_offset(sbi->s_vat_inode);
+                                map->s_type_specific.s_virtual.s_num_entries =
+                                        (sbi->s_vat_inode->i_size -
+                                         map->s_type_specific.s_virtual.
+                                                        s_start_offset) >> 2;
                                 brelse(bh);
                         }
-                        UDF_SB_PARTROOT(sb, i) = udf_get_pblock(sb, 0, i, 0);
-                        UDF_SB_PARTLEN(sb, i) = UDF_SB_PARTLEN(sb, ino.partitionReferenceNum);
+                        map->s_partition_root = udf_get_pblock(sb, 0, i, 0);
+                        map->s_partition_len =
+                                sbi->s_partmaps[ino.partitionReferenceNum].
+                                                                s_partition_len;
                 }
         }
         return 0;
@@ -1341,62 +1628,86 @@ static int udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
 
 static void udf_open_lvid(struct super_block *sb)
 {
-        if (UDF_SB_LVIDBH(sb)) {
-                int i;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct buffer_head *bh = sbi->s_lvid_bh;
+        if (bh) {
                 kernel_timestamp cpu_time;
+                struct logicalVolIntegrityDesc *lvid =
+                                (struct logicalVolIntegrityDesc *)bh->b_data;
+                struct logicalVolIntegrityDescImpUse *lvidiu =
+                                                        udf_sb_lvidiu(sbi);
 
-                UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
-                UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
+                lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
+                lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
                 if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
-                        UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
-                UDF_SB_LVID(sb)->integrityType = LVID_INTEGRITY_TYPE_OPEN;
-
-                UDF_SB_LVID(sb)->descTag.descCRC = cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
-                                                                       le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
+                        lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
+                lvid->integrityType = LVID_INTEGRITY_TYPE_OPEN;
 
-                UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
-                for (i = 0; i < 16; i++)
-                        if (i != 4)
-                                UDF_SB_LVID(sb)->descTag.tagChecksum +=
-                                        ((uint8_t *) &(UDF_SB_LVID(sb)->descTag))[i];
+                lvid->descTag.descCRC = cpu_to_le16(
+                        udf_crc((char *)lvid + sizeof(tag),
+                                le16_to_cpu(lvid->descTag.descCRCLength),
+                                0));
 
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
+                lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
+                mark_buffer_dirty(bh);
         }
 }
 
 static void udf_close_lvid(struct super_block *sb)
 {
         kernel_timestamp cpu_time;
-        int i;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct buffer_head *bh = sbi->s_lvid_bh;
+        struct logicalVolIntegrityDesc *lvid;
+
+        if (!bh)
+                return;
+
+        lvid = (struct logicalVolIntegrityDesc *)bh->b_data;
 
-        if (UDF_SB_LVIDBH(sb) &&
-            UDF_SB_LVID(sb)->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
-                UDF_SB_LVIDIU(sb)->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
-                UDF_SB_LVIDIU(sb)->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
+        if (lvid->integrityType == LVID_INTEGRITY_TYPE_OPEN) {
+                struct logicalVolIntegrityDescImpUse *lvidiu =
+                                                        udf_sb_lvidiu(sbi);
+                lvidiu->impIdent.identSuffix[0] = UDF_OS_CLASS_UNIX;
+                lvidiu->impIdent.identSuffix[1] = UDF_OS_ID_LINUX;
                 if (udf_time_to_stamp(&cpu_time, CURRENT_TIME))
-                        UDF_SB_LVID(sb)->recordingDateAndTime = cpu_to_lets(cpu_time);
-                if (UDF_MAX_WRITE_VERSION > le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev))
-                        UDF_SB_LVIDIU(sb)->maxUDFWriteRev = cpu_to_le16(UDF_MAX_WRITE_VERSION);
-                if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev))
-                        UDF_SB_LVIDIU(sb)->minUDFReadRev = cpu_to_le16(UDF_SB_UDFREV(sb));
-                if (UDF_SB_UDFREV(sb) > le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev))
-                        UDF_SB_LVIDIU(sb)->minUDFWriteRev = cpu_to_le16(UDF_SB_UDFREV(sb));
-                UDF_SB_LVID(sb)->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
-
-                UDF_SB_LVID(sb)->descTag.descCRC =
-                        cpu_to_le16(udf_crc((char *)UDF_SB_LVID(sb) + sizeof(tag),
-                                            le16_to_cpu(UDF_SB_LVID(sb)->descTag.descCRCLength), 0));
-
-                UDF_SB_LVID(sb)->descTag.tagChecksum = 0;
-                for (i = 0; i < 16; i++)
-                        if (i != 4)
-                                UDF_SB_LVID(sb)->descTag.tagChecksum +=
-                                        ((uint8_t *)&(UDF_SB_LVID(sb)->descTag))[i];
-
-                mark_buffer_dirty(UDF_SB_LVIDBH(sb));
+                        lvid->recordingDateAndTime = cpu_to_lets(cpu_time);
+                if (UDF_MAX_WRITE_VERSION > le16_to_cpu(lvidiu->maxUDFWriteRev))
+                        lvidiu->maxUDFWriteRev =
+                                        cpu_to_le16(UDF_MAX_WRITE_VERSION);
+                if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFReadRev))
+                        lvidiu->minUDFReadRev = cpu_to_le16(sbi->s_udfrev);
+                if (sbi->s_udfrev > le16_to_cpu(lvidiu->minUDFWriteRev))
+                        lvidiu->minUDFWriteRev = cpu_to_le16(sbi->s_udfrev);
+                lvid->integrityType = cpu_to_le32(LVID_INTEGRITY_TYPE_CLOSE);
+
+                lvid->descTag.descCRC = cpu_to_le16(
+                        udf_crc((char *)lvid + sizeof(tag),
+                                le16_to_cpu(lvid->descTag.descCRCLength),
+                                0));
+
+                lvid->descTag.tagChecksum = udf_tag_checksum(&lvid->descTag);
+                mark_buffer_dirty(bh);
         }
 }
 
+static void udf_sb_free_bitmap(struct udf_bitmap *bitmap)
+{
+        int i;
+        int nr_groups = bitmap->s_nr_groups;
+        int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) *
+                                                nr_groups);
+
+        for (i = 0; i < nr_groups; i++)
+                if (bitmap->s_block_bitmap[i])
+                        brelse(bitmap->s_block_bitmap[i]);
+
+        if (size <= PAGE_SIZE)
+                kfree(bitmap);
+        else
+                vfree(bitmap);
+}
+
 /*
  * udf_read_super
  *
@@ -1426,16 +1737,15 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         uopt.gid = -1;
         uopt.umask = 0;
 
-        sbi = kmalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
+        sbi = kzalloc(sizeof(struct udf_sb_info), GFP_KERNEL);
         if (!sbi)
                 return -ENOMEM;
 
         sb->s_fs_info = sbi;
-        memset(UDF_SB(sb), 0x00, sizeof(struct udf_sb_info));
 
         mutex_init(&sbi->s_alloc_mutex);
 
-        if (!udf_parse_options((char *)options, &uopt))
+        if (!udf_parse_options((char *)options, &uopt, false))
                 goto error_out;
 
         if (uopt.flags & (1 << UDF_FLAG_UTF8) &&
@@ -1459,30 +1769,31 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         fileset.logicalBlockNum = 0xFFFFFFFF;
         fileset.partitionReferenceNum = 0xFFFF;
 
-        UDF_SB(sb)->s_flags = uopt.flags;
-        UDF_SB(sb)->s_uid = uopt.uid;
-        UDF_SB(sb)->s_gid = uopt.gid;
-        UDF_SB(sb)->s_umask = uopt.umask;
-        UDF_SB(sb)->s_nls_map = uopt.nls_map;
+        sbi->s_flags = uopt.flags;
+        sbi->s_uid = uopt.uid;
+        sbi->s_gid = uopt.gid;
+        sbi->s_umask = uopt.umask;
+        sbi->s_nls_map = uopt.nls_map;
 
         /* Set the block size for all transfers */
         if (!udf_set_blocksize(sb, uopt.blocksize))
                 goto error_out;
 
         if (uopt.session == 0xFFFFFFFF)
-                UDF_SB_SESSION(sb) = udf_get_last_session(sb);
+                sbi->s_session = udf_get_last_session(sb);
         else
-                UDF_SB_SESSION(sb) = uopt.session;
+                sbi->s_session = uopt.session;
 
-        udf_debug("Multi-session=%d\n", UDF_SB_SESSION(sb));
+        udf_debug("Multi-session=%d\n", sbi->s_session);
 
-        UDF_SB_LASTBLOCK(sb) = uopt.lastblock;
-        UDF_SB_ANCHOR(sb)[0] = UDF_SB_ANCHOR(sb)[1] = 0;
-        UDF_SB_ANCHOR(sb)[2] = uopt.anchor;
-        UDF_SB_ANCHOR(sb)[3] = 256;
+        sbi->s_last_block = uopt.lastblock;
+        sbi->s_anchor[0] = sbi->s_anchor[1] = 0;
+        sbi->s_anchor[2] = uopt.anchor;
+        sbi->s_anchor[3] = 256;
 
-        if (udf_check_valid(sb, uopt.novrs, silent)) { /* read volume recognition sequences */
-                printk("UDF-fs: No VRS found\n");
+        if (udf_check_valid(sb, uopt.novrs, silent)) {
+                /* read volume recognition sequences */
+                printk(KERN_WARNING "UDF-fs: No VRS found\n");
                 goto error_out;
         }
 
@@ -1496,27 +1807,30 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         sb->s_time_gran = 1000;
 
         if (udf_load_partition(sb, &fileset)) {
-                printk("UDF-fs: No partition found (1)\n");
+                printk(KERN_WARNING "UDF-fs: No partition found (1)\n");
                 goto error_out;
         }
 
-        udf_debug("Lastblock=%d\n", UDF_SB_LASTBLOCK(sb));
+        udf_debug("Lastblock=%d\n", sbi->s_last_block);
 
-        if (UDF_SB_LVIDBH(sb)) {
-                uint16_t minUDFReadRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev);
-                uint16_t minUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFWriteRev);
-                /* uint16_t maxUDFWriteRev = le16_to_cpu(UDF_SB_LVIDIU(sb)->maxUDFWriteRev); */
+        if (sbi->s_lvid_bh) {
+                struct logicalVolIntegrityDescImpUse *lvidiu =
+                                                        udf_sb_lvidiu(sbi);
+                uint16_t minUDFReadRev = le16_to_cpu(lvidiu->minUDFReadRev);
+                uint16_t minUDFWriteRev = le16_to_cpu(lvidiu->minUDFWriteRev);
+                /* uint16_t maxUDFWriteRev =
+                                le16_to_cpu(lvidiu->maxUDFWriteRev); */
 
                 if (minUDFReadRev > UDF_MAX_READ_VERSION) {
-                        printk("UDF-fs: minUDFReadRev=%x (max is %x)\n",
-                               le16_to_cpu(UDF_SB_LVIDIU(sb)->minUDFReadRev),
+                        printk(KERN_ERR "UDF-fs: minUDFReadRev=%x "
+                                        "(max is %x)\n",
+                               le16_to_cpu(lvidiu->minUDFReadRev),
                                UDF_MAX_READ_VERSION);
                         goto error_out;
-                } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION) {
+                } else if (minUDFWriteRev > UDF_MAX_WRITE_VERSION)
                         sb->s_flags |= MS_RDONLY;
-                }
 
-                UDF_SB_UDFREV(sb) = minUDFWriteRev;
+                sbi->s_udfrev = minUDFWriteRev;
 
                 if (minUDFReadRev >= UDF_VERS_USE_EXTENDED_FE)
                         UDF_SET_FLAG(sb, UDF_FLAG_USE_EXTENDED_FE);
@@ -1524,29 +1838,30 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                         UDF_SET_FLAG(sb, UDF_FLAG_USE_STREAMS);
         }
 
-        if (!UDF_SB_NUMPARTS(sb)) {
-                printk("UDF-fs: No partition found (2)\n");
+        if (!sbi->s_partitions) {
+                printk(KERN_WARNING "UDF-fs: No partition found (2)\n");
                 goto error_out;
         }
 
-        if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_READ_ONLY) {
-                printk("UDF-fs: Partition marked readonly; forcing readonly mount\n");
+        if (sbi->s_partmaps[sbi->s_partition].s_partition_flags &
+                        UDF_PART_FLAG_READ_ONLY) {
+                printk(KERN_NOTICE "UDF-fs: Partition marked readonly; "
+                                   "forcing readonly mount\n");
                 sb->s_flags |= MS_RDONLY;
         }
 
         if (udf_find_fileset(sb, &fileset, &rootdir)) {
-                printk("UDF-fs: No fileset found\n");
+                printk(KERN_WARNING "UDF-fs: No fileset found\n");
                 goto error_out;
         }
 
         if (!silent) {
                 kernel_timestamp ts;
-                udf_time_to_stamp(&ts, UDF_SB_RECORDTIME(sb));
-                udf_info("UDF %s (%s) Mounting volume '%s', "
+                udf_time_to_stamp(&ts, sbi->s_record_time);
+                udf_info("UDF: Mounting volume '%s', "
                          "timestamp %04u/%02u/%02u %02u:%02u (%x)\n",
-                         UDFFS_VERSION, UDFFS_DATE,
-                         UDF_SB_VOLIDENT(sb), ts.year, ts.month, ts.day, ts.hour, ts.minute,
-                         ts.typeAndTimezone);
+                         sbi->s_volume_ident, ts.year, ts.month, ts.day,
+                         ts.hour, ts.minute, ts.typeAndTimezone);
         }
         if (!(sb->s_flags & MS_RDONLY))
                 udf_open_lvid(sb);
@@ -1556,7 +1871,8 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         /* perhaps it's not extensible enough, but for now ... */
         inode = udf_iget(sb, rootdir);
         if (!inode) {
-                printk("UDF-fs: Error in udf_iget, block=%d, partition=%d\n",
+                printk(KERN_ERR "UDF-fs: Error in udf_iget, block=%d, "
+                                "partition=%d\n",
                        rootdir.logicalBlockNum, rootdir.partitionReferenceNum);
                 goto error_out;
         }
@@ -1564,7 +1880,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         /* Allocate a dentry for the root inode */
         sb->s_root = d_alloc_root(inode);
         if (!sb->s_root) {
-                printk("UDF-fs: Couldn't allocate root dentry\n");
+                printk(KERN_ERR "UDF-fs: Couldn't allocate root dentry\n");
                 iput(inode);
                 goto error_out;
         }
@@ -1572,30 +1888,32 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
         return 0;
 
 error_out:
-        if (UDF_SB_VAT(sb))
-                iput(UDF_SB_VAT(sb));
-        if (UDF_SB_NUMPARTS(sb)) {
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_uspace);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_fspace);
-                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
+        if (sbi->s_vat_inode)
+                iput(sbi->s_vat_inode);
+        if (sbi->s_partitions) {
+                struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
+                if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
+                        iput(map->s_uspace.s_table);
+                if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
+                        iput(map->s_fspace.s_table);
+                if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
+                        udf_sb_free_bitmap(map->s_uspace.s_bitmap);
+                if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
+                        udf_sb_free_bitmap(map->s_fspace.s_bitmap);
+                if (map->s_partition_type == UDF_SPARABLE_MAP15)
                         for (i = 0; i < 4; i++)
-                                brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
-                }
+                                brelse(map->s_type_specific.s_sparing.
+                                                s_spar_map[i]);
         }
 #ifdef CONFIG_UDF_NLS
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
-                unload_nls(UDF_SB(sb)->s_nls_map);
+                unload_nls(sbi->s_nls_map);
 #endif
         if (!(sb->s_flags & MS_RDONLY))
                 udf_close_lvid(sb);
-        brelse(UDF_SB_LVIDBH(sb));
-        UDF_SB_FREE(sb);
+        brelse(sbi->s_lvid_bh);
+
+        kfree(sbi->s_partmaps);
         kfree(sbi);
         sb->s_fs_info = NULL;
 
@@ -1614,7 +1932,7 @@ void udf_error(struct super_block *sb, const char *function,
         va_start(args, fmt);
         vsnprintf(error_buf, sizeof(error_buf), fmt, args);
         va_end(args);
-        printk (KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
+        printk(KERN_CRIT "UDF-fs error (device %s): %s: %s\n",
                 sb->s_id, function, error_buf);
 }
 
@@ -1646,31 +1964,34 @@ void udf_warning(struct super_block *sb, const char *function,
 static void udf_put_super(struct super_block *sb)
 {
         int i;
+        struct udf_sb_info *sbi;
 
-        if (UDF_SB_VAT(sb))
-                iput(UDF_SB_VAT(sb));
-        if (UDF_SB_NUMPARTS(sb)) {
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE)
-                        iput(UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_uspace);
-                if (UDF_SB_PARTFLAGS(sb, UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP)
-                        UDF_SB_FREE_BITMAP(sb,UDF_SB_PARTITION(sb), s_fspace);
-                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15) {
+        sbi = UDF_SB(sb);
+        if (sbi->s_vat_inode)
+                iput(sbi->s_vat_inode);
+        if (sbi->s_partitions) {
+                struct udf_part_map *map = &sbi->s_partmaps[sbi->s_partition];
+                if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE)
+                        iput(map->s_uspace.s_table);
+                if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE)
+                        iput(map->s_fspace.s_table);
+                if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP)
+                        udf_sb_free_bitmap(map->s_uspace.s_bitmap);
+                if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP)
+                        udf_sb_free_bitmap(map->s_fspace.s_bitmap);
+                if (map->s_partition_type == UDF_SPARABLE_MAP15)
                         for (i = 0; i < 4; i++)
-                                brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
-                }
+                                brelse(map->s_type_specific.s_sparing.
+                                                s_spar_map[i]);
         }
 #ifdef CONFIG_UDF_NLS
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP))
-                unload_nls(UDF_SB(sb)->s_nls_map);
+                unload_nls(sbi->s_nls_map);
 #endif
         if (!(sb->s_flags & MS_RDONLY))
                 udf_close_lvid(sb);
-        brelse(UDF_SB_LVIDBH(sb));
-        UDF_SB_FREE(sb);
+        brelse(sbi->s_lvid_bh);
+        kfree(sbi->s_partmaps);
         kfree(sb->s_fs_info);
         sb->s_fs_info = NULL;
 }
@@ -1691,15 +2012,22 @@ static void udf_put_super(struct super_block *sb)
 static int udf_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
         struct super_block *sb = dentry->d_sb;
+        struct udf_sb_info *sbi = UDF_SB(sb);
+        struct logicalVolIntegrityDescImpUse *lvidiu;
+
+        if (sbi->s_lvid_bh != NULL)
+                lvidiu = udf_sb_lvidiu(sbi);
+        else
+                lvidiu = NULL;
 
         buf->f_type = UDF_SUPER_MAGIC;
         buf->f_bsize = sb->s_blocksize;
-        buf->f_blocks = UDF_SB_PARTLEN(sb, UDF_SB_PARTITION(sb));
+        buf->f_blocks = sbi->s_partmaps[sbi->s_partition].s_partition_len;
         buf->f_bfree = udf_count_free(sb);
         buf->f_bavail = buf->f_bfree;
-        buf->f_files = (UDF_SB_LVIDBH(sb) ?
-                        (le32_to_cpu(UDF_SB_LVIDIU(sb)->numFiles) +
-                         le32_to_cpu(UDF_SB_LVIDIU(sb)->numDirs)) : 0) + buf->f_bfree;
+        buf->f_files = (lvidiu != NULL ? (le32_to_cpu(lvidiu->numFiles) +
+                                          le32_to_cpu(lvidiu->numDirs)) : 0)
+                        + buf->f_bfree;
         buf->f_ffree = buf->f_bfree;
         /* __kernel_fsid_t f_fsid */
         buf->f_namelen = UDF_NAME_LEN - 2;
@@ -1711,7 +2039,8 @@ static unsigned char udf_bitmap_lookup[16] = {
         0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
 };
 
-static unsigned int udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
+static unsigned int udf_count_free_bitmap(struct super_block *sb,
+                                          struct udf_bitmap *bitmap)
 {
         struct buffer_head *bh = NULL;
         unsigned int accum = 0;
@@ -1727,7 +2056,7 @@ static unsigned int udf_count_free_bitmap(struct super_block *sb, struct udf_bit
         lock_kernel();
 
         loc.logicalBlockNum = bitmap->s_extPosition;
-        loc.partitionReferenceNum = UDF_SB_PARTITION(sb);
+        loc.partitionReferenceNum = UDF_SB(sb)->s_partition;
         bh = udf_read_ptagged(sb, loc, 0, &ident);
 
         if (!bh) {
@@ -1772,7 +2101,8 @@ out:
         return accum;
 }
 
-static unsigned int udf_count_free_table(struct super_block *sb, struct inode *table)
+static unsigned int udf_count_free_table(struct super_block *sb,
+                                         struct inode *table)
 {
         unsigned int accum = 0;
         uint32_t elen;
@@ -1782,13 +2112,13 @@ static unsigned int udf_count_free_table(struct super_block *sb, struct inode *t
 
         lock_kernel();
 
-        epos.block = UDF_I_LOCATION(table);
+        epos.block = UDF_I(table)->i_location;
         epos.offset = sizeof(struct unallocSpaceEntry);
         epos.bh = NULL;
 
-        while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1) {
+        while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
                 accum += (elen >> table->i_sb->s_blocksize_bits);
-        }
+
         brelse(epos.bh);
 
         unlock_kernel();
@@ -1799,10 +2129,17 @@ static unsigned int udf_count_free_table(struct super_block *sb, struct inode *t
 static unsigned int udf_count_free(struct super_block *sb)
 {
         unsigned int accum = 0;
-
-        if (UDF_SB_LVIDBH(sb)) {
-                if (le32_to_cpu(UDF_SB_LVID(sb)->numOfPartitions) > UDF_SB_PARTITION(sb)) {
-                        accum = le32_to_cpu(UDF_SB_LVID(sb)->freeSpaceTable[UDF_SB_PARTITION(sb)]);
+        struct udf_sb_info *sbi;
+        struct udf_part_map *map;
+
+        sbi = UDF_SB(sb);
+        if (sbi->s_lvid_bh) {
+                struct logicalVolIntegrityDesc *lvid =
+                        (struct logicalVolIntegrityDesc *)
+                        sbi->s_lvid_bh->b_data;
+                if (le32_to_cpu(lvid->numOfPartitions) > sbi->s_partition) {
+                        accum = le32_to_cpu(
+                                        lvid->freeSpaceTable[sbi->s_partition]);
                         if (accum == 0xFFFFFFFF)
                                 accum = 0;
                 }
@@ -1811,24 +2148,25 @@ static unsigned int udf_count_free(struct super_block *sb)
         if (accum)
                 return accum;
 
-        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_BITMAP) {
+        map = &sbi->s_partmaps[sbi->s_partition];
+        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_BITMAP) {
                 accum += udf_count_free_bitmap(sb,
-                                               UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_bitmap);
+                                               map->s_uspace.s_bitmap);
         }
-        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_BITMAP) {
+        if (map->s_partition_flags & UDF_PART_FLAG_FREED_BITMAP) {
                 accum += udf_count_free_bitmap(sb,
-                                               UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_bitmap);
+                                               map->s_fspace.s_bitmap);
         }
         if (accum)
                 return accum;
 
-        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_UNALLOC_TABLE) {
+        if (map->s_partition_flags & UDF_PART_FLAG_UNALLOC_TABLE) {
                 accum += udf_count_free_table(sb,
-                                              UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_uspace.s_table);
+                                              map->s_uspace.s_table);
         }
-        if (UDF_SB_PARTFLAGS(sb,UDF_SB_PARTITION(sb)) & UDF_PART_FLAG_FREED_TABLE) {
+        if (map->s_partition_flags & UDF_PART_FLAG_FREED_TABLE) {
                 accum += udf_count_free_table(sb,
-                                              UDF_SB_PARTMAPS(sb)[UDF_SB_PARTITION(sb)].s_fspace.s_table);
+                                              map->s_fspace.s_table);
         }
 
         return accum;
diff --git a/fs/udf/symlink.c b/fs/udf/symlink.c
index e6f933dd6a7b..6ec99221e50c 100644
--- a/fs/udf/symlink.c
+++ b/fs/udf/symlink.c
@@ -33,7 +33,8 @@
 #include <linux/buffer_head.h>
 #include "udf_i.h"
 
-static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen, char *to)
+static void udf_pc_to_char(struct super_block *sb, char *from, int fromlen,
+                           char *to)
 {
         struct pathComponent *pc;
         int elen = 0;
@@ -78,10 +79,12 @@ static int udf_symlink_filler(struct file *file, struct page *page)
         char *symlink;
         int err = -EIO;
         char *p = kmap(page);
+        struct udf_inode_info *iinfo;
 
         lock_kernel();
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB) {
-                symlink = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
+        iinfo = UDF_I(inode);
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB) {
+                symlink = iinfo->i_ext.i_data + iinfo->i_lenEAttr;
         } else {
                 bh = sb_bread(inode->i_sb, udf_block_map(inode, 0));
 
diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
index 7fc3912885a5..fe61be17cdab 100644
--- a/fs/udf/truncate.c
+++ b/fs/udf/truncate.c
@@ -74,17 +74,18 @@ void udf_truncate_tail_extent(struct inode *inode)
         uint64_t lbcount = 0;
         int8_t etype = -1, netype;
         int adsize;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB ||
-            inode->i_size == UDF_I_LENEXTENTS(inode))
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
+            inode->i_size == iinfo->i_lenExtents)
                 return;
         /* Are we going to delete the file anyway? */
         if (inode->i_nlink == 0)
                 return;
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 BUG();
@@ -117,7 +118,7 @@ void udf_truncate_tail_extent(struct inode *inode)
         }
         /* This inode entry is in-memory only and thus we don't have to mark
          * the inode dirty */
-        UDF_I_LENEXTENTS(inode) = inode->i_size;
+        iinfo->i_lenExtents = inode->i_size;
         brelse(epos.bh);
 }
 
@@ -129,19 +130,20 @@ void udf_discard_prealloc(struct inode *inode)
         uint64_t lbcount = 0;
         int8_t etype = -1, netype;
         int adsize;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB ||
-            inode->i_size == UDF_I_LENEXTENTS(inode))
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ||
+            inode->i_size == iinfo->i_lenExtents)
                 return;
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 adsize = 0;
 
-        epos.block = UDF_I_LOCATION(inode);
+        epos.block = iinfo->i_location;
 
         /* Find the last extent in the file */
         while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1) {
@@ -153,8 +155,9 @@ void udf_discard_prealloc(struct inode *inode)
                 lbcount -= elen;
                 extent_trunc(inode, &epos, eloc, etype, elen, 0);
                 if (!epos.bh) {
-                        UDF_I_LENALLOC(inode) =
-                                epos.offset - udf_file_entry_alloc_offset(inode);
+                        iinfo->i_lenAlloc =
+                                epos.offset -
+                                udf_file_entry_alloc_offset(inode);
                         mark_inode_dirty(inode);
                 } else {
                         struct allocExtDesc *aed =
@@ -163,7 +166,7 @@ void udf_discard_prealloc(struct inode *inode)
                                 cpu_to_le32(epos.offset -
                                             sizeof(struct allocExtDesc));
                         if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) ||
-                            UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                            UDF_SB(inode->i_sb)->s_udfrev >= 0x0201)
                                 udf_update_tag(epos.bh->b_data, epos.offset);
                         else
                                 udf_update_tag(epos.bh->b_data,
@@ -173,7 +176,7 @@ void udf_discard_prealloc(struct inode *inode)
         }
         /* This inode entry is in-memory only and thus we don't have to mark
          * the inode dirty */
-        UDF_I_LENEXTENTS(inode) = lbcount;
+        iinfo->i_lenExtents = lbcount;
         brelse(epos.bh);
 }
 
@@ -184,13 +187,15 @@ void udf_truncate_extents(struct inode *inode)
         uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
         int8_t etype;
         struct super_block *sb = inode->i_sb;
+        struct udf_sb_info *sbi = UDF_SB(sb);
         sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
         loff_t byte_offset;
         int adsize;
+        struct udf_inode_info *iinfo = UDF_I(inode);
 
-        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
+        if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_SHORT)
                 adsize = sizeof(short_ad);
-        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
+        else if (iinfo->i_alloc_type == ICBTAG_FLAG_AD_LONG)
                 adsize = sizeof(long_ad);
         else
                 BUG();
@@ -212,7 +217,8 @@ void udf_truncate_extents(struct inode *inode)
                 else
                         lenalloc -= sizeof(struct allocExtDesc);
 
-                while ((etype = udf_current_aext(inode, &epos, &eloc, &elen, 0)) != -1) {
+                while ((etype = udf_current_aext(inode, &epos, &eloc,
+                                                 &elen, 0)) != -1) {
                         if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30)) {
                                 udf_write_aext(inode, &epos, neloc, nelen, 0);
                                 if (indirect_ext_len) {
@@ -224,35 +230,43 @@ void udf_truncate_extents(struct inode *inode)
                                                         0, indirect_ext_len);
                                 } else {
                                         if (!epos.bh) {
-                                                UDF_I_LENALLOC(inode) = lenalloc;
+                                                iinfo->i_lenAlloc =
+                                                                lenalloc;
                                                 mark_inode_dirty(inode);
                                         } else {
                                                 struct allocExtDesc *aed =
-                                                        (struct allocExtDesc *)(epos.bh->b_data);
+                                                        (struct allocExtDesc *)
+                                                        (epos.bh->b_data);
+                                                int len =
+                                                    sizeof(struct allocExtDesc);
+
                                                 aed->lengthAllocDescs =
                                                     cpu_to_le32(lenalloc);
-                                                if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
-                                                    UDF_SB_UDFREV(sb) >= 0x0201)
-                                                        udf_update_tag(epos.bh->b_data,
-                                                                       lenalloc +
-                                                                       sizeof(struct allocExtDesc));
-                                                else
-                                                        udf_update_tag(epos.bh->b_data,
-                                                                       sizeof(struct allocExtDesc));
-                                                mark_buffer_dirty_inode(epos.bh, inode);
+                                                if (!UDF_QUERY_FLAG(sb,
+                                                        UDF_FLAG_STRICT) ||
+                                                    sbi->s_udfrev >= 0x0201)
+                                                        len += lenalloc;
+
+                                                udf_update_tag(epos.bh->b_data,
+                                                                len);
+                                                mark_buffer_dirty_inode(
+                                                                epos.bh, inode);
                                         }
                                 }
                                 brelse(epos.bh);
                                 epos.offset = sizeof(struct allocExtDesc);
                                 epos.block = eloc;
-                                epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, eloc, 0));
+                                epos.bh = udf_tread(sb,
+                                                udf_get_lb_pblock(sb, eloc, 0));
                                 if (elen)
-                                        indirect_ext_len = (elen + sb->s_blocksize -1) >>
+                                        indirect_ext_len =
+                                                (elen + sb->s_blocksize - 1) >>
                                                 sb->s_blocksize_bits;
                                 else
                                         indirect_ext_len = 1;
                         } else {
-                                extent_trunc(inode, &epos, eloc, etype, elen, 0);
+                                extent_trunc(inode, &epos, eloc, etype,
+                                             elen, 0);
                                 epos.offset += adsize;
                         }
                 }
@@ -264,19 +278,20 @@ void udf_truncate_extents(struct inode *inode)
                                         indirect_ext_len);
                 } else {
                         if (!epos.bh) {
-                                UDF_I_LENALLOC(inode) = lenalloc;
+                                iinfo->i_lenAlloc = lenalloc;
                                 mark_inode_dirty(inode);
                         } else {
                                 struct allocExtDesc *aed =
                                     (struct allocExtDesc *)(epos.bh->b_data);
                                 aed->lengthAllocDescs = cpu_to_le32(lenalloc);
                                 if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) ||
-                                    UDF_SB_UDFREV(sb) >= 0x0201)
+                                    sbi->s_udfrev >= 0x0201)
                                         udf_update_tag(epos.bh->b_data,
-                                                       lenalloc + sizeof(struct allocExtDesc));
+                                                lenalloc +
+                                                sizeof(struct allocExtDesc));
                                 else
                                         udf_update_tag(epos.bh->b_data,
-                                                       sizeof(struct allocExtDesc));
+                                                sizeof(struct allocExtDesc));
                                 mark_buffer_dirty_inode(epos.bh, inode);
                         }
                 }
@@ -290,13 +305,16 @@ void udf_truncate_extents(struct inode *inode)
                          *  extending the file by 'offset' blocks.
                          */
                         if ((!epos.bh &&
-                             epos.offset == udf_file_entry_alloc_offset(inode)) ||
-                            (epos.bh && epos.offset == sizeof(struct allocExtDesc))) {
+                             epos.offset ==
+                                        udf_file_entry_alloc_offset(inode)) ||
+                            (epos.bh && epos.offset ==
+                                                sizeof(struct allocExtDesc))) {
                                 /* File has no extents at all or has empty last
                                  * indirect extent! Create a fake extent... */
                                 extent.extLocation.logicalBlockNum = 0;
                                 extent.extLocation.partitionReferenceNum = 0;
-                                extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
+                                extent.extLength =
+                                        EXT_NOT_RECORDED_NOT_ALLOCATED;
                         } else {
                                 epos.offset -= adsize;
                                 etype = udf_next_aext(inode, &epos,
@@ -305,10 +323,12 @@ void udf_truncate_extents(struct inode *inode)
                                 extent.extLength |= etype << 30;
                         }
                         udf_extend_file(inode, &epos, &extent,
-                                        offset + ((inode->i_size & (sb->s_blocksize - 1)) != 0));
+                                        offset +
+                                        ((inode->i_size &
+                                                (sb->s_blocksize - 1)) != 0));
                 }
         }
-        UDF_I_LENEXTENTS(inode) = inode->i_size;
+        iinfo->i_lenExtents = inode->i_size;
 
         brelse(epos.bh);
 }
diff --git a/fs/udf/udf_i.h b/fs/udf/udf_i.h
index d7dbe6f3ba0c..ccc52f16bf7d 100644
--- a/fs/udf/udf_i.h
+++ b/fs/udf/udf_i.h
@@ -7,20 +7,4 @@ static inline struct udf_inode_info *UDF_I(struct inode *inode)
         return list_entry(inode, struct udf_inode_info, vfs_inode);
 }
 
-#define UDF_I_LOCATION(X)       ( UDF_I(X)->i_location )
-#define UDF_I_LENEATTR(X)       ( UDF_I(X)->i_lenEAttr )
-#define UDF_I_LENALLOC(X)       ( UDF_I(X)->i_lenAlloc )
-#define UDF_I_LENEXTENTS(X)     ( UDF_I(X)->i_lenExtents )
-#define UDF_I_UNIQUE(X)         ( UDF_I(X)->i_unique )
-#define UDF_I_ALLOCTYPE(X)      ( UDF_I(X)->i_alloc_type )
-#define UDF_I_EFE(X)            ( UDF_I(X)->i_efe )
-#define UDF_I_USE(X)            ( UDF_I(X)->i_use )
-#define UDF_I_STRAT4096(X)      ( UDF_I(X)->i_strat4096 )
-#define UDF_I_NEXT_ALLOC_BLOCK(X)       ( UDF_I(X)->i_next_alloc_block )
-#define UDF_I_NEXT_ALLOC_GOAL(X)        ( UDF_I(X)->i_next_alloc_goal )
-#define UDF_I_CRTIME(X)         ( UDF_I(X)->i_crtime )
-#define UDF_I_SAD(X)            ( UDF_I(X)->i_ext.i_sad )
-#define UDF_I_LAD(X)            ( UDF_I(X)->i_ext.i_lad )
-#define UDF_I_DATA(X)           ( UDF_I(X)->i_ext.i_data )
-
 #endif /* !defined(_LINUX_UDF_I_H) */
diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
index 3c2982017c6d..737d1c604eea 100644
--- a/fs/udf/udf_sb.h
+++ b/fs/udf/udf_sb.h
@@ -26,6 +26,8 @@
 #define UDF_FLAG_GID_IGNORE     14
 #define UDF_FLAG_UID_SET        15
 #define UDF_FLAG_GID_SET        16
+#define UDF_FLAG_SESSION_SET    17
+#define UDF_FLAG_LASTBLOCK_SET  18
 
 #define UDF_PART_FLAG_UNALLOC_BITMAP    0x0001
 #define UDF_PART_FLAG_UNALLOC_TABLE     0x0002
@@ -41,96 +43,12 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
         return sb->s_fs_info;
 }
 
-#define UDF_SB_FREE(X)\
-{\
-        if (UDF_SB(X)) {\
-                kfree(UDF_SB_PARTMAPS(X));\
-                UDF_SB_PARTMAPS(X) = NULL;\
-        }\
-}
-
-#define UDF_SB_ALLOC_PARTMAPS(X,Y)\
-{\
-        UDF_SB_PARTMAPS(X) = kmalloc(sizeof(struct udf_part_map) * Y, GFP_KERNEL);\
-        if (UDF_SB_PARTMAPS(X) != NULL) {\
-                UDF_SB_NUMPARTS(X) = Y;\
-                memset(UDF_SB_PARTMAPS(X), 0x00, sizeof(struct udf_part_map) * Y);\
-        } else {\
-                UDF_SB_NUMPARTS(X) = 0;\
-                udf_error(X, __FUNCTION__, "Unable to allocate space for %d partition maps", Y);\
-        }\
-}
-
-#define UDF_SB_ALLOC_BITMAP(X,Y,Z)\
-{\
-        int nr_groups = ((UDF_SB_PARTLEN((X),(Y)) + (sizeof(struct spaceBitmapDesc) << 3) +\
-                ((X)->s_blocksize * 8) - 1) / ((X)->s_blocksize * 8));\
-        int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
-        if (size <= PAGE_SIZE)\
-                UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = kmalloc(size, GFP_KERNEL);\
-        else\
-                UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap = vmalloc(size);\
-        if (UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap != NULL) {\
-                memset(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap, 0x00, size);\
-                UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap =\
-                        (struct buffer_head **)(UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap + 1);\
-                UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups = nr_groups;\
-        } else {\
-                udf_error(X, __FUNCTION__, "Unable to allocate space for bitmap and %d buffer_head pointers", nr_groups);\
-        }\
-}
+struct logicalVolIntegrityDescImpUse *udf_sb_lvidiu(struct udf_sb_info *sbi);
 
-#define UDF_SB_FREE_BITMAP(X,Y,Z)\
-{\
-        int i;\
-        int nr_groups = UDF_SB_BITMAP_NR_GROUPS(X,Y,Z);\
-        int size = sizeof(struct udf_bitmap) + (sizeof(struct buffer_head *) * nr_groups);\
-        for (i = 0; i < nr_groups; i++) {\
-                if (UDF_SB_BITMAP(X,Y,Z,i))\
-                        brelse(UDF_SB_BITMAP(X,Y,Z,i));\
-        }\
-        if (size <= PAGE_SIZE)\
-                kfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\
-        else\
-                vfree(UDF_SB_PARTMAPS(X)[Y].Z.s_bitmap);\
-}
+int udf_compute_nr_groups(struct super_block *sb, u32 partition);
 
 #define UDF_QUERY_FLAG(X,Y)                     ( UDF_SB(X)->s_flags & ( 1 << (Y) ) )
 #define UDF_SET_FLAG(X,Y)                       ( UDF_SB(X)->s_flags |= ( 1 << (Y) ) )
 #define UDF_CLEAR_FLAG(X,Y)                     ( UDF_SB(X)->s_flags &= ~( 1 << (Y) ) )
 
-#define UDF_UPDATE_UDFREV(X,Y)                  ( ((Y) > UDF_SB_UDFREV(X)) ? UDF_SB_UDFREV(X) = (Y) : UDF_SB_UDFREV(X) )
-
-#define UDF_SB_PARTMAPS(X)                      ( UDF_SB(X)->s_partmaps )
-#define UDF_SB_PARTTYPE(X,Y)                    ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_type )
-#define UDF_SB_PARTROOT(X,Y)                    ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_root )
-#define UDF_SB_PARTLEN(X,Y)                     ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_len )
-#define UDF_SB_PARTVSN(X,Y)                     ( UDF_SB_PARTMAPS(X)[(Y)].s_volumeseqnum )
-#define UDF_SB_PARTNUM(X,Y)                     ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_num )
-#define UDF_SB_TYPESPAR(X,Y)                    ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_sparing )
-#define UDF_SB_TYPEVIRT(X,Y)                    ( UDF_SB_PARTMAPS(X)[(Y)].s_type_specific.s_virtual )
-#define UDF_SB_PARTFUNC(X,Y)                    ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_func )
-#define UDF_SB_PARTFLAGS(X,Y)                   ( UDF_SB_PARTMAPS(X)[(Y)].s_partition_flags )
-#define UDF_SB_BITMAP(X,Y,Z,I)                  ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_block_bitmap[I] )
-#define UDF_SB_BITMAP_NR_GROUPS(X,Y,Z)          ( UDF_SB_PARTMAPS(X)[(Y)].Z.s_bitmap->s_nr_groups )
-
-#define UDF_SB_VOLIDENT(X)                      ( UDF_SB(X)->s_volident )
-#define UDF_SB_NUMPARTS(X)                      ( UDF_SB(X)->s_partitions )
-#define UDF_SB_PARTITION(X)                     ( UDF_SB(X)->s_partition )
-#define UDF_SB_SESSION(X)                       ( UDF_SB(X)->s_session )
-#define UDF_SB_ANCHOR(X)                        ( UDF_SB(X)->s_anchor )
-#define UDF_SB_LASTBLOCK(X)                     ( UDF_SB(X)->s_lastblock )
-#define UDF_SB_LVIDBH(X)                        ( UDF_SB(X)->s_lvidbh )
-#define UDF_SB_LVID(X)                          ( (struct logicalVolIntegrityDesc *)UDF_SB_LVIDBH(X)->b_data )
-#define UDF_SB_LVIDIU(X)                        ( (struct logicalVolIntegrityDescImpUse *)&(UDF_SB_LVID(X)->impUse[le32_to_cpu(UDF_SB_LVID(X)->numOfPartitions) * 2 * sizeof(uint32_t)/sizeof(uint8_t)]) )
-
-#define UDF_SB_UMASK(X)                         ( UDF_SB(X)->s_umask )
-#define UDF_SB_GID(X)                           ( UDF_SB(X)->s_gid )
-#define UDF_SB_UID(X)                           ( UDF_SB(X)->s_uid )
-#define UDF_SB_RECORDTIME(X)                    ( UDF_SB(X)->s_recordtime )
-#define UDF_SB_SERIALNUM(X)                     ( UDF_SB(X)->s_serialnum )
-#define UDF_SB_UDFREV(X)                        ( UDF_SB(X)->s_udfrev )
-#define UDF_SB_FLAGS(X)                         ( UDF_SB(X)->s_flags )
-#define UDF_SB_VAT(X)                           ( UDF_SB(X)->s_vat )
-
 #endif /* __LINUX_UDF_SB_H */
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index c8016cc9e7e6..681dc2b66cdb 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -24,18 +24,21 @@
 #define UDF_PATH_LEN            1023
 
 #define udf_file_entry_alloc_offset(inode)\
-        (UDF_I_USE(inode) ?\
+        (UDF_I(inode)->i_use ?\
                 sizeof(struct unallocSpaceEntry) :\
-                ((UDF_I_EFE(inode) ?\
+                ((UDF_I(inode)->i_efe ?\
                         sizeof(struct extendedFileEntry) :\
-                        sizeof(struct fileEntry)) + UDF_I_LENEATTR(inode)))
+                        sizeof(struct fileEntry)) + UDF_I(inode)->i_lenEAttr))
 
 #define udf_ext0_offset(inode)\
-        (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB ?\
+        (UDF_I(inode)->i_alloc_type == ICBTAG_FLAG_AD_IN_ICB ?\
                 udf_file_entry_alloc_offset(inode) : 0)
 
 #define udf_get_lb_pblock(sb,loc,offset) udf_get_pblock((sb), (loc).logicalBlockNum, (loc).partitionReferenceNum, (offset))
 
+/* computes tag checksum */
+u8 udf_tag_checksum(const tag *t);
+
 struct dentry;
 struct inode;
 struct task_struct;
@@ -185,8 +188,8 @@ extern struct fileIdentDesc *udf_fileident_read(struct inode *, loff_t *,
                                                 sector_t *);
 extern struct fileIdentDesc *udf_get_fileident(void *buffer, int bufsize,
                                                int *offset);
-extern long_ad *udf_get_filelongad(uint8_t *, int, int *, int);
-extern short_ad *udf_get_fileshortad(uint8_t *, int, int *, int);
+extern long_ad *udf_get_filelongad(uint8_t *, int, uint32_t *, int);
+extern short_ad *udf_get_fileshortad(uint8_t *, int, uint32_t *, int);
 
 /* crc.c */
 extern uint16_t udf_crc(uint8_t *, uint32_t, uint16_t);
diff --git a/fs/udf/udftime.c b/fs/udf/udftime.c
index adcb87c2da7e..ce595732ba6f 100644
--- a/fs/udf/udftime.c
+++ b/fs/udf/udftime.c
@@ -18,8 +18,10 @@
    Boston, MA 02111-1307, USA.  */
 
 /*
- * dgb 10/02/98: ripped this from glibc source to help convert timestamps to unix time
- *     10/04/98: added new table-based lookup after seeing how ugly the gnu code is
+ * dgb 10/02/98: ripped this from glibc source to help convert timestamps
+ *               to unix time
+ *     10/04/98: added new table-based lookup after seeing how ugly
+ *               the gnu code is
  * blf 09/27/99: ripped out all the old code and inserted new table from
  *               John Brockmeyer (without leap second corrections)
  *               rewrote udf_stamp_to_time and fixed timezone accounting in
@@ -55,27 +57,27 @@ static const unsigned short int __mon_yday[2][13] = {
 
 #define MAX_YEAR_SECONDS        69
 #define SPD                     0x15180 /*3600*24 */
-#define SPY(y,l,s)              (SPD * (365*y+l)+s)
-
-static time_t year_seconds[MAX_YEAR_SECONDS]= {
-/*1970*/ SPY( 0, 0,0), SPY( 1, 0,0), SPY( 2, 0,0), SPY( 3, 1,0),
-/*1974*/ SPY( 4, 1,0), SPY( 5, 1,0), SPY( 6, 1,0), SPY( 7, 2,0),
-/*1978*/ SPY( 8, 2,0), SPY( 9, 2,0), SPY(10, 2,0), SPY(11, 3,0),
-/*1982*/ SPY(12, 3,0), SPY(13, 3,0), SPY(14, 3,0), SPY(15, 4,0),
-/*1986*/ SPY(16, 4,0), SPY(17, 4,0), SPY(18, 4,0), SPY(19, 5,0),
-/*1990*/ SPY(20, 5,0), SPY(21, 5,0), SPY(22, 5,0), SPY(23, 6,0),
-/*1994*/ SPY(24, 6,0), SPY(25, 6,0), SPY(26, 6,0), SPY(27, 7,0),
-/*1998*/ SPY(28, 7,0), SPY(29, 7,0), SPY(30, 7,0), SPY(31, 8,0),
-/*2002*/ SPY(32, 8,0), SPY(33, 8,0), SPY(34, 8,0), SPY(35, 9,0),
-/*2006*/ SPY(36, 9,0), SPY(37, 9,0), SPY(38, 9,0), SPY(39,10,0),
-/*2010*/ SPY(40,10,0), SPY(41,10,0), SPY(42,10,0), SPY(43,11,0),
-/*2014*/ SPY(44,11,0), SPY(45,11,0), SPY(46,11,0), SPY(47,12,0),
-/*2018*/ SPY(48,12,0), SPY(49,12,0), SPY(50,12,0), SPY(51,13,0),
-/*2022*/ SPY(52,13,0), SPY(53,13,0), SPY(54,13,0), SPY(55,14,0),
-/*2026*/ SPY(56,14,0), SPY(57,14,0), SPY(58,14,0), SPY(59,15,0),
-/*2030*/ SPY(60,15,0), SPY(61,15,0), SPY(62,15,0), SPY(63,16,0),
-/*2034*/ SPY(64,16,0), SPY(65,16,0), SPY(66,16,0), SPY(67,17,0),
-/*2038*/ SPY(68,17,0)
+#define SPY(y, l, s)            (SPD * (365 * y + l) + s)
+
+static time_t year_seconds[MAX_YEAR_SECONDS] = {
+/*1970*/ SPY(0,   0, 0), SPY(1,   0, 0), SPY(2,   0, 0), SPY(3,   1, 0),
+/*1974*/ SPY(4,   1, 0), SPY(5,   1, 0), SPY(6,   1, 0), SPY(7,   2, 0),
+/*1978*/ SPY(8,   2, 0), SPY(9,   2, 0), SPY(10,  2, 0), SPY(11,  3, 0),
+/*1982*/ SPY(12,  3, 0), SPY(13,  3, 0), SPY(14,  3, 0), SPY(15,  4, 0),
+/*1986*/ SPY(16,  4, 0), SPY(17,  4, 0), SPY(18,  4, 0), SPY(19,  5, 0),
+/*1990*/ SPY(20,  5, 0), SPY(21,  5, 0), SPY(22,  5, 0), SPY(23,  6, 0),
+/*1994*/ SPY(24,  6, 0), SPY(25,  6, 0), SPY(26,  6, 0), SPY(27,  7, 0),
+/*1998*/ SPY(28,  7, 0), SPY(29,  7, 0), SPY(30,  7, 0), SPY(31,  8, 0),
+/*2002*/ SPY(32,  8, 0), SPY(33,  8, 0), SPY(34,  8, 0), SPY(35,  9, 0),
+/*2006*/ SPY(36,  9, 0), SPY(37,  9, 0), SPY(38,  9, 0), SPY(39, 10, 0),
+/*2010*/ SPY(40, 10, 0), SPY(41, 10, 0), SPY(42, 10, 0), SPY(43, 11, 0),
+/*2014*/ SPY(44, 11, 0), SPY(45, 11, 0), SPY(46, 11, 0), SPY(47, 12, 0),
+/*2018*/ SPY(48, 12, 0), SPY(49, 12, 0), SPY(50, 12, 0), SPY(51, 13, 0),
+/*2022*/ SPY(52, 13, 0), SPY(53, 13, 0), SPY(54, 13, 0), SPY(55, 14, 0),
+/*2026*/ SPY(56, 14, 0), SPY(57, 14, 0), SPY(58, 14, 0), SPY(59, 15, 0),
+/*2030*/ SPY(60, 15, 0), SPY(61, 15, 0), SPY(62, 15, 0), SPY(63, 16, 0),
+/*2034*/ SPY(64, 16, 0), SPY(65, 16, 0), SPY(66, 16, 0), SPY(67, 17, 0),
+/*2038*/ SPY(68, 17, 0)
 };
 
 extern struct timezone sys_tz;
@@ -115,7 +117,7 @@ time_t *udf_stamp_to_time(time_t *dest, long *dest_usec, kernel_timestamp src)
         return dest;
 }
 
-kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
+kernel_timestamp *udf_time_to_stamp(kernel_timestamp *dest, struct timespec ts)
 {
         long int days, rem, y;
         const unsigned short int *ip;
@@ -137,7 +139,7 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
         dest->second = rem % 60;
         y = 1970;
 
-#define DIV(a,b) ((a) / (b) - ((a) % (b) < 0))
+#define DIV(a, b) ((a) / (b) - ((a) % (b) < 0))
 #define LEAPS_THRU_END_OF(y) (DIV (y, 4) - DIV (y, 100) + DIV (y, 400))
 
         while (days < 0 || days >= (__isleap(y) ? 366 : 365)) {
@@ -145,8 +147,8 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
 
                 /* Adjust DAYS and Y to match the guessed year.  */
                 days -= ((yg - y) * 365
-                         + LEAPS_THRU_END_OF (yg - 1)
-                         - LEAPS_THRU_END_OF (y - 1));
+                         + LEAPS_THRU_END_OF(yg - 1)
+                         - LEAPS_THRU_END_OF(y - 1));
                 y = yg;
         }
         dest->year = y;
@@ -158,7 +160,8 @@ kernel_timestamp *udf_time_to_stamp(kernel_timestamp * dest, struct timespec ts)
         dest->day = days + 1;
 
         dest->centiseconds = ts.tv_nsec / 10000000;
-        dest->hundredsOfMicroseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000) / 100;
+        dest->hundredsOfMicroseconds = (ts.tv_nsec / 1000 -
+                                        dest->centiseconds * 10000) / 100;
         dest->microseconds = (ts.tv_nsec / 1000 - dest->centiseconds * 10000 -
                               dest->hundredsOfMicroseconds * 100);
         return dest;
diff --git a/fs/udf/unicode.c b/fs/udf/unicode.c
index 9e6099c26c27..e533b11703bf 100644
--- a/fs/udf/unicode.c
+++ b/fs/udf/unicode.c
@@ -136,12 +136,18 @@ int udf_CS0toUTF8(struct ustr *utf_o, struct ustr *ocu_i)
                 if (c < 0x80U) {
                         utf_o->u_name[utf_o->u_len++] = (uint8_t)c;
                 } else if (c < 0x800U) {
-                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xc0 | (c >> 6));
-                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
+                        utf_o->u_name[utf_o->u_len++] =
+                                                (uint8_t)(0xc0 | (c >> 6));
+                        utf_o->u_name[utf_o->u_len++] =
+                                                (uint8_t)(0x80 | (c & 0x3f));
                 } else {
-                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0xe0 | (c >> 12));
-                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | ((c >> 6) & 0x3f));
-                        utf_o->u_name[utf_o->u_len++] = (uint8_t)(0x80 | (c & 0x3f));
+                        utf_o->u_name[utf_o->u_len++] =
+                                                (uint8_t)(0xe0 | (c >> 12));
+                        utf_o->u_name[utf_o->u_len++] =
+                                                (uint8_t)(0x80 |
+                                                          ((c >> 6) & 0x3f));
+                        utf_o->u_name[utf_o->u_len++] =
+                                                (uint8_t)(0x80 | (c & 0x3f));
                 }
         }
         utf_o->u_cmpID = 8;
@@ -232,9 +238,8 @@ try_again:
                         goto error_out;
                 }
 
-                if (max_val == 0xffffU) {
+                if (max_val == 0xffffU)
                         ocu[++u_len] = (uint8_t)(utf_char >> 8);
-                }
                 ocu[++u_len] = (uint8_t)(utf_char & 0xffU);
         }
 
@@ -330,29 +335,29 @@ int udf_get_filename(struct super_block *sb, uint8_t *sname, uint8_t *dname,
         struct ustr filename, unifilename;
         int len;
 
-        if (udf_build_ustr_exact(&unifilename, sname, flen)) {
+        if (udf_build_ustr_exact(&unifilename, sname, flen))
                 return 0;
-        }
 
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
                 if (!udf_CS0toUTF8(&filename, &unifilename)) {
-                        udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
+                        udf_debug("Failed in udf_get_filename: sname = %s\n",
+                                  sname);
                         return 0;
                 }
         } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
-                if (!udf_CS0toNLS(UDF_SB(sb)->s_nls_map, &filename, &unifilename)) {
-                        udf_debug("Failed in udf_get_filename: sname = %s\n", sname);
+                if (!udf_CS0toNLS(UDF_SB(sb)->s_nls_map, &filename,
+                                  &unifilename)) {
+                        udf_debug("Failed in udf_get_filename: sname = %s\n",
+                                  sname);
                         return 0;
                 }
-        } else {
+        } else
                 return 0;
-        }
 
         len = udf_translate_to_linux(dname, filename.u_name, filename.u_len,
                                      unifilename.u_name, unifilename.u_len);
-        if (len) {
+        if (len)
                 return len;
-        }
 
         return 0;
 }
@@ -363,23 +368,20 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname,
         struct ustr unifilename;
         int namelen;
 
-        if (!(udf_char_to_ustr(&unifilename, sname, flen))) {
+        if (!udf_char_to_ustr(&unifilename, sname, flen))
                 return 0;
-        }
 
         if (UDF_QUERY_FLAG(sb, UDF_FLAG_UTF8)) {
                 namelen = udf_UTF8toCS0(dname, &unifilename, UDF_NAME_LEN);
-                if (!namelen) {
+                if (!namelen)
                         return 0;
-                }
         } else if (UDF_QUERY_FLAG(sb, UDF_FLAG_NLS_MAP)) {
-                namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname, &unifilename, UDF_NAME_LEN);
-                if (!namelen) {
+                namelen = udf_NLStoCS0(UDF_SB(sb)->s_nls_map, dname,
+                                        &unifilename, UDF_NAME_LEN);
+                if (!namelen)
                         return 0;
-                }
-        } else {
+        } else
                 return 0;
-        }
 
         return namelen;
 }
@@ -389,8 +391,9 @@ int udf_put_filename(struct super_block *sb, const uint8_t *sname,
 #define CRC_MARK                '#'
 #define EXT_SIZE                5
 
-static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen,
-                                  uint8_t *fidName, int fidNameLen)
+static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName,
+                                  int udfLen, uint8_t *fidName,
+                                  int fidNameLen)
 {
         int index, newIndex = 0, needsCRC = 0;
         int extIndex = 0, newExtIndex = 0, hasExt = 0;
@@ -409,13 +412,16 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
                         if (curr == '/' || curr == 0) {
                                 needsCRC = 1;
                                 curr = ILLEGAL_CHAR_MARK;
-                                while (index + 1 < udfLen && (udfName[index + 1] == '/' ||
-                                                              udfName[index + 1] == 0))
+                                while (index + 1 < udfLen &&
+                                                (udfName[index + 1] == '/' ||
+                                                 udfName[index + 1] == 0))
                                         index++;
-                        } if (curr == EXT_MARK && (udfLen - index - 1) <= EXT_SIZE) {
-                                if (udfLen == index + 1) {
+                        }
+                        if (curr == EXT_MARK &&
+                                        (udfLen - index - 1) <= EXT_SIZE) {
+                                if (udfLen == index + 1)
                                         hasExt = 0;
-                                } else {
+                                else {
                                         hasExt = 1;
                                         extIndex = index;
                                         newExtIndex = newIndex;
@@ -433,16 +439,18 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
 
                 if (hasExt) {
                         int maxFilenameLen;
-                        for(index = 0; index < EXT_SIZE && extIndex + index + 1 < udfLen; index++) {
+                        for (index = 0;
+                             index < EXT_SIZE && extIndex + index + 1 < udfLen;
+                             index++) {
                                 curr = udfName[extIndex + index + 1];
 
                                 if (curr == '/' || curr == 0) {
                                         needsCRC = 1;
                                         curr = ILLEGAL_CHAR_MARK;
-                                        while(extIndex + index + 2 < udfLen &&
-                                              (index + 1 < EXT_SIZE
-                                               && (udfName[extIndex + index + 2] == '/' ||
-                                                   udfName[extIndex + index + 2] == 0)))
+                                        while (extIndex + index + 2 < udfLen &&
+                                              (index + 1 < EXT_SIZE &&
+                                                (udfName[extIndex + index + 2] == '/' ||
+                                                 udfName[extIndex + index + 2] == 0)))
                                                 index++;
                                 }
                                 ext[localExtIndex++] = curr;
@@ -452,9 +460,8 @@ static int udf_translate_to_linux(uint8_t *newName, uint8_t *udfName, int udfLen
                                 newIndex = maxFilenameLen;
                         else
                                 newIndex = newExtIndex;
-                } else if (newIndex > 250) {
+                } else if (newIndex > 250)
                         newIndex = 250;
-                }
                 newName[newIndex++] = CRC_MARK;
                 valueCRC = udf_crc(fidName, fidNameLen, 0);
                 newName[newIndex++] = hexChar[(valueCRC & 0xf000) >> 12];
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index f63a09ce8683..1fca381f0ce2 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -9,7 +9,6 @@
  */
 
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/stat.h>
 #include <linux/time.h>
 #include <linux/string.h>
@@ -19,6 +18,7 @@
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"
diff --git a/fs/ufs/cylinder.c b/fs/ufs/cylinder.c
index 2a815665644f..b4676322ddb6 100644
--- a/fs/ufs/cylinder.c
+++ b/fs/ufs/cylinder.c
@@ -9,7 +9,6 @@
  */
 
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/time.h>
 #include <linux/stat.h>
 #include <linux/string.h>
@@ -17,6 +16,7 @@
 
 #include <asm/byteorder.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index aaf2878305ce..ef563fc8d72c 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -18,9 +18,9 @@
 
 #include <linux/time.h>
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/swap.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"
diff --git a/fs/ufs/file.c b/fs/ufs/file.c
index a46c97bf023f..625ef17c6f83 100644
--- a/fs/ufs/file.c
+++ b/fs/ufs/file.c
@@ -24,9 +24,9 @@
  */
 
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/buffer_head.h>  /* for sync_mapping_buffers() */
 
+#include "ufs_fs.h"
 #include "ufs.h"
 
 
diff --git a/fs/ufs/ialloc.c b/fs/ufs/ialloc.c
index 7e260bc0d94f..ac181f6806a3 100644
--- a/fs/ufs/ialloc.c
+++ b/fs/ufs/ialloc.c
@@ -24,7 +24,6 @@
  */
 
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/time.h>
 #include <linux/stat.h>
 #include <linux/string.h>
@@ -34,6 +33,7 @@
 #include <linux/bitops.h>
 #include <asm/byteorder.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"
diff --git a/fs/ufs/inode.c b/fs/ufs/inode.c
index 489f26bc26d9..5446b888fc8e 100644
--- a/fs/ufs/inode.c
+++ b/fs/ufs/inode.c
@@ -30,7 +30,6 @@
 
 #include <linux/errno.h>
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/time.h>
 #include <linux/stat.h>
 #include <linux/string.h>
@@ -38,6 +37,7 @@
 #include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"
diff --git a/fs/ufs/namei.c b/fs/ufs/namei.c
index 747a4de6c695..e3a9b1fac75a 100644
--- a/fs/ufs/namei.c
+++ b/fs/ufs/namei.c
@@ -29,8 +29,9 @@
 
 #include <linux/time.h>
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/smp_lock.h>
+
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "util.h"
 
diff --git a/fs/ufs/super.c b/fs/ufs/super.c
index 73deff475e63..85b22b5977fa 100644
--- a/fs/ufs/super.c
+++ b/fs/ufs/super.c
@@ -76,7 +76,6 @@
 
 #include <linux/errno.h>
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/slab.h>
 #include <linux/time.h>
 #include <linux/stat.h>
@@ -91,6 +90,7 @@
 #include <linux/mount.h>
 #include <linux/seq_file.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"
@@ -131,6 +131,8 @@ static void ufs_print_super_stuff(struct super_block *sb,
                 printk(KERN_INFO"  cs_nffree(Num of free frags): %llu\n",
                        (unsigned long long)
                        fs64_to_cpu(sb, usb3->fs_un1.fs_u2.cs_nffree));
+                printk(KERN_INFO"  fs_maxsymlinklen: %u\n",
+                       fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen));
         } else {
                 printk(" sblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_sblkno));
                 printk(" cblkno:      %u\n", fs32_to_cpu(sb, usb1->fs_cblkno));
@@ -1061,8 +1063,8 @@ magic_found:
         uspi->s_bpf = uspi->s_fsize << 3;
         uspi->s_bpfshift = uspi->s_fshift + 3;
         uspi->s_bpfmask = uspi->s_bpf - 1;
-        if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) ==
-            UFS_MOUNT_UFSTYPE_44BSD)
+        if ((sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_44BSD ||
+            (sbi->s_mount_opt & UFS_MOUNT_UFSTYPE) == UFS_MOUNT_UFSTYPE_UFS2)
                 uspi->s_maxsymlinklen =
                     fs32_to_cpu(sb, usb3->fs_un2.fs_44.fs_maxsymlinklen);
 
diff --git a/fs/ufs/symlink.c b/fs/ufs/symlink.c
index 43ac10e75a4a..c0156eda44bc 100644
--- a/fs/ufs/symlink.c
+++ b/fs/ufs/symlink.c
@@ -27,7 +27,8 @@
 
 #include <linux/fs.h>
 #include <linux/namei.h>
-#include <linux/ufs_fs.h>
+
+#include "ufs_fs.h"
 #include "ufs.h"
 
 
diff --git a/fs/ufs/truncate.c b/fs/ufs/truncate.c
index 311ded34c2b2..41dd431ce228 100644
--- a/fs/ufs/truncate.c
+++ b/fs/ufs/truncate.c
@@ -36,7 +36,6 @@
 
 #include <linux/errno.h>
 #include <linux/fs.h>
-#include <linux/ufs_fs.h>
 #include <linux/fcntl.h>
 #include <linux/time.h>
 #include <linux/stat.h>
@@ -46,6 +45,7 @@
 #include <linux/blkdev.h>
 #include <linux/sched.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"
diff --git a/fs/ufs/ufs_fs.h b/fs/ufs/ufs_fs.h
new file mode 100644
index 000000000000..54bde1895a80
--- /dev/null
+++ b/fs/ufs/ufs_fs.h
@@ -0,0 +1,947 @@
+/*
+ *  linux/include/linux/ufs_fs.h
+ *
+ * Copyright (C) 1996
+ * Adrian Rodriguez (adrian@franklins-tower.rutgers.edu)
+ * Laboratory for Computer Science Research Computing Facility
+ * Rutgers, The State University of New Jersey
+ *
+ * Clean swab support by Fare <fare@tunes.org>
+ * just hope no one is using NNUUXXI on __?64 structure elements
+ * 64-bit clean thanks to Maciej W. Rozycki <macro@ds2.pg.gda.pl>
+ *
+ * 4.4BSD (FreeBSD) support added on February 1st 1998 by
+ * Niels Kristian Bech Jensen <nkbj@image.dk> partially based
+ * on code by Martin von Loewis <martin@mira.isdn.cs.tu-berlin.de>.
+ *
+ * NeXTstep support added on February 5th 1998 by
+ * Niels Kristian Bech Jensen <nkbj@image.dk>.
+ *
+ * Write support by Daniel Pirkl <daniel.pirkl@email.cz>
+ *
+ * HP/UX hfs filesystem support added by
+ * Martin K. Petersen <mkp@mkp.net>, August 1999
+ *
+ * UFS2 (of FreeBSD 5.x) support added by
+ * Niraj Kumar <niraj17@iitbombay.org>  , Jan 2004
+ *
+ */
+
+#ifndef __LINUX_UFS_FS_H
+#define __LINUX_UFS_FS_H
+
+#include <linux/types.h>
+#include <linux/kernel.h>
+#include <linux/stat.h>
+#include <linux/fs.h>
+
+#include <asm/div64.h>
+typedef __u64 __bitwise __fs64;
+typedef __u32 __bitwise __fs32;
+typedef __u16 __bitwise __fs16;
+
+#define UFS_BBLOCK 0
+#define UFS_BBSIZE 8192
+#define UFS_SBLOCK 8192
+#define UFS_SBSIZE 8192
+
+#define UFS_SECTOR_SIZE 512
+#define UFS_SECTOR_BITS 9
+#define UFS_MAGIC  0x00011954
+#define UFS2_MAGIC 0x19540119
+#define UFS_CIGAM  0x54190100 /* byteswapped MAGIC */
+
+/* Copied from FreeBSD */
+/*
+ * Each disk drive contains some number of filesystems.
+ * A filesystem consists of a number of cylinder groups.
+ * Each cylinder group has inodes and data.
+ *
+ * A filesystem is described by its super-block, which in turn
+ * describes the cylinder groups.  The super-block is critical
+ * data and is replicated in each cylinder group to protect against
+ * catastrophic loss.  This is done at `newfs' time and the critical
+ * super-block data does not change, so the copies need not be
+ * referenced further unless disaster strikes.
+ *
+ * For filesystem fs, the offsets of the various blocks of interest
+ * are given in the super block as:
+ *      [fs->fs_sblkno]         Super-block
+ *      [fs->fs_cblkno]         Cylinder group block
+ *      [fs->fs_iblkno]         Inode blocks
+ *      [fs->fs_dblkno]         Data blocks
+ * The beginning of cylinder group cg in fs, is given by
+ * the ``cgbase(fs, cg)'' macro.
+ *
+ * Depending on the architecture and the media, the superblock may
+ * reside in any one of four places. For tiny media where every block
+ * counts, it is placed at the very front of the partition. Historically,
+ * UFS1 placed it 8K from the front to leave room for the disk label and
+ * a small bootstrap. For UFS2 it got moved to 64K from the front to leave
+ * room for the disk label and a bigger bootstrap, and for really piggy
+ * systems we check at 256K from the front if the first three fail. In
+ * all cases the size of the superblock will be SBLOCKSIZE. All values are
+ * given in byte-offset form, so they do not imply a sector size. The
+ * SBLOCKSEARCH specifies the order in which the locations should be searched.
+ */
+#define SBLOCK_FLOPPY        0
+#define SBLOCK_UFS1       8192
+#define SBLOCK_UFS2      65536
+#define SBLOCK_PIGGY    262144
+#define SBLOCKSIZE        8192
+#define SBLOCKSEARCH \
+        { SBLOCK_UFS2, SBLOCK_UFS1, SBLOCK_FLOPPY, SBLOCK_PIGGY, -1 }
+
+
+/* HP specific MAGIC values */
+
+#define UFS_MAGIC_LFN   0x00095014 /* fs supports filenames > 14 chars */
+#define UFS_CIGAM_LFN   0x14500900 /* srahc 41 < semanelif stroppus sf */
+
+#define UFS_MAGIC_SEC   0x00612195 /* B1 security fs */
+#define UFS_CIGAM_SEC   0x95216100
+
+#define UFS_MAGIC_FEA   0x00195612 /* fs_featurebits supported */
+#define UFS_CIGAM_FEA   0x12561900
+
+#define UFS_MAGIC_4GB   0x05231994 /* fs > 4 GB && fs_featurebits */
+#define UFS_CIGAM_4GB   0x94192305
+
+/* Seems somebody at HP goofed here. B1 and lfs are both 0x2 !?! */
+#define UFS_FSF_LFN     0x00000001 /* long file names */
+#define UFS_FSF_B1      0x00000002 /* B1 security */
+#define UFS_FSF_LFS     0x00000002 /* large files */
+#define UFS_FSF_LUID    0x00000004 /* large UIDs */
+
+/* End of HP stuff */
+
+
+#define UFS_BSIZE       8192
+#define UFS_MINBSIZE    4096
+#define UFS_FSIZE       1024
+#define UFS_MAXFRAG     (UFS_BSIZE / UFS_FSIZE)
+
+#define UFS_NDADDR 12
+#define UFS_NINDIR 3
+
+#define UFS_IND_BLOCK   (UFS_NDADDR + 0)
+#define UFS_DIND_BLOCK  (UFS_NDADDR + 1)
+#define UFS_TIND_BLOCK  (UFS_NDADDR + 2)
+
+#define UFS_NDIR_FRAGMENT (UFS_NDADDR << uspi->s_fpbshift)
+#define UFS_IND_FRAGMENT (UFS_IND_BLOCK << uspi->s_fpbshift)
+#define UFS_DIND_FRAGMENT (UFS_DIND_BLOCK << uspi->s_fpbshift)
+#define UFS_TIND_FRAGMENT (UFS_TIND_BLOCK << uspi->s_fpbshift)
+
+#define UFS_ROOTINO 2
+#define UFS_FIRST_INO (UFS_ROOTINO + 1)
+
+#define UFS_USEEFT  ((__u16)65535)
+
+#define UFS_FSOK      0x7c269d38
+#define UFS_FSACTIVE  ((__s8)0x00)
+#define UFS_FSCLEAN   ((__s8)0x01)
+#define UFS_FSSTABLE  ((__s8)0x02)
+#define UFS_FSOSF1    ((__s8)0x03)      /* is this correct for DEC OSF/1? */
+#define UFS_FSBAD     ((__s8)0xff)
+
+/* From here to next blank line, s_flags for ufs_sb_info */
+/* directory entry encoding */
+#define UFS_DE_MASK             0x00000010      /* mask for the following */
+#define UFS_DE_OLD              0x00000000
+#define UFS_DE_44BSD            0x00000010
+/* uid encoding */
+#define UFS_UID_MASK            0x00000060      /* mask for the following */
+#define UFS_UID_OLD             0x00000000
+#define UFS_UID_44BSD           0x00000020
+#define UFS_UID_EFT             0x00000040
+/* superblock state encoding */
+#define UFS_ST_MASK             0x00000700      /* mask for the following */
+#define UFS_ST_OLD              0x00000000
+#define UFS_ST_44BSD            0x00000100
+#define UFS_ST_SUN              0x00000200 /* Solaris */
+#define UFS_ST_SUNOS            0x00000300
+#define UFS_ST_SUNx86           0x00000400 /* Solaris x86 */
+/*cylinder group encoding */
+#define UFS_CG_MASK             0x00003000      /* mask for the following */
+#define UFS_CG_OLD              0x00000000
+#define UFS_CG_44BSD            0x00002000
+#define UFS_CG_SUN              0x00001000
+/* filesystem type encoding */
+#define UFS_TYPE_MASK           0x00010000      /* mask for the following */
+#define UFS_TYPE_UFS1           0x00000000
+#define UFS_TYPE_UFS2           0x00010000
+
+
+/* fs_inodefmt options */
+#define UFS_42INODEFMT  -1
+#define UFS_44INODEFMT  2
+
+/*
+ * MINFREE gives the minimum acceptable percentage of file system
+ * blocks which may be free. If the freelist drops below this level
+ * only the superuser may continue to allocate blocks. This may
+ * be set to 0 if no reserve of free blocks is deemed necessary,
+ * however throughput drops by fifty percent if the file system
+ * is run at between 95% and 100% full; thus the minimum default
+ * value of fs_minfree is 5%. However, to get good clustering
+ * performance, 10% is a better choice. hence we use 10% as our
+ * default value. With 10% free space, fragmentation is not a
+ * problem, so we choose to optimize for time.
+ */
+#define UFS_MINFREE         5
+#define UFS_DEFAULTOPT      UFS_OPTTIME
+
+/*
+ * Turn file system block numbers into disk block addresses.
+ * This maps file system blocks to device size blocks.
+ */
+#define ufs_fsbtodb(uspi, b)    ((b) << (uspi)->s_fsbtodb)
+#define ufs_dbtofsb(uspi, b)    ((b) >> (uspi)->s_fsbtodb)
+
+/*
+ * Cylinder group macros to locate things in cylinder groups.
+ * They calc file system addresses of cylinder group data structures.
+ */
+#define ufs_cgbase(c)   (uspi->s_fpg * (c))
+#define ufs_cgstart(c)  ((uspi)->fs_magic == UFS2_MAGIC ?  ufs_cgbase(c) : \
+        (ufs_cgbase(c)  + uspi->s_cgoffset * ((c) & ~uspi->s_cgmask)))
+#define ufs_cgsblock(c) (ufs_cgstart(c) + uspi->s_sblkno)       /* super blk */
+#define ufs_cgcmin(c)   (ufs_cgstart(c) + uspi->s_cblkno)       /* cg block */
+#define ufs_cgimin(c)   (ufs_cgstart(c) + uspi->s_iblkno)       /* inode blk */
+#define ufs_cgdmin(c)   (ufs_cgstart(c) + uspi->s_dblkno)       /* 1st data */
+
+/*
+ * Macros for handling inode numbers:
+ *     inode number to file system block offset.
+ *     inode number to cylinder group number.
+ *     inode number to file system block address.
+ */
+#define ufs_inotocg(x)          ((x) / uspi->s_ipg)
+#define ufs_inotocgoff(x)       ((x) % uspi->s_ipg)
+#define ufs_inotofsba(x)        (((u64)ufs_cgimin(ufs_inotocg(x))) + ufs_inotocgoff(x) / uspi->s_inopf)
+#define ufs_inotofsbo(x)        ((x) % uspi->s_inopf)
+
+/*
+ * Compute the cylinder and rotational position of a cyl block addr.
+ */
+#define ufs_cbtocylno(bno) \
+        ((bno) * uspi->s_nspf / uspi->s_spc)
+#define ufs_cbtorpos(bno) \
+        ((((bno) * uspi->s_nspf % uspi->s_spc / uspi->s_nsect \
+        * uspi->s_trackskew + (bno) * uspi->s_nspf % uspi->s_spc \
+        % uspi->s_nsect * uspi->s_interleave) % uspi->s_nsect \
+        * uspi->s_nrpos) / uspi->s_npsect)
+
+/*
+ * The following macros optimize certain frequently calculated
+ * quantities by using shifts and masks in place of divisions
+ * modulos and multiplications.
+ */
+#define ufs_blkoff(loc)         ((loc) & uspi->s_qbmask)
+#define ufs_fragoff(loc)        ((loc) & uspi->s_qfmask)
+#define ufs_lblktosize(blk)     ((blk) << uspi->s_bshift)
+#define ufs_lblkno(loc)         ((loc) >> uspi->s_bshift)
+#define ufs_numfrags(loc)       ((loc) >> uspi->s_fshift)
+#define ufs_blkroundup(size)    (((size) + uspi->s_qbmask) & uspi->s_bmask)
+#define ufs_fragroundup(size)   (((size) + uspi->s_qfmask) & uspi->s_fmask)
+#define ufs_fragstoblks(frags)  ((frags) >> uspi->s_fpbshift)
+#define ufs_blkstofrags(blks)   ((blks) << uspi->s_fpbshift)
+#define ufs_fragnum(fsb)        ((fsb) & uspi->s_fpbmask)
+#define ufs_blknum(fsb)         ((fsb) & ~uspi->s_fpbmask)
+
+#define UFS_MAXNAMLEN 255
+#define UFS_MAXMNTLEN 512
+#define UFS2_MAXMNTLEN 468
+#define UFS2_MAXVOLLEN 32
+#define UFS_MAXCSBUFS 31
+#define UFS_LINK_MAX 32000
+/*
+#define UFS2_NOCSPTRS   ((128 / sizeof(void *)) - 4)
+*/
+#define UFS2_NOCSPTRS   28
+
+/*
+ * UFS_DIR_PAD defines the directory entries boundaries
+ * (must be a multiple of 4)
+ */
+#define UFS_DIR_PAD                     4
+#define UFS_DIR_ROUND                   (UFS_DIR_PAD - 1)
+#define UFS_DIR_REC_LEN(name_len)       (((name_len) + 1 + 8 + UFS_DIR_ROUND) & ~UFS_DIR_ROUND)
+
+struct ufs_timeval {
+        __fs32  tv_sec;
+        __fs32  tv_usec;
+};
+
+struct ufs_dir_entry {
+        __fs32  d_ino;                  /* inode number of this entry */
+        __fs16  d_reclen;               /* length of this entry */
+        union {
+                __fs16  d_namlen;               /* actual length of d_name */
+                struct {
+                        __u8    d_type;         /* file type */
+                        __u8    d_namlen;       /* length of string in d_name */
+                } d_44;
+        } d_u;
+        __u8    d_name[UFS_MAXNAMLEN + 1];      /* file name */
+};
+
+struct ufs_csum {
+        __fs32  cs_ndir;        /* number of directories */
+        __fs32  cs_nbfree;      /* number of free blocks */
+        __fs32  cs_nifree;      /* number of free inodes */
+        __fs32  cs_nffree;      /* number of free frags */
+};
+struct ufs2_csum_total {
+        __fs64  cs_ndir;        /* number of directories */
+        __fs64  cs_nbfree;      /* number of free blocks */
+        __fs64  cs_nifree;      /* number of free inodes */
+        __fs64  cs_nffree;      /* number of free frags */
+        __fs64   cs_numclusters;        /* number of free clusters */
+        __fs64   cs_spare[3];   /* future expansion */
+};
+
+struct ufs_csum_core {
+        __u64   cs_ndir;        /* number of directories */
+        __u64   cs_nbfree;      /* number of free blocks */
+        __u64   cs_nifree;      /* number of free inodes */
+        __u64   cs_nffree;      /* number of free frags */
+        __u64   cs_numclusters; /* number of free clusters */
+};
+
+/*
+ * File system flags
+ */
+#define UFS_UNCLEAN      0x01    /* file system not clean at mount (unused) */
+#define UFS_DOSOFTDEP    0x02    /* file system using soft dependencies */
+#define UFS_NEEDSFSCK    0x04    /* needs sync fsck (FreeBSD compat, unused) */
+#define UFS_INDEXDIRS    0x08    /* kernel supports indexed directories */
+#define UFS_ACLS         0x10    /* file system has ACLs enabled */
+#define UFS_MULTILABEL   0x20    /* file system is MAC multi-label */
+#define UFS_FLAGS_UPDATED 0x80   /* flags have been moved to new location */
+
+#if 0
+/*
+ * This is the actual superblock, as it is laid out on the disk.
+ * Do NOT use this structure, because of sizeof(ufs_super_block) > 512 and
+ * it may occupy several blocks, use
+ * struct ufs_super_block_(first,second,third) instead.
+ */
+struct ufs_super_block {
+        union {
+                struct {
+                        __fs32  fs_link;        /* UNUSED */
+                } fs_42;
+                struct {
+                        __fs32  fs_state;       /* file system state flag */
+                } fs_sun;
+        } fs_u0;
+        __fs32  fs_rlink;       /* UNUSED */
+        __fs32  fs_sblkno;      /* addr of super-block in filesys */
+        __fs32  fs_cblkno;      /* offset of cyl-block in filesys */
+        __fs32  fs_iblkno;      /* offset of inode-blocks in filesys */
+        __fs32  fs_dblkno;      /* offset of first data after cg */
+        __fs32  fs_cgoffset;    /* cylinder group offset in cylinder */
+        __fs32  fs_cgmask;      /* used to calc mod fs_ntrak */
+        __fs32  fs_time;        /* last time written -- time_t */
+        __fs32  fs_size;        /* number of blocks in fs */
+        __fs32  fs_dsize;       /* number of data blocks in fs */
+        __fs32  fs_ncg;         /* number of cylinder groups */
+        __fs32  fs_bsize;       /* size of basic blocks in fs */
+        __fs32  fs_fsize;       /* size of frag blocks in fs */
+        __fs32  fs_frag;        /* number of frags in a block in fs */
+/* these are configuration parameters */
+        __fs32  fs_minfree;     /* minimum percentage of free blocks */
+        __fs32  fs_rotdelay;    /* num of ms for optimal next block */
+        __fs32  fs_rps;         /* disk revolutions per second */
+/* these fields can be computed from the others */
+        __fs32  fs_bmask;       /* ``blkoff'' calc of blk offsets */
+        __fs32  fs_fmask;       /* ``fragoff'' calc of frag offsets */
+        __fs32  fs_bshift;      /* ``lblkno'' calc of logical blkno */
+        __fs32  fs_fshift;      /* ``numfrags'' calc number of frags */
+/* these are configuration parameters */
+        __fs32  fs_maxcontig;   /* max number of contiguous blks */
+        __fs32  fs_maxbpg;      /* max number of blks per cyl group */
+/* these fields can be computed from the others */
+        __fs32  fs_fragshift;   /* block to frag shift */
+        __fs32  fs_fsbtodb;     /* fsbtodb and dbtofsb shift constant */
+        __fs32  fs_sbsize;      /* actual size of super block */
+        __fs32  fs_csmask;      /* csum block offset */
+        __fs32  fs_csshift;     /* csum block number */
+        __fs32  fs_nindir;      /* value of NINDIR */
+        __fs32  fs_inopb;       /* value of INOPB */
+        __fs32  fs_nspf;        /* value of NSPF */
+/* yet another configuration parameter */
+        __fs32  fs_optim;       /* optimization preference, see below */
+/* these fields are derived from the hardware */
+        union {
+                struct {
+                        __fs32  fs_npsect;      /* # sectors/track including spares */
+                } fs_sun;
+                struct {
+                        __fs32  fs_state;       /* file system state time stamp */
+                } fs_sunx86;
+        } fs_u1;
+        __fs32  fs_interleave;  /* hardware sector interleave */
+        __fs32  fs_trackskew;   /* sector 0 skew, per track */
+/* a unique id for this filesystem (currently unused and unmaintained) */
+/* In 4.3 Tahoe this space is used by fs_headswitch and fs_trkseek */
+/* Neither of those fields is used in the Tahoe code right now but */
+/* there could be problems if they are.                            */
+        __fs32  fs_id[2];       /* file system id */
+/* sizes determined by number of cylinder groups and their sizes */
+        __fs32  fs_csaddr;      /* blk addr of cyl grp summary area */
+        __fs32  fs_cssize;      /* size of cyl grp summary area */
+        __fs32  fs_cgsize;      /* cylinder group size */
+/* these fields are derived from the hardware */
+        __fs32  fs_ntrak;       /* tracks per cylinder */
+        __fs32  fs_nsect;       /* sectors per track */
+        __fs32  fs_spc;         /* sectors per cylinder */
+/* this comes from the disk driver partitioning */
+        __fs32  fs_ncyl;        /* cylinders in file system */
+/* these fields can be computed from the others */
+        __fs32  fs_cpg;         /* cylinders per group */
+        __fs32  fs_ipg;         /* inodes per cylinder group */
+        __fs32  fs_fpg;         /* blocks per group * fs_frag */
+/* this data must be re-computed after crashes */
+        struct ufs_csum fs_cstotal;     /* cylinder summary information */
+/* these fields are cleared at mount time */
+        __s8    fs_fmod;        /* super block modified flag */
+        __s8    fs_clean;       /* file system is clean flag */
+        __s8    fs_ronly;       /* mounted read-only flag */
+        __s8    fs_flags;
+        union {
+                struct {
+                        __s8    fs_fsmnt[UFS_MAXMNTLEN];/* name mounted on */
+                        __fs32  fs_cgrotor;     /* last cg searched */
+                        __fs32  fs_csp[UFS_MAXCSBUFS];/*list of fs_cs info buffers */
+                        __fs32  fs_maxcluster;
+                        __fs32  fs_cpc;         /* cyl per cycle in postbl */
+                        __fs16  fs_opostbl[16][8]; /* old rotation block list head */
+                } fs_u1;
+                struct {
+                        __s8  fs_fsmnt[UFS2_MAXMNTLEN]; /* name mounted on */
+                        __u8   fs_volname[UFS2_MAXVOLLEN]; /* volume name */
+                        __fs64  fs_swuid;               /* system-wide uid */
+                        __fs32  fs_pad; /* due to alignment of fs_swuid */
+                        __fs32   fs_cgrotor;     /* last cg searched */
+                        __fs32   fs_ocsp[UFS2_NOCSPTRS]; /*list of fs_cs info buffers */
+                        __fs32   fs_contigdirs;/*# of contiguously allocated dirs */
+                        __fs32   fs_csp;        /* cg summary info buffer for fs_cs */
+                        __fs32   fs_maxcluster;
+                        __fs32   fs_active;/* used by snapshots to track fs */
+                        __fs32   fs_old_cpc;    /* cyl per cycle in postbl */
+                        __fs32   fs_maxbsize;/*maximum blocking factor permitted */
+                        __fs64   fs_sparecon64[17];/*old rotation block list head */
+                        __fs64   fs_sblockloc; /* byte offset of standard superblock */
+                        struct  ufs2_csum_total fs_cstotal;/*cylinder summary information*/
+                        struct  ufs_timeval    fs_time;         /* last time written */
+                        __fs64    fs_size;              /* number of blocks in fs */
+                        __fs64    fs_dsize;     /* number of data blocks in fs */
+                        __fs64   fs_csaddr;     /* blk addr of cyl grp summary area */
+                        __fs64    fs_pendingblocks;/* blocks in process of being freed */
+                        __fs32    fs_pendinginodes;/*inodes in process of being freed */
+                } fs_u2;
+        }  fs_u11;
+        union {
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_state;       /* file system state time stamp */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sun;
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_npsect;      /* # sectors/track including spares */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sunx86;
+                struct {
+                        __fs32  fs_sparecon[50];/* reserved for future constants */
+                        __fs32  fs_contigsumsize;/* size of cluster summary array */
+                        __fs32  fs_maxsymlinklen;/* max length of an internal symlink */
+                        __fs32  fs_inodefmt;    /* format of on-disk inodes */
+                        __fs32  fs_maxfilesize[2];      /* max representable file size */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                        __fs32  fs_state;       /* file system state time stamp */
+                } fs_44;
+        } fs_u2;
+        __fs32  fs_postblformat;        /* format of positional layout tables */
+        __fs32  fs_nrpos;               /* number of rotational positions */
+        __fs32  fs_postbloff;           /* (__s16) rotation block list head */
+        __fs32  fs_rotbloff;            /* (__u8) blocks for each rotation */
+        __fs32  fs_magic;               /* magic number */
+        __u8    fs_space[1];            /* list of blocks for each rotation */
+};
+#endif/*struct ufs_super_block*/
+
+/*
+ * Preference for optimization.
+ */
+#define UFS_OPTTIME     0       /* minimize allocation time */
+#define UFS_OPTSPACE    1       /* minimize disk fragmentation */
+
+/*
+ * Rotational layout table format types
+ */
+#define UFS_42POSTBLFMT         -1      /* 4.2BSD rotational table format */
+#define UFS_DYNAMICPOSTBLFMT    1       /* dynamic rotational table format */
+
+/*
+ * Convert cylinder group to base address of its global summary info.
+ */
+#define fs_cs(indx) s_csp[(indx)]
+
+/*
+ * Cylinder group block for a file system.
+ *
+ * Writable fields in the cylinder group are protected by the associated
+ * super block lock fs->fs_lock.
+ */
+#define CG_MAGIC        0x090255
+#define ufs_cg_chkmagic(sb, ucg) \
+        (fs32_to_cpu((sb), (ucg)->cg_magic) == CG_MAGIC)
+/*
+ * Macros for access to old cylinder group array structures
+ */
+#define ufs_ocg_blktot(sb, ucg)      fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_btot)
+#define ufs_ocg_blks(sb, ucg, cylno) fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_b[cylno])
+#define ufs_ocg_inosused(sb, ucg)    fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_iused)
+#define ufs_ocg_blksfree(sb, ucg)    fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_free)
+#define ufs_ocg_chkmagic(sb, ucg) \
+        (fs32_to_cpu((sb), ((struct ufs_old_cylinder_group *)(ucg))->cg_magic) == CG_MAGIC)
+
+/*
+ * size of this structure is 172 B
+ */
+struct  ufs_cylinder_group {
+        __fs32  cg_link;                /* linked list of cyl groups */
+        __fs32  cg_magic;               /* magic number */
+        __fs32  cg_time;                /* time last written */
+        __fs32  cg_cgx;                 /* we are the cgx'th cylinder group */
+        __fs16  cg_ncyl;                /* number of cyl's this cg */
+        __fs16  cg_niblk;               /* number of inode blocks this cg */
+        __fs32  cg_ndblk;               /* number of data blocks this cg */
+        struct  ufs_csum cg_cs;         /* cylinder summary information */
+        __fs32  cg_rotor;               /* position of last used block */
+        __fs32  cg_frotor;              /* position of last used frag */
+        __fs32  cg_irotor;              /* position of last used inode */
+        __fs32  cg_frsum[UFS_MAXFRAG];  /* counts of available frags */
+        __fs32  cg_btotoff;             /* (__u32) block totals per cylinder */
+        __fs32  cg_boff;                /* (short) free block positions */
+        __fs32  cg_iusedoff;            /* (char) used inode map */
+        __fs32  cg_freeoff;             /* (u_char) free block map */
+        __fs32  cg_nextfreeoff;         /* (u_char) next available space */
+        union {
+                struct {
+                        __fs32  cg_clustersumoff;       /* (u_int32) counts of avail clusters */
+                        __fs32  cg_clusteroff;          /* (u_int8) free cluster map */
+                        __fs32  cg_nclusterblks;        /* number of clusters this cg */
+                        __fs32  cg_sparecon[13];        /* reserved for future use */
+                } cg_44;
+                struct {
+                        __fs32  cg_clustersumoff;/* (u_int32) counts of avail clusters */
+                        __fs32  cg_clusteroff;  /* (u_int8) free cluster map */
+                        __fs32  cg_nclusterblks;/* number of clusters this cg */
+                        __fs32   cg_niblk; /* number of inode blocks this cg */
+                        __fs32   cg_initediblk; /* last initialized inode */
+                        __fs32   cg_sparecon32[3];/* reserved for future use */
+                        __fs64   cg_time;       /* time last written */
+                        __fs64  cg_sparecon[3]; /* reserved for future use */
+                } cg_u2;
+                __fs32  cg_sparecon[16];        /* reserved for future use */
+        } cg_u;
+        __u8    cg_space[1];            /* space for cylinder group maps */
+/* actually longer */
+};
+
+/* Historic Cylinder group info */
+struct ufs_old_cylinder_group {
+        __fs32  cg_link;                /* linked list of cyl groups */
+        __fs32  cg_rlink;               /* for incore cyl groups     */
+        __fs32  cg_time;                /* time last written */
+        __fs32  cg_cgx;                 /* we are the cgx'th cylinder group */
+        __fs16  cg_ncyl;                /* number of cyl's this cg */
+        __fs16  cg_niblk;               /* number of inode blocks this cg */
+        __fs32  cg_ndblk;               /* number of data blocks this cg */
+        struct  ufs_csum cg_cs;         /* cylinder summary information */
+        __fs32  cg_rotor;               /* position of last used block */
+        __fs32  cg_frotor;              /* position of last used frag */
+        __fs32  cg_irotor;              /* position of last used inode */
+        __fs32  cg_frsum[8];            /* counts of available frags */
+        __fs32  cg_btot[32];            /* block totals per cylinder */
+        __fs16  cg_b[32][8];            /* positions of free blocks */
+        __u8    cg_iused[256];          /* used inode map */
+        __fs32  cg_magic;               /* magic number */
+        __u8    cg_free[1];             /* free block map */
+/* actually longer */
+};
+
+/*
+ * structure of an on-disk inode
+ */
+struct ufs_inode {
+        __fs16  ui_mode;                /*  0x0 */
+        __fs16  ui_nlink;               /*  0x2 */
+        union {
+                struct {
+                        __fs16  ui_suid;        /*  0x4 */
+                        __fs16  ui_sgid;        /*  0x6 */
+                } oldids;
+                __fs32  ui_inumber;             /*  0x4 lsf: inode number */
+                __fs32  ui_author;              /*  0x4 GNU HURD: author */
+        } ui_u1;
+        __fs64  ui_size;                /*  0x8 */
+        struct ufs_timeval ui_atime;    /* 0x10 access */
+        struct ufs_timeval ui_mtime;    /* 0x18 modification */
+        struct ufs_timeval ui_ctime;    /* 0x20 creation */
+        union {
+                struct {
+                        __fs32  ui_db[UFS_NDADDR];/* 0x28 data blocks */
+                        __fs32  ui_ib[UFS_NINDIR];/* 0x58 indirect blocks */
+                } ui_addr;
+                __u8    ui_symlink[4*(UFS_NDADDR+UFS_NINDIR)];/* 0x28 fast symlink */
+        } ui_u2;
+        __fs32  ui_flags;               /* 0x64 immutable, append-only... */
+        __fs32  ui_blocks;              /* 0x68 blocks in use */
+        __fs32  ui_gen;                 /* 0x6c like ext2 i_version, for NFS support */
+        union {
+                struct {
+                        __fs32  ui_shadow;      /* 0x70 shadow inode with security data */
+                        __fs32  ui_uid;         /* 0x74 long EFT version of uid */
+                        __fs32  ui_gid;         /* 0x78 long EFT version of gid */
+                        __fs32  ui_oeftflag;    /* 0x7c reserved */
+                } ui_sun;
+                struct {
+                        __fs32  ui_uid;         /* 0x70 File owner */
+                        __fs32  ui_gid;         /* 0x74 File group */
+                        __fs32  ui_spare[2];    /* 0x78 reserved */
+                } ui_44;
+                struct {
+                        __fs32  ui_uid;         /* 0x70 */
+                        __fs32  ui_gid;         /* 0x74 */
+                        __fs16  ui_modeh;       /* 0x78 mode high bits */
+                        __fs16  ui_spare;       /* 0x7A unused */
+                        __fs32  ui_trans;       /* 0x7c filesystem translator */
+                } ui_hurd;
+        } ui_u3;
+};
+
+#define UFS_NXADDR  2            /* External addresses in inode. */
+struct ufs2_inode {
+        __fs16     ui_mode;        /*   0: IFMT, permissions; see below. */
+        __fs16     ui_nlink;       /*   2: File link count. */
+        __fs32     ui_uid;         /*   4: File owner. */
+        __fs32     ui_gid;         /*   8: File group. */
+        __fs32     ui_blksize;     /*  12: Inode blocksize. */
+        __fs64     ui_size;        /*  16: File byte count. */
+        __fs64     ui_blocks;      /*  24: Bytes actually held. */
+        __fs64   ui_atime;       /*  32: Last access time. */
+        __fs64   ui_mtime;       /*  40: Last modified time. */
+        __fs64   ui_ctime;       /*  48: Last inode change time. */
+        __fs64   ui_birthtime;   /*  56: Inode creation time. */
+        __fs32     ui_mtimensec;   /*  64: Last modified time. */
+        __fs32     ui_atimensec;   /*  68: Last access time. */
+        __fs32     ui_ctimensec;   /*  72: Last inode change time. */
+        __fs32     ui_birthnsec;   /*  76: Inode creation time. */
+        __fs32     ui_gen;         /*  80: Generation number. */
+        __fs32     ui_kernflags;   /*  84: Kernel flags. */
+        __fs32     ui_flags;       /*  88: Status flags (chflags). */
+        __fs32     ui_extsize;     /*  92: External attributes block. */
+        __fs64     ui_extb[UFS_NXADDR];/*  96: External attributes block. */
+        union {
+                struct {
+                        __fs64     ui_db[UFS_NDADDR]; /* 112: Direct disk blocks. */
+                        __fs64     ui_ib[UFS_NINDIR];/* 208: Indirect disk blocks.*/
+                } ui_addr;
+        __u8    ui_symlink[2*4*(UFS_NDADDR+UFS_NINDIR)];/* 0x28 fast symlink */
+        } ui_u2;
+        __fs64     ui_spare[3];    /* 232: Reserved; currently unused */
+};
+
+
+/* FreeBSD has these in sys/stat.h */
+/* ui_flags that can be set by a file owner */
+#define UFS_UF_SETTABLE   0x0000ffff
+#define UFS_UF_NODUMP     0x00000001  /* do not dump */
+#define UFS_UF_IMMUTABLE  0x00000002  /* immutable (can't "change") */
+#define UFS_UF_APPEND     0x00000004  /* append-only */
+#define UFS_UF_OPAQUE     0x00000008  /* directory is opaque (unionfs) */
+#define UFS_UF_NOUNLINK   0x00000010  /* can't be removed or renamed */
+/* ui_flags that only root can set */
+#define UFS_SF_SETTABLE   0xffff0000
+#define UFS_SF_ARCHIVED   0x00010000  /* archived */
+#define UFS_SF_IMMUTABLE  0x00020000  /* immutable (can't "change") */
+#define UFS_SF_APPEND     0x00040000  /* append-only */
+#define UFS_SF_NOUNLINK   0x00100000  /* can't be removed or renamed */
+
+/*
+ * This structure is used for reading disk structures larger
+ * than the size of fragment.
+ */
+struct ufs_buffer_head {
+        __u64 fragment;                 /* first fragment */
+        __u64 count;                            /* number of fragments */
+        struct buffer_head * bh[UFS_MAXFRAG];   /* buffers */
+};
+
+struct ufs_cg_private_info {
+        struct ufs_buffer_head c_ubh;
+        __u32   c_cgx;          /* number of cylidner group */
+        __u16   c_ncyl;         /* number of cyl's this cg */
+        __u16   c_niblk;        /* number of inode blocks this cg */
+        __u32   c_ndblk;        /* number of data blocks this cg */
+        __u32   c_rotor;        /* position of last used block */
+        __u32   c_frotor;       /* position of last used frag */
+        __u32   c_irotor;       /* position of last used inode */
+        __u32   c_btotoff;      /* (__u32) block totals per cylinder */
+        __u32   c_boff;         /* (short) free block positions */
+        __u32   c_iusedoff;     /* (char) used inode map */
+        __u32   c_freeoff;      /* (u_char) free block map */
+        __u32   c_nextfreeoff;  /* (u_char) next available space */
+        __u32   c_clustersumoff;/* (u_int32) counts of avail clusters */
+        __u32   c_clusteroff;   /* (u_int8) free cluster map */
+        __u32   c_nclusterblks; /* number of clusters this cg */
+};
+
+
+struct ufs_sb_private_info {
+        struct ufs_buffer_head s_ubh; /* buffer containing super block */
+        struct ufs_csum_core cs_total;
+        __u32   s_sblkno;       /* offset of super-blocks in filesys */
+        __u32   s_cblkno;       /* offset of cg-block in filesys */
+        __u32   s_iblkno;       /* offset of inode-blocks in filesys */
+        __u32   s_dblkno;       /* offset of first data after cg */
+        __u32   s_cgoffset;     /* cylinder group offset in cylinder */
+        __u32   s_cgmask;       /* used to calc mod fs_ntrak */
+        __u32   s_size;         /* number of blocks (fragments) in fs */
+        __u32   s_dsize;        /* number of data blocks in fs */
+        __u64   s_u2_size;      /* ufs2: number of blocks (fragments) in fs */
+        __u64   s_u2_dsize;     /*ufs2:  number of data blocks in fs */
+        __u32   s_ncg;          /* number of cylinder groups */
+        __u32   s_bsize;        /* size of basic blocks */
+        __u32   s_fsize;        /* size of fragments */
+        __u32   s_fpb;          /* fragments per block */
+        __u32   s_minfree;      /* minimum percentage of free blocks */
+        __u32   s_bmask;        /* `blkoff'' calc of blk offsets */
+        __u32   s_fmask;        /* s_fsize mask */
+        __u32   s_bshift;       /* `lblkno'' calc of logical blkno */
+        __u32   s_fshift;       /* s_fsize shift */
+        __u32   s_fpbshift;     /* fragments per block shift */
+        __u32   s_fsbtodb;      /* fsbtodb and dbtofsb shift constant */
+        __u32   s_sbsize;       /* actual size of super block */
+        __u32   s_csmask;       /* csum block offset */
+        __u32   s_csshift;      /* csum block number */
+        __u32   s_nindir;       /* value of NINDIR */
+        __u32   s_inopb;        /* value of INOPB */
+        __u32   s_nspf;         /* value of NSPF */
+        __u32   s_npsect;       /* # sectors/track including spares */
+        __u32   s_interleave;   /* hardware sector interleave */
+        __u32   s_trackskew;    /* sector 0 skew, per track */
+        __u64   s_csaddr;       /* blk addr of cyl grp summary area */
+        __u32   s_cssize;       /* size of cyl grp summary area */
+        __u32   s_cgsize;       /* cylinder group size */
+        __u32   s_ntrak;        /* tracks per cylinder */
+        __u32   s_nsect;        /* sectors per track */
+        __u32   s_spc;          /* sectors per cylinder */
+        __u32   s_ipg;          /* inodes per cylinder group */
+        __u32   s_fpg;          /* fragments per group */
+        __u32   s_cpc;          /* cyl per cycle in postbl */
+        __s32   s_contigsumsize;/* size of cluster summary array, 44bsd */
+        __s64   s_qbmask;       /* ~usb_bmask */
+        __s64   s_qfmask;       /* ~usb_fmask */
+        __s32   s_postblformat; /* format of positional layout tables */
+        __s32   s_nrpos;        /* number of rotational positions */
+        __s32   s_postbloff;    /* (__s16) rotation block list head */
+        __s32   s_rotbloff;     /* (__u8) blocks for each rotation */
+
+        __u32   s_fpbmask;      /* fragments per block mask */
+        __u32   s_apb;          /* address per block */
+        __u32   s_2apb;         /* address per block^2 */
+        __u32   s_3apb;         /* address per block^3 */
+        __u32   s_apbmask;      /* address per block mask */
+        __u32   s_apbshift;     /* address per block shift */
+        __u32   s_2apbshift;    /* address per block shift * 2 */
+        __u32   s_3apbshift;    /* address per block shift * 3 */
+        __u32   s_nspfshift;    /* number of sector per fragment shift */
+        __u32   s_nspb;         /* number of sector per block */
+        __u32   s_inopf;        /* inodes per fragment */
+        __u32   s_sbbase;       /* offset of NeXTstep superblock */
+        __u32   s_bpf;          /* bits per fragment */
+        __u32   s_bpfshift;     /* bits per fragment shift*/
+        __u32   s_bpfmask;      /* bits per fragment mask */
+
+        __u32   s_maxsymlinklen;/* upper limit on fast symlinks' size */
+        __s32   fs_magic;       /* filesystem magic */
+        unsigned int s_dirblksize;
+};
+
+/*
+ * Sizes of this structures are:
+ *      ufs_super_block_first   512
+ *      ufs_super_block_second  512
+ *      ufs_super_block_third   356
+ */
+struct ufs_super_block_first {
+        union {
+                struct {
+                        __fs32  fs_link;        /* UNUSED */
+                } fs_42;
+                struct {
+                        __fs32  fs_state;       /* file system state flag */
+                } fs_sun;
+        } fs_u0;
+        __fs32  fs_rlink;
+        __fs32  fs_sblkno;
+        __fs32  fs_cblkno;
+        __fs32  fs_iblkno;
+        __fs32  fs_dblkno;
+        __fs32  fs_cgoffset;
+        __fs32  fs_cgmask;
+        __fs32  fs_time;
+        __fs32  fs_size;
+        __fs32  fs_dsize;
+        __fs32  fs_ncg;
+        __fs32  fs_bsize;
+        __fs32  fs_fsize;
+        __fs32  fs_frag;
+        __fs32  fs_minfree;
+        __fs32  fs_rotdelay;
+        __fs32  fs_rps;
+        __fs32  fs_bmask;
+        __fs32  fs_fmask;
+        __fs32  fs_bshift;
+        __fs32  fs_fshift;
+        __fs32  fs_maxcontig;
+        __fs32  fs_maxbpg;
+        __fs32  fs_fragshift;
+        __fs32  fs_fsbtodb;
+        __fs32  fs_sbsize;
+        __fs32  fs_csmask;
+        __fs32  fs_csshift;
+        __fs32  fs_nindir;
+        __fs32  fs_inopb;
+        __fs32  fs_nspf;
+        __fs32  fs_optim;
+        union {
+                struct {
+                        __fs32  fs_npsect;
+                } fs_sun;
+                struct {
+                        __fs32  fs_state;
+                } fs_sunx86;
+        } fs_u1;
+        __fs32  fs_interleave;
+        __fs32  fs_trackskew;
+        __fs32  fs_id[2];
+        __fs32  fs_csaddr;
+        __fs32  fs_cssize;
+        __fs32  fs_cgsize;
+        __fs32  fs_ntrak;
+        __fs32  fs_nsect;
+        __fs32  fs_spc;
+        __fs32  fs_ncyl;
+        __fs32  fs_cpg;
+        __fs32  fs_ipg;
+        __fs32  fs_fpg;
+        struct ufs_csum fs_cstotal;
+        __s8    fs_fmod;
+        __s8    fs_clean;
+        __s8    fs_ronly;
+        __s8    fs_flags;
+        __s8    fs_fsmnt[UFS_MAXMNTLEN - 212];
+
+};
+
+struct ufs_super_block_second {
+        union {
+                struct {
+                        __s8    fs_fsmnt[212];
+                        __fs32  fs_cgrotor;
+                        __fs32  fs_csp[UFS_MAXCSBUFS];
+                        __fs32  fs_maxcluster;
+                        __fs32  fs_cpc;
+                        __fs16  fs_opostbl[82];
+                } fs_u1;
+                struct {
+                        __s8  fs_fsmnt[UFS2_MAXMNTLEN - UFS_MAXMNTLEN + 212];
+                        __u8   fs_volname[UFS2_MAXVOLLEN];
+                        __fs64  fs_swuid;
+                        __fs32  fs_pad;
+                        __fs32   fs_cgrotor;
+                        __fs32   fs_ocsp[UFS2_NOCSPTRS];
+                        __fs32   fs_contigdirs;
+                        __fs32   fs_csp;
+                        __fs32   fs_maxcluster;
+                        __fs32   fs_active;
+                        __fs32   fs_old_cpc;
+                        __fs32   fs_maxbsize;
+                        __fs64   fs_sparecon64[17];
+                        __fs64   fs_sblockloc;
+                        __fs64  cs_ndir;
+                        __fs64  cs_nbfree;
+                } fs_u2;
+        } fs_un;
+};
+
+struct ufs_super_block_third {
+        union {
+                struct {
+                        __fs16  fs_opostbl[46];
+                } fs_u1;
+                struct {
+                        __fs64  cs_nifree;      /* number of free inodes */
+                        __fs64  cs_nffree;      /* number of free frags */
+                        __fs64   cs_numclusters;        /* number of free clusters */
+                        __fs64   cs_spare[3];   /* future expansion */
+                        struct  ufs_timeval    fs_time;         /* last time written */
+                        __fs64    fs_size;              /* number of blocks in fs */
+                        __fs64    fs_dsize;     /* number of data blocks in fs */
+                        __fs64   fs_csaddr;     /* blk addr of cyl grp summary area */
+                        __fs64    fs_pendingblocks;/* blocks in process of being freed */
+                        __fs32    fs_pendinginodes;/*inodes in process of being freed */
+                } __attribute__ ((packed)) fs_u2;
+        } fs_un1;
+        union {
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_state;       /* file system state time stamp */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sun;
+                struct {
+                        __fs32  fs_sparecon[53];/* reserved for future constants */
+                        __fs32  fs_reclaim;
+                        __fs32  fs_sparecon2[1];
+                        __fs32  fs_npsect;      /* # sectors/track including spares */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                } fs_sunx86;
+                struct {
+                        __fs32  fs_sparecon[50];/* reserved for future constants */
+                        __fs32  fs_contigsumsize;/* size of cluster summary array */
+                        __fs32  fs_maxsymlinklen;/* max length of an internal symlink */
+                        __fs32  fs_inodefmt;    /* format of on-disk inodes */
+                        __fs32  fs_maxfilesize[2];      /* max representable file size */
+                        __fs32  fs_qbmask[2];   /* ~usb_bmask */
+                        __fs32  fs_qfmask[2];   /* ~usb_fmask */
+                        __fs32  fs_state;       /* file system state time stamp */
+                } fs_44;
+        } fs_un2;
+        __fs32  fs_postblformat;
+        __fs32  fs_nrpos;
+        __fs32  fs_postbloff;
+        __fs32  fs_rotbloff;
+        __fs32  fs_magic;
+        __u8    fs_space[1];
+};
+
+#endif /* __LINUX_UFS_FS_H */
diff --git a/fs/ufs/util.c b/fs/ufs/util.c
index 410084dae389..85a7fc9e4a4e 100644
--- a/fs/ufs/util.c
+++ b/fs/ufs/util.c
@@ -8,9 +8,9 @@
  
 #include <linux/string.h>
 #include <linux/slab.h>
-#include <linux/ufs_fs.h>
 #include <linux/buffer_head.h>
 
+#include "ufs_fs.h"
 #include "ufs.h"
 #include "swab.h"
 #include "util.h"