171 files changed, 3090 insertions, 1838 deletions
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index bed48fa96521..3128aa948a4e 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -29,7 +29,6 @@
 #include <linux/file.h>
 #include <linux/stat.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/inet.h>
 #include <linux/pagemap.h>
 #include <linux/idr.h>
diff --git a/fs/9p/vfs_dentry.c b/fs/9p/vfs_dentry.c
index ddffd8aa902d..775e26e82cbc 100644
--- a/fs/9p/vfs_dentry.c
+++ b/fs/9p/vfs_dentry.c
@@ -30,7 +30,6 @@
 #include <linux/pagemap.h>
 #include <linux/stat.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/inet.h>
 #include <linux/namei.h>
 #include <linux/idr.h>
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index 3129688143ea..1dd86ee90bc5 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -29,7 +29,6 @@
 #include <linux/file.h>
 #include <linux/stat.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/sched.h>
 #include <linux/inet.h>
 #include <linux/idr.h>
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index c7b677253843..6e7678e4852f 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -30,7 +30,6 @@
 #include <linux/file.h>
 #include <linux/stat.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/inet.h>
 #include <linux/list.h>
 #include <asm/uaccess.h>
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index b01b0a457932..7624821729a0 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -30,7 +30,6 @@
 #include <linux/pagemap.h>
 #include <linux/stat.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/inet.h>
 #include <linux/namei.h>
 #include <linux/idr.h>
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index 0ec42f665457..8eb9263a67b9 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -31,7 +31,6 @@
 #include <linux/file.h>
 #include <linux/stat.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/inet.h>
 #include <linux/pagemap.h>
 #include <linux/seq_file.h>
diff --git a/fs/Kconfig b/fs/Kconfig
index 8ea7b04c661f..4622dabb2253 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -314,7 +314,7 @@ config REISERFS_CHECK
 config REISERFS_PROC_INFO
        bool "Stats in /proc/fs/reiserfs"
-        depends on REISERFS_FS
+        depends on REISERFS_FS && PROC_FS
        help
          Create under /proc/fs/reiserfs a hierarchy of files, displaying
          various ReiserFS statistics and internal data at the expense of
diff --git a/fs/attr.c b/fs/attr.c
index 97de94670878..a0a0c7b07ba3 100644
--- a/fs/attr.c
+++ b/fs/attr.c
@@ -9,7 +9,6 @@
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/capability.h>
 #include <linux/fsnotify.h>
 #include <linux/fcntl.h>
diff --git a/fs/autofs4/inode.c b/fs/autofs4/inode.c
index 26063dc84a2a..5769a2f9ad60 100644
--- a/fs/autofs4/inode.c
+++ b/fs/autofs4/inode.c
@@ -18,7 +18,6 @@
 #include <linux/pagemap.h>
 #include <linux/parser.h>
 #include <linux/bitops.h>
-#include <linux/smp_lock.h>
 #include <linux/magic.h>
 #include "autofs_i.h"
 #include <linux/module.h>
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index d0e9b3a3905d..15170f4e13a7 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -17,7 +17,6 @@
 #include <linux/stat.h>
 #include <linux/param.h>
 #include <linux/time.h>
-#include <linux/smp_lock.h>
 #include "autofs_i.h"
 static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
diff --git a/fs/bad_inode.c b/fs/bad_inode.c
index efeab2fab40b..329ee473eede 100644
--- a/fs/bad_inode.c
+++ b/fs/bad_inode.c
@@ -12,7 +12,6 @@
 #include <linux/module.h>
 #include <linux/stat.h>
 #include <linux/time.h>
-#include <linux/smp_lock.h>
 #include <linux/namei.h>
 #include <linux/poll.h>
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 9cc4f0a8aaae..fa8ea33ab0be 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -31,7 +31,6 @@
 #include <linux/init.h>
 #include <linux/highuid.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/compiler.h>
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
@@ -39,6 +38,7 @@
 #include <linux/syscalls.h>
 #include <linux/random.h>
 #include <linux/elf.h>
+#include <linux/utsname.h>
 #include <asm/uaccess.h>
 #include <asm/param.h>
 #include <asm/page.h>
@@ -871,6 +871,8 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                                elf_prot, elf_flags);
                if (BAD_ADDR(error)) {
                        send_sig(SIGKILL, current, 0);
+                        retval = IS_ERR((void *)error) ?
+                                PTR_ERR((void*)error) : -EINVAL;
                        goto out_free_dentry;
                }
@@ -900,6 +902,7 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                    TASK_SIZE - elf_ppnt->p_memsz < k) {
                        /* set_brk can never work. Avoid overflows. */
                        send_sig(SIGKILL, current, 0);
+                        retval = -EINVAL;
                        goto out_free_dentry;
                }
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index f3ddca4a387b..9d62fbad3d4b 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -30,7 +30,6 @@
 #include <linux/personality.h>
 #include <linux/ptrace.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/elf.h>
 #include <linux/elf-fdpic.h>
 #include <linux/elfcore.h>
diff --git a/fs/binfmt_em86.c b/fs/binfmt_em86.c
index 1f2d1ad63319..576dd7de2278 100644
--- a/fs/binfmt_em86.c
+++ b/fs/binfmt_em86.c
@@ -12,7 +12,6 @@
 #include <linux/string.h>
 #include <linux/stat.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/binfmts.h>
 #include <linux/elf.h>
 #include <linux/init.h>
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index e6f57990b121..18657f001b43 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -727,8 +727,8 @@ static const struct super_operations s_ops = {
 static int bm_fill_super(struct super_block * sb, void * data, int silent)
 {
        static struct tree_descr bm_files[] = {
-                [1] = {"status", &bm_status_operations, S_IWUSR|S_IRUGO},
+                [2] = {"status", &bm_status_operations, S_IWUSR|S_IRUGO},
-                [2] = {"register", &bm_register_operations, S_IWUSR},
+                [3] = {"register", &bm_register_operations, S_IWUSR},
                /* last one */ {""}
        };
        int err = simple_fill_super(sb, 0x42494e4d, bm_files);
diff --git a/fs/binfmt_script.c b/fs/binfmt_script.c
index 1edbcca25a73..304c88544d89 100644
--- a/fs/binfmt_script.c
+++ b/fs/binfmt_script.c
@@ -12,7 +12,6 @@
 #include <linux/binfmts.h>
 #include <linux/init.h>
 #include <linux/file.h>
-#include <linux/smp_lock.h>
 #include <linux/err.h>
 #include <linux/fs.h>
diff --git a/fs/block_dev.c b/fs/block_dev.c
index f02b7bdd9864..742899240872 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -22,6 +22,7 @@
 #include <linux/mount.h>
 #include <linux/uio.h>
 #include <linux/namei.h>
+#include <linux/log2.h>
 #include <asm/uaccess.h>
 #include "internal.h"
@@ -67,7 +68,7 @@ static void kill_bdev(struct block_device *bdev)
 int set_blocksize(struct block_device *bdev, int size)
 {
        /* Size must be a power of two, and between 512 and PAGE_SIZE */
-        if (size > PAGE_SIZE || size < 512 || (size & (size-1)))
+        if (size > PAGE_SIZE || size < 512 || !is_power_of_2(size))
                return -EINVAL;
        /* Size cannot be smaller than the size supported by the device */
diff --git a/fs/buffer.c b/fs/buffer.c
index 7db24b9e5449..eb820b82a636 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -24,7 +24,6 @@
 #include <linux/mm.h>
 #include <linux/percpu.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/capability.h>
 #include <linux/blkdev.h>
 #include <linux/file.h>
@@ -1727,6 +1726,7 @@ recover:
        } while ((bh = bh->b_this_page) != head);
        SetPageError(page);
        BUG_ON(PageWriteback(page));
+        mapping_set_error(page->mapping, err);
        set_page_writeback(page);
        do {
                struct buffer_head *next = bh->b_this_page;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index b570530f97bf..94d5b49049df 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -27,7 +27,6 @@
 #include <linux/fcntl.h>
 #include <linux/pagemap.h>
 #include <linux/pagevec.h>
-#include <linux/smp_lock.h>
 #include <linux/writeback.h>
 #include <linux/task_io_accounting_ops.h>
 #include <linux/delay.h>
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index b5364f90d551..c08bda9fcac6 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -23,7 +23,6 @@
 #include <linux/fs.h>
 #include <linux/pagemap.h>
 #include <linux/stat.h>
-#include <linux/smp_lock.h>
 #include "cifspdu.h"
 #include "cifsglob.h"
 #include "cifsproto.h"
diff --git a/fs/compat.c b/fs/compat.c
index 72e5e6923828..9cf75df9b2bb 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -15,6 +15,7 @@
 *  published by the Free Software Foundation.
 */
+#include <linux/kernel.h>
 #include <linux/linkage.h>
 #include <linux/compat.h>
 #include <linux/errno.h>
@@ -24,10 +25,8 @@
 #include <linux/namei.h>
 #include <linux/file.h>
 #include <linux/vfs.h>
-#include <linux/ioctl32.h>
 #include <linux/ioctl.h>
 #include <linux/init.h>
-#include <linux/sockios.h>      /* for SIOCDEVPRIVATE */
 #include <linux/smb.h>
 #include <linux/smb_mount.h>
 #include <linux/ncp_mount.h>
@@ -45,13 +44,12 @@
 #include <linux/personality.h>
 #include <linux/rwsem.h>
 #include <linux/tsacct_kern.h>
+#include <linux/security.h>
 #include <linux/highmem.h>
 #include <linux/poll.h>
 #include <linux/mm.h>
 #include <linux/eventpoll.h>
-#include <net/sock.h>           /* siocdevprivate_ioctl */
 #include <asm/uaccess.h>
 #include <asm/mmu_context.h>
 #include <asm/ioctls.h>
@@ -79,30 +77,57 @@ int compat_printk(const char *fmt, ...)
 */
 asmlinkage long compat_sys_utime(char __user *filename, struct compat_utimbuf __user *t)
 {
-        struct timeval tv[2];
+        struct timespec tv[2];
        if (t) {
                if (get_user(tv[0].tv_sec, &t->actime) ||
                    get_user(tv[1].tv_sec, &t->modtime))
                        return -EFAULT;
-                tv[0].tv_usec = 0;
+                tv[0].tv_nsec = 0;
-                tv[1].tv_usec = 0;
+                tv[1].tv_nsec = 0;
+        }
+        return do_utimes(AT_FDCWD, filename, t ? tv : NULL, 0);
+}
+asmlinkage long compat_sys_utimensat(unsigned int dfd, char __user *filename, struct compat_timespec __user *t, int flags)
+{
+        struct timespec tv[2];
+        if  (t) {
+                if (get_compat_timespec(&tv[0], &t[0]) ||
+                    get_compat_timespec(&tv[1], &t[1]))
+                        return -EFAULT;
+                if ((tv[0].tv_nsec == UTIME_OMIT || tv[0].tv_nsec == UTIME_NOW)
+                    && tv[0].tv_sec != 0)
+                        return -EINVAL;
+                if ((tv[1].tv_nsec == UTIME_OMIT || tv[1].tv_nsec == UTIME_NOW)
+                    && tv[1].tv_sec != 0)
+                        return -EINVAL;
+                if (tv[0].tv_nsec == UTIME_OMIT && tv[1].tv_nsec == UTIME_OMIT)
+                        return 0;
        }
-        return do_utimes(AT_FDCWD, filename, t ? tv : NULL);
+        return do_utimes(dfd, filename, t ? tv : NULL, flags);
 }
 asmlinkage long compat_sys_futimesat(unsigned int dfd, char __user *filename, struct compat_timeval __user *t)
 {
-        struct timeval tv[2];
+        struct timespec tv[2];
        if (t) {
                if (get_user(tv[0].tv_sec, &t[0].tv_sec) ||
-                    get_user(tv[0].tv_usec, &t[0].tv_usec) ||
+                    get_user(tv[0].tv_nsec, &t[0].tv_usec) ||
                    get_user(tv[1].tv_sec, &t[1].tv_sec) ||
-                    get_user(tv[1].tv_usec, &t[1].tv_usec))
+                    get_user(tv[1].tv_nsec, &t[1].tv_usec))
                        return -EFAULT;
+                if (tv[0].tv_nsec >= 1000000 || tv[0].tv_nsec < 0 ||
+                    tv[1].tv_nsec >= 1000000 || tv[1].tv_nsec < 0)
+                        return -EINVAL;
+                tv[0].tv_nsec *= 1000;
+                tv[1].tv_nsec *= 1000;
        }
-        return do_utimes(dfd, filename, t ? tv : NULL);
+        return do_utimes(dfd, filename, t ? tv : NULL, 0);
 }
 asmlinkage long compat_sys_utimes(char __user *filename, struct compat_timeval __user *t)
@@ -312,163 +337,6 @@ out:
        return error;
 }
-/* ioctl32 stuff, used by sparc64, parisc, s390x, ppc64, x86_64, MIPS */
-#define IOCTL_HASHSIZE 256
-static struct ioctl_trans *ioctl32_hash_table[IOCTL_HASHSIZE];
-static inline unsigned long ioctl32_hash(unsigned long cmd)
-{
-        return (((cmd >> 6) ^ (cmd >> 4) ^ cmd)) % IOCTL_HASHSIZE;
-}
-static void ioctl32_insert_translation(struct ioctl_trans *trans)
-{
-        unsigned long hash;
-        struct ioctl_trans *t;
-        hash = ioctl32_hash (trans->cmd);
-        if (!ioctl32_hash_table[hash])
-                ioctl32_hash_table[hash] = trans;
-        else {
-                t = ioctl32_hash_table[hash];
-                while (t->next)
-                        t = t->next;
-                trans->next = NULL;
-                t->next = trans;
-        }
-}
-static int __init init_sys32_ioctl(void)
-{
-        int i;
-        for (i = 0; i < ioctl_table_size; i++) {
-                if (ioctl_start[i].next != 0) { 
-                        printk("ioctl translation %d bad\n",i); 
-                        return -1;
-                }
-                ioctl32_insert_translation(&ioctl_start[i]);
-        }
-        return 0;
-}
-__initcall(init_sys32_ioctl);
-static void compat_ioctl_error(struct file *filp, unsigned int fd,
-                unsigned int cmd, unsigned long arg)
-{
-        char buf[10];
-        char *fn = "?";
-        char *path;
-        /* find the name of the device. */
-        path = (char *)__get_free_page(GFP_KERNEL);
-        if (path) {
-                fn = d_path(filp->f_path.dentry, filp->f_path.mnt, path, PAGE_SIZE);
-                if (IS_ERR(fn))
-                        fn = "?";
-        }
-        sprintf(buf,"'%c'", (cmd>>_IOC_TYPESHIFT) & _IOC_TYPEMASK);
-        if (!isprint(buf[1]))
-                sprintf(buf, "%02x", buf[1]);
-        compat_printk("ioctl32(%s:%d): Unknown cmd fd(%d) "
-                        "cmd(%08x){t:%s;sz:%u} arg(%08x) on %s\n",
-                        current->comm, current->pid,
-                        (int)fd, (unsigned int)cmd, buf,
-                        (cmd >> _IOC_SIZESHIFT) & _IOC_SIZEMASK,
-                        (unsigned int)arg, fn);
-        if (path)
-                free_page((unsigned long)path);
-}
-asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
-                                unsigned long arg)
-{
-        struct file *filp;
-        int error = -EBADF;
-        struct ioctl_trans *t;
-        int fput_needed;
-        filp = fget_light(fd, &fput_needed);
-        if (!filp)
-                goto out;
-        /* RED-PEN how should LSM module know it's handling 32bit? */
-        error = security_file_ioctl(filp, cmd, arg);
-        if (error)
-                goto out_fput;
-        /*
-         * To allow the compat_ioctl handlers to be self contained
-         * we need to check the common ioctls here first.
-         * Just handle them with the standard handlers below.
-         */
-        switch (cmd) {
-        case FIOCLEX:
-        case FIONCLEX:
-        case FIONBIO:
-        case FIOASYNC:
-        case FIOQSIZE:
-                break;
-        case FIBMAP:
-        case FIGETBSZ:
-        case FIONREAD:
-                if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
-                        break;
-                /*FALL THROUGH*/
-        default:
-                if (filp->f_op && filp->f_op->compat_ioctl) {
-                        error = filp->f_op->compat_ioctl(filp, cmd, arg);
-                        if (error != -ENOIOCTLCMD)
-                                goto out_fput;
-                }
-                if (!filp->f_op ||
-                    (!filp->f_op->ioctl && !filp->f_op->unlocked_ioctl))
-                        goto do_ioctl;
-                break;
-        }
-        for (t = ioctl32_hash_table[ioctl32_hash(cmd)]; t; t = t->next) {
-                if (t->cmd == cmd)
-                        goto found_handler;
-        }
-        if (S_ISSOCK(filp->f_path.dentry->d_inode->i_mode) &&
-            cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
-                error = siocdevprivate_ioctl(fd, cmd, arg);
-        } else {
-                static int count;
-                if (++count <= 50)
-                        compat_ioctl_error(filp, fd, cmd, arg);
-                error = -EINVAL;
-        }
-        goto out_fput;
- found_handler:
-        if (t->handler) {
-                lock_kernel();
-                error = t->handler(fd, cmd, arg, filp);
-                unlock_kernel();
-                goto out_fput;
-        }
- do_ioctl:
-        error = vfs_ioctl(filp, fd, cmd, arg);
- out_fput:
-        fput_light(filp, fput_needed);
- out:
-        return error;
-}
 static int get_compat_flock(struct flock *kfl, struct compat_flock __user *ufl)
 {
        if (!access_ok(VERIFY_READ, ufl, sizeof(*ufl)) ||
@@ -902,8 +770,6 @@ asmlinkage long compat_sys_mount(char __user * dev_name, char __user * dir_name,
 }
 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
-#define COMPAT_ROUND_UP(x) (((x)+sizeof(compat_long_t)-1) & \
-                                ~(sizeof(compat_long_t)-1))
 struct compat_old_linux_dirent {
        compat_ulong_t  d_ino;
@@ -991,7 +857,7 @@ static int compat_filldir(void *__buf, const char *name, int namlen,
        struct compat_linux_dirent __user * dirent;
        struct compat_getdents_callback *buf = __buf;
        compat_ulong_t d_ino;
-        int reclen = COMPAT_ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
+        int reclen = ALIGN(NAME_OFFSET(dirent) + namlen + 2, sizeof(compat_long_t));
        buf->error = -EINVAL;   /* only used if we fail.. */
        if (reclen > buf->count)
@@ -1066,7 +932,6 @@ out:
 }
 #ifndef __ARCH_OMIT_COMPAT_SYS_GETDENTS64
-#define COMPAT_ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
 struct compat_getdents_callback64 {
        struct linux_dirent64 __user *current_dir;
@@ -1081,7 +946,7 @@ static int compat_filldir64(void * __buf, const char * name, int namlen, loff_t
        struct linux_dirent64 __user *dirent;
        struct compat_getdents_callback64 *buf = __buf;
        int jj = NAME_OFFSET(dirent);
-        int reclen = COMPAT_ROUND_UP64(jj + namlen + 1);
+        int reclen = ALIGN(jj + namlen + 1, sizeof(u64));
        u64 off;
        buf->error = -EINVAL;   /* only used if we fail.. */
@@ -1594,8 +1459,6 @@ out_ret:
 #define __COMPAT_NFDBITS       (8 * sizeof(compat_ulong_t))
-#define ROUND_UP(x,y) (((x)+(y)-1)/(y))
 /*
 * Ooo, nasty.  We need here to frob 32-bit unsigned longs to
 * 64-bit unsigned longs.
@@ -1604,7 +1467,7 @@ static
 int compat_get_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
                        unsigned long *fdset)
 {
-        nr = ROUND_UP(nr, __COMPAT_NFDBITS);
+        nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS);
        if (ufdset) {
                unsigned long odd;
@@ -1638,7 +1501,7 @@ int compat_set_fd_set(unsigned long nr, compat_ulong_t __user *ufdset,
                      unsigned long *fdset)
 {
        unsigned long odd;
-        nr = ROUND_UP(nr, __COMPAT_NFDBITS);
+        nr = DIV_ROUND_UP(nr, __COMPAT_NFDBITS);
        if (!ufdset)
                return 0;
@@ -1760,7 +1623,7 @@ asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
                if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
                        timeout = -1;   /* infinite */
                else {
-                        timeout = ROUND_UP(tv.tv_usec, 1000000/HZ);
+                        timeout = DIV_ROUND_UP(tv.tv_usec, 1000000/HZ);
                        timeout += tv.tv_sec * HZ;
                }
        }
@@ -1828,7 +1691,7 @@ asmlinkage long compat_sys_pselect7(int n, compat_ulong_t __user *inp,
        do {
                if (tsp) {
                        if ((unsigned long)ts.tv_sec < MAX_SELECT_SECONDS) {
-                                timeout = ROUND_UP(ts.tv_nsec, 1000000000/HZ);
+                                timeout = DIV_ROUND_UP(ts.tv_nsec, 1000000000/HZ);
                                timeout += ts.tv_sec * (unsigned long)HZ;
                                ts.tv_sec = 0;
                                ts.tv_nsec = 0;
@@ -1924,7 +1787,7 @@ asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
                /* We assume that ts.tv_sec is always lower than
                   the number of seconds that can be expressed in
                   an s64. Otherwise the compiler bitches at us */
-                timeout = ROUND_UP(ts.tv_nsec, 1000000000/HZ);
+                timeout = DIV_ROUND_UP(ts.tv_nsec, 1000000000/HZ);
                timeout += ts.tv_sec * HZ;
        }
diff --git a/fs/compat_ioctl.c b/fs/compat_ioctl.c
index 464c04a9541d..d92bc3eb7afc 100644
--- a/fs/compat_ioctl.c
+++ b/fs/compat_ioctl.c
@@ -17,7 +17,6 @@
 #include <linux/compiler.h>
 #include <linux/sched.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/ioctl.h>
 #include <linux/if.h>
 #include <linux/if_bridge.h>
@@ -58,7 +57,6 @@
 #include <linux/serial.h>
 #include <linux/if_tun.h>
 #include <linux/ctype.h>
-#include <linux/ioctl32.h>
 #include <linux/syscalls.h>
 #include <linux/i2c.h>
 #include <linux/i2c-dev.h>
@@ -66,7 +64,6 @@
 #include <linux/atalk.h>
 #include <linux/blktrace_api.h>
-#include <net/sock.h>          /* siocdevprivate_ioctl */
 #include <net/bluetooth/bluetooth.h>
 #include <net/bluetooth/hci.h>
 #include <net/bluetooth/rfcomm.h>
@@ -475,7 +472,7 @@ static int bond_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
        };
 }
-int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
+static int siocdevprivate_ioctl(unsigned int fd, unsigned int cmd, unsigned long arg)
 {
        struct ifreq __user *u_ifreq64;
        struct ifreq32 __user *u_ifreq32 = compat_ptr(arg);
@@ -687,8 +684,10 @@ static int hdio_getgeo(unsigned int fd, unsigned int cmd, unsigned long arg)
        if (!err) {
                err = copy_to_user (ugeo, &geo, 4);
                err |= __put_user (geo.start, &ugeo->start);
+                if (err)
+                        err = -EFAULT;
        }
-        return err ? -EFAULT : 0;
+        return err;
 }
 static int hdio_ioctl_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
@@ -2385,6 +2384,16 @@ lp_timeout_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
        return sys_ioctl(fd, cmd, (unsigned long)tn);
 }
+typedef int (*ioctl_trans_handler_t)(unsigned int, unsigned int,
+                                        unsigned long, struct file *);
+struct ioctl_trans {
+        unsigned long cmd;
+        ioctl_trans_handler_t handler;
+        struct ioctl_trans *next;
+};
 #define HANDLE_IOCTL(cmd,handler) \
        { (cmd), (ioctl_trans_handler_t)(handler) },
@@ -2405,8 +2414,835 @@ lp_timeout_trans(unsigned int fd, unsigned int cmd, unsigned long arg)
   Most other reasons are not valid. */
 #define IGNORE_IOCTL(cmd) COMPATIBLE_IOCTL(cmd)
-struct ioctl_trans ioctl_start[] = {
+static struct ioctl_trans ioctl_start[] = {
-#include <linux/compat_ioctl.h>
+/* compatible ioctls first */
+COMPATIBLE_IOCTL(0x4B50)   /* KDGHWCLK - not in the kernel, but don't complain */
+COMPATIBLE_IOCTL(0x4B51)   /* KDSHWCLK - not in the kernel, but don't complain */
+/* Big T */
+COMPATIBLE_IOCTL(TCGETA)
+COMPATIBLE_IOCTL(TCSETA)
+COMPATIBLE_IOCTL(TCSETAW)
+COMPATIBLE_IOCTL(TCSETAF)
+COMPATIBLE_IOCTL(TCSBRK)
+ULONG_IOCTL(TCSBRKP)
+COMPATIBLE_IOCTL(TCXONC)
+COMPATIBLE_IOCTL(TCFLSH)
+COMPATIBLE_IOCTL(TCGETS)
+COMPATIBLE_IOCTL(TCSETS)
+COMPATIBLE_IOCTL(TCSETSW)
+COMPATIBLE_IOCTL(TCSETSF)
+COMPATIBLE_IOCTL(TIOCLINUX)
+COMPATIBLE_IOCTL(TIOCSBRK)
+COMPATIBLE_IOCTL(TIOCCBRK)
+ULONG_IOCTL(TIOCMIWAIT)
+COMPATIBLE_IOCTL(TIOCGICOUNT)
+/* Little t */
+COMPATIBLE_IOCTL(TIOCGETD)
+COMPATIBLE_IOCTL(TIOCSETD)
+COMPATIBLE_IOCTL(TIOCEXCL)
+COMPATIBLE_IOCTL(TIOCNXCL)
+COMPATIBLE_IOCTL(TIOCCONS)
+COMPATIBLE_IOCTL(TIOCGSOFTCAR)
+COMPATIBLE_IOCTL(TIOCSSOFTCAR)
+COMPATIBLE_IOCTL(TIOCSWINSZ)
+COMPATIBLE_IOCTL(TIOCGWINSZ)
+COMPATIBLE_IOCTL(TIOCMGET)
+COMPATIBLE_IOCTL(TIOCMBIC)
+COMPATIBLE_IOCTL(TIOCMBIS)
+COMPATIBLE_IOCTL(TIOCMSET)
+COMPATIBLE_IOCTL(TIOCPKT)
+COMPATIBLE_IOCTL(TIOCNOTTY)
+COMPATIBLE_IOCTL(TIOCSTI)
+COMPATIBLE_IOCTL(TIOCOUTQ)
+COMPATIBLE_IOCTL(TIOCSPGRP)
+COMPATIBLE_IOCTL(TIOCGPGRP)
+ULONG_IOCTL(TIOCSCTTY)
+COMPATIBLE_IOCTL(TIOCGPTN)
+COMPATIBLE_IOCTL(TIOCSPTLCK)
+COMPATIBLE_IOCTL(TIOCSERGETLSR)
+/* Little f */
+COMPATIBLE_IOCTL(FIOCLEX)
+COMPATIBLE_IOCTL(FIONCLEX)
+COMPATIBLE_IOCTL(FIOASYNC)
+COMPATIBLE_IOCTL(FIONBIO)
+COMPATIBLE_IOCTL(FIONREAD)  /* This is also TIOCINQ */
+/* 0x00 */
+COMPATIBLE_IOCTL(FIBMAP)
+COMPATIBLE_IOCTL(FIGETBSZ)
+/* 0x03 -- HD/IDE ioctl's used by hdparm and friends.
+ *         Some need translations, these do not.
+ */
+COMPATIBLE_IOCTL(HDIO_GET_IDENTITY)
+COMPATIBLE_IOCTL(HDIO_DRIVE_TASK)
+COMPATIBLE_IOCTL(HDIO_DRIVE_CMD)
+ULONG_IOCTL(HDIO_SET_MULTCOUNT)
+ULONG_IOCTL(HDIO_SET_UNMASKINTR)
+ULONG_IOCTL(HDIO_SET_KEEPSETTINGS)
+ULONG_IOCTL(HDIO_SET_32BIT)
+ULONG_IOCTL(HDIO_SET_NOWERR)
+ULONG_IOCTL(HDIO_SET_DMA)
+ULONG_IOCTL(HDIO_SET_PIO_MODE)
+ULONG_IOCTL(HDIO_SET_NICE)
+ULONG_IOCTL(HDIO_SET_WCACHE)
+ULONG_IOCTL(HDIO_SET_ACOUSTIC)
+ULONG_IOCTL(HDIO_SET_BUSSTATE)
+ULONG_IOCTL(HDIO_SET_ADDRESS)
+COMPATIBLE_IOCTL(HDIO_SCAN_HWIF)
+/* 0x330 is reserved -- it used to be HDIO_GETGEO_BIG */
+COMPATIBLE_IOCTL(0x330)
+/* 0x02 -- Floppy ioctls */
+COMPATIBLE_IOCTL(FDMSGON)
+COMPATIBLE_IOCTL(FDMSGOFF)
+COMPATIBLE_IOCTL(FDSETEMSGTRESH)
+COMPATIBLE_IOCTL(FDFLUSH)
+COMPATIBLE_IOCTL(FDWERRORCLR)
+COMPATIBLE_IOCTL(FDSETMAXERRS)
+COMPATIBLE_IOCTL(FDGETMAXERRS)
+COMPATIBLE_IOCTL(FDGETDRVTYP)
+COMPATIBLE_IOCTL(FDEJECT)
+COMPATIBLE_IOCTL(FDCLRPRM)
+COMPATIBLE_IOCTL(FDFMTBEG)
+COMPATIBLE_IOCTL(FDFMTEND)
+COMPATIBLE_IOCTL(FDRESET)
+COMPATIBLE_IOCTL(FDTWADDLE)
+COMPATIBLE_IOCTL(FDFMTTRK)
+COMPATIBLE_IOCTL(FDRAWCMD)
+/* 0x12 */
+#ifdef CONFIG_BLOCK
+COMPATIBLE_IOCTL(BLKRASET)
+COMPATIBLE_IOCTL(BLKROSET)
+COMPATIBLE_IOCTL(BLKROGET)
+COMPATIBLE_IOCTL(BLKRRPART)
+COMPATIBLE_IOCTL(BLKFLSBUF)
+COMPATIBLE_IOCTL(BLKSECTSET)
+COMPATIBLE_IOCTL(BLKSSZGET)
+COMPATIBLE_IOCTL(BLKTRACESTART)
+COMPATIBLE_IOCTL(BLKTRACESTOP)
+COMPATIBLE_IOCTL(BLKTRACESETUP)
+COMPATIBLE_IOCTL(BLKTRACETEARDOWN)
+ULONG_IOCTL(BLKRASET)
+ULONG_IOCTL(BLKFRASET)
+#endif
+/* RAID */
+COMPATIBLE_IOCTL(RAID_VERSION)
+COMPATIBLE_IOCTL(GET_ARRAY_INFO)
+COMPATIBLE_IOCTL(GET_DISK_INFO)
+COMPATIBLE_IOCTL(PRINT_RAID_DEBUG)
+COMPATIBLE_IOCTL(RAID_AUTORUN)
+COMPATIBLE_IOCTL(CLEAR_ARRAY)
+COMPATIBLE_IOCTL(ADD_NEW_DISK)
+ULONG_IOCTL(HOT_REMOVE_DISK)
+COMPATIBLE_IOCTL(SET_ARRAY_INFO)
+COMPATIBLE_IOCTL(SET_DISK_INFO)
+COMPATIBLE_IOCTL(WRITE_RAID_INFO)
+COMPATIBLE_IOCTL(UNPROTECT_ARRAY)
+COMPATIBLE_IOCTL(PROTECT_ARRAY)
+ULONG_IOCTL(HOT_ADD_DISK)
+ULONG_IOCTL(SET_DISK_FAULTY)
+COMPATIBLE_IOCTL(RUN_ARRAY)
+COMPATIBLE_IOCTL(STOP_ARRAY)
+COMPATIBLE_IOCTL(STOP_ARRAY_RO)
+COMPATIBLE_IOCTL(RESTART_ARRAY_RW)
+COMPATIBLE_IOCTL(GET_BITMAP_FILE)
+ULONG_IOCTL(SET_BITMAP_FILE)
+/* DM */
+COMPATIBLE_IOCTL(DM_VERSION_32)
+COMPATIBLE_IOCTL(DM_REMOVE_ALL_32)
+COMPATIBLE_IOCTL(DM_LIST_DEVICES_32)
+COMPATIBLE_IOCTL(DM_DEV_CREATE_32)
+COMPATIBLE_IOCTL(DM_DEV_REMOVE_32)
+COMPATIBLE_IOCTL(DM_DEV_RENAME_32)
+COMPATIBLE_IOCTL(DM_DEV_SUSPEND_32)
+COMPATIBLE_IOCTL(DM_DEV_STATUS_32)
+COMPATIBLE_IOCTL(DM_DEV_WAIT_32)
+COMPATIBLE_IOCTL(DM_TABLE_LOAD_32)
+COMPATIBLE_IOCTL(DM_TABLE_CLEAR_32)
+COMPATIBLE_IOCTL(DM_TABLE_DEPS_32)
+COMPATIBLE_IOCTL(DM_TABLE_STATUS_32)
+COMPATIBLE_IOCTL(DM_LIST_VERSIONS_32)
+COMPATIBLE_IOCTL(DM_TARGET_MSG_32)
+COMPATIBLE_IOCTL(DM_DEV_SET_GEOMETRY_32)
+COMPATIBLE_IOCTL(DM_VERSION)
+COMPATIBLE_IOCTL(DM_REMOVE_ALL)
+COMPATIBLE_IOCTL(DM_LIST_DEVICES)
+COMPATIBLE_IOCTL(DM_DEV_CREATE)
+COMPATIBLE_IOCTL(DM_DEV_REMOVE)
+COMPATIBLE_IOCTL(DM_DEV_RENAME)
+COMPATIBLE_IOCTL(DM_DEV_SUSPEND)
+COMPATIBLE_IOCTL(DM_DEV_STATUS)
+COMPATIBLE_IOCTL(DM_DEV_WAIT)
+COMPATIBLE_IOCTL(DM_TABLE_LOAD)
+COMPATIBLE_IOCTL(DM_TABLE_CLEAR)
+COMPATIBLE_IOCTL(DM_TABLE_DEPS)
+COMPATIBLE_IOCTL(DM_TABLE_STATUS)
+COMPATIBLE_IOCTL(DM_LIST_VERSIONS)
+COMPATIBLE_IOCTL(DM_TARGET_MSG)
+COMPATIBLE_IOCTL(DM_DEV_SET_GEOMETRY)
+/* Big K */
+COMPATIBLE_IOCTL(PIO_FONT)
+COMPATIBLE_IOCTL(GIO_FONT)
+ULONG_IOCTL(KDSIGACCEPT)
+COMPATIBLE_IOCTL(KDGETKEYCODE)
+COMPATIBLE_IOCTL(KDSETKEYCODE)
+ULONG_IOCTL(KIOCSOUND)
+ULONG_IOCTL(KDMKTONE)
+COMPATIBLE_IOCTL(KDGKBTYPE)
+ULONG_IOCTL(KDSETMODE)
+COMPATIBLE_IOCTL(KDGETMODE)
+ULONG_IOCTL(KDSKBMODE)
+COMPATIBLE_IOCTL(KDGKBMODE)
+ULONG_IOCTL(KDSKBMETA)
+COMPATIBLE_IOCTL(KDGKBMETA)
+COMPATIBLE_IOCTL(KDGKBENT)
+COMPATIBLE_IOCTL(KDSKBENT)
+COMPATIBLE_IOCTL(KDGKBSENT)
+COMPATIBLE_IOCTL(KDSKBSENT)
+COMPATIBLE_IOCTL(KDGKBDIACR)
+COMPATIBLE_IOCTL(KDSKBDIACR)
+COMPATIBLE_IOCTL(KDKBDREP)
+COMPATIBLE_IOCTL(KDGKBLED)
+ULONG_IOCTL(KDSKBLED)
+COMPATIBLE_IOCTL(KDGETLED)
+ULONG_IOCTL(KDSETLED)
+COMPATIBLE_IOCTL(GIO_SCRNMAP)
+COMPATIBLE_IOCTL(PIO_SCRNMAP)
+COMPATIBLE_IOCTL(GIO_UNISCRNMAP)
+COMPATIBLE_IOCTL(PIO_UNISCRNMAP)
+COMPATIBLE_IOCTL(PIO_FONTRESET)
+COMPATIBLE_IOCTL(PIO_UNIMAPCLR)
+/* Big S */
+COMPATIBLE_IOCTL(SCSI_IOCTL_GET_IDLUN)
+COMPATIBLE_IOCTL(SCSI_IOCTL_DOORLOCK)
+COMPATIBLE_IOCTL(SCSI_IOCTL_DOORUNLOCK)
+COMPATIBLE_IOCTL(SCSI_IOCTL_TEST_UNIT_READY)
+COMPATIBLE_IOCTL(SCSI_IOCTL_GET_BUS_NUMBER)
+COMPATIBLE_IOCTL(SCSI_IOCTL_SEND_COMMAND)
+COMPATIBLE_IOCTL(SCSI_IOCTL_PROBE_HOST)
+COMPATIBLE_IOCTL(SCSI_IOCTL_GET_PCI)
+/* Big T */
+COMPATIBLE_IOCTL(TUNSETNOCSUM)
+COMPATIBLE_IOCTL(TUNSETDEBUG)
+COMPATIBLE_IOCTL(TUNSETPERSIST)
+COMPATIBLE_IOCTL(TUNSETOWNER)
+/* Big V */
+COMPATIBLE_IOCTL(VT_SETMODE)
+COMPATIBLE_IOCTL(VT_GETMODE)
+COMPATIBLE_IOCTL(VT_GETSTATE)
+COMPATIBLE_IOCTL(VT_OPENQRY)
+ULONG_IOCTL(VT_ACTIVATE)
+ULONG_IOCTL(VT_WAITACTIVE)
+ULONG_IOCTL(VT_RELDISP)
+ULONG_IOCTL(VT_DISALLOCATE)
+COMPATIBLE_IOCTL(VT_RESIZE)
+COMPATIBLE_IOCTL(VT_RESIZEX)
+COMPATIBLE_IOCTL(VT_LOCKSWITCH)
+COMPATIBLE_IOCTL(VT_UNLOCKSWITCH)
+COMPATIBLE_IOCTL(VT_GETHIFONTMASK)
+/* Little p (/dev/rtc, /dev/envctrl, etc.) */
+COMPATIBLE_IOCTL(RTC_AIE_ON)
+COMPATIBLE_IOCTL(RTC_AIE_OFF)
+COMPATIBLE_IOCTL(RTC_UIE_ON)
+COMPATIBLE_IOCTL(RTC_UIE_OFF)
+COMPATIBLE_IOCTL(RTC_PIE_ON)
+COMPATIBLE_IOCTL(RTC_PIE_OFF)
+COMPATIBLE_IOCTL(RTC_WIE_ON)
+COMPATIBLE_IOCTL(RTC_WIE_OFF)
+COMPATIBLE_IOCTL(RTC_ALM_SET)
+COMPATIBLE_IOCTL(RTC_ALM_READ)
+COMPATIBLE_IOCTL(RTC_RD_TIME)
+COMPATIBLE_IOCTL(RTC_SET_TIME)
+COMPATIBLE_IOCTL(RTC_WKALM_SET)
+COMPATIBLE_IOCTL(RTC_WKALM_RD)
+/*
+ * These two are only for the sbus rtc driver, but
+ * hwclock tries them on every rtc device first when
+ * running on sparc.  On other architectures the entries
+ * are useless but harmless.
+ */
+COMPATIBLE_IOCTL(_IOR('p', 20, int[7])) /* RTCGET */
+COMPATIBLE_IOCTL(_IOW('p', 21, int[7])) /* RTCSET */
+/* Little m */
+COMPATIBLE_IOCTL(MTIOCTOP)
+/* Socket level stuff */
+COMPATIBLE_IOCTL(FIOQSIZE)
+COMPATIBLE_IOCTL(FIOSETOWN)
+COMPATIBLE_IOCTL(SIOCSPGRP)
+COMPATIBLE_IOCTL(FIOGETOWN)
+COMPATIBLE_IOCTL(SIOCGPGRP)
+COMPATIBLE_IOCTL(SIOCATMARK)
+COMPATIBLE_IOCTL(SIOCSIFLINK)
+COMPATIBLE_IOCTL(SIOCSIFENCAP)
+COMPATIBLE_IOCTL(SIOCGIFENCAP)
+COMPATIBLE_IOCTL(SIOCSIFNAME)
+COMPATIBLE_IOCTL(SIOCSARP)
+COMPATIBLE_IOCTL(SIOCGARP)
+COMPATIBLE_IOCTL(SIOCDARP)
+COMPATIBLE_IOCTL(SIOCSRARP)
+COMPATIBLE_IOCTL(SIOCGRARP)
+COMPATIBLE_IOCTL(SIOCDRARP)
+COMPATIBLE_IOCTL(SIOCADDDLCI)
+COMPATIBLE_IOCTL(SIOCDELDLCI)
+COMPATIBLE_IOCTL(SIOCGMIIPHY)
+COMPATIBLE_IOCTL(SIOCGMIIREG)
+COMPATIBLE_IOCTL(SIOCSMIIREG)
+COMPATIBLE_IOCTL(SIOCGIFVLAN)
+COMPATIBLE_IOCTL(SIOCSIFVLAN)
+COMPATIBLE_IOCTL(SIOCBRADDBR)
+COMPATIBLE_IOCTL(SIOCBRDELBR)
+/* SG stuff */
+COMPATIBLE_IOCTL(SG_SET_TIMEOUT)
+COMPATIBLE_IOCTL(SG_GET_TIMEOUT)
+COMPATIBLE_IOCTL(SG_EMULATED_HOST)
+ULONG_IOCTL(SG_SET_TRANSFORM)
+COMPATIBLE_IOCTL(SG_GET_TRANSFORM)
+COMPATIBLE_IOCTL(SG_SET_RESERVED_SIZE)
+COMPATIBLE_IOCTL(SG_GET_RESERVED_SIZE)
+COMPATIBLE_IOCTL(SG_GET_SCSI_ID)
+COMPATIBLE_IOCTL(SG_SET_FORCE_LOW_DMA)
+COMPATIBLE_IOCTL(SG_GET_LOW_DMA)
+COMPATIBLE_IOCTL(SG_SET_FORCE_PACK_ID)
+COMPATIBLE_IOCTL(SG_GET_PACK_ID)
+COMPATIBLE_IOCTL(SG_GET_NUM_WAITING)
+COMPATIBLE_IOCTL(SG_SET_DEBUG)
+COMPATIBLE_IOCTL(SG_GET_SG_TABLESIZE)
+COMPATIBLE_IOCTL(SG_GET_COMMAND_Q)
+COMPATIBLE_IOCTL(SG_SET_COMMAND_Q)
+COMPATIBLE_IOCTL(SG_GET_VERSION_NUM)
+COMPATIBLE_IOCTL(SG_NEXT_CMD_LEN)
+COMPATIBLE_IOCTL(SG_SCSI_RESET)
+COMPATIBLE_IOCTL(SG_GET_REQUEST_TABLE)
+COMPATIBLE_IOCTL(SG_SET_KEEP_ORPHAN)
+COMPATIBLE_IOCTL(SG_GET_KEEP_ORPHAN)
+/* PPP stuff */
+COMPATIBLE_IOCTL(PPPIOCGFLAGS)
+COMPATIBLE_IOCTL(PPPIOCSFLAGS)
+COMPATIBLE_IOCTL(PPPIOCGASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCSASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCGUNIT)
+COMPATIBLE_IOCTL(PPPIOCGRASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCSRASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCGMRU)
+COMPATIBLE_IOCTL(PPPIOCSMRU)
+COMPATIBLE_IOCTL(PPPIOCSMAXCID)
+COMPATIBLE_IOCTL(PPPIOCGXASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCSXASYNCMAP)
+COMPATIBLE_IOCTL(PPPIOCXFERUNIT)
+/* PPPIOCSCOMPRESS is translated */
+COMPATIBLE_IOCTL(PPPIOCGNPMODE)
+COMPATIBLE_IOCTL(PPPIOCSNPMODE)
+COMPATIBLE_IOCTL(PPPIOCGDEBUG)
+COMPATIBLE_IOCTL(PPPIOCSDEBUG)
+/* PPPIOCSPASS is translated */
+/* PPPIOCSACTIVE is translated */
+/* PPPIOCGIDLE is translated */
+COMPATIBLE_IOCTL(PPPIOCNEWUNIT)
+COMPATIBLE_IOCTL(PPPIOCATTACH)
+COMPATIBLE_IOCTL(PPPIOCDETACH)
+COMPATIBLE_IOCTL(PPPIOCSMRRU)
+COMPATIBLE_IOCTL(PPPIOCCONNECT)
+COMPATIBLE_IOCTL(PPPIOCDISCONN)
+COMPATIBLE_IOCTL(PPPIOCATTCHAN)
+COMPATIBLE_IOCTL(PPPIOCGCHAN)
+/* PPPOX */
+COMPATIBLE_IOCTL(PPPOEIOCSFWD)
+COMPATIBLE_IOCTL(PPPOEIOCDFWD)
+/* LP */
+COMPATIBLE_IOCTL(LPGETSTATUS)
+/* ppdev */
+COMPATIBLE_IOCTL(PPSETMODE)
+COMPATIBLE_IOCTL(PPRSTATUS)
+COMPATIBLE_IOCTL(PPRCONTROL)
+COMPATIBLE_IOCTL(PPWCONTROL)
+COMPATIBLE_IOCTL(PPFCONTROL)
+COMPATIBLE_IOCTL(PPRDATA)
+COMPATIBLE_IOCTL(PPWDATA)
+COMPATIBLE_IOCTL(PPCLAIM)
+COMPATIBLE_IOCTL(PPRELEASE)
+COMPATIBLE_IOCTL(PPYIELD)
+COMPATIBLE_IOCTL(PPEXCL)
+COMPATIBLE_IOCTL(PPDATADIR)
+COMPATIBLE_IOCTL(PPNEGOT)
+COMPATIBLE_IOCTL(PPWCTLONIRQ)
+COMPATIBLE_IOCTL(PPCLRIRQ)
+COMPATIBLE_IOCTL(PPSETPHASE)
+COMPATIBLE_IOCTL(PPGETMODES)
+COMPATIBLE_IOCTL(PPGETMODE)
+COMPATIBLE_IOCTL(PPGETPHASE)
+COMPATIBLE_IOCTL(PPGETFLAGS)
+COMPATIBLE_IOCTL(PPSETFLAGS)
+/* CDROM stuff */
+COMPATIBLE_IOCTL(CDROMPAUSE)
+COMPATIBLE_IOCTL(CDROMRESUME)
+COMPATIBLE_IOCTL(CDROMPLAYMSF)
+COMPATIBLE_IOCTL(CDROMPLAYTRKIND)
+COMPATIBLE_IOCTL(CDROMREADTOCHDR)
+COMPATIBLE_IOCTL(CDROMREADTOCENTRY)
+COMPATIBLE_IOCTL(CDROMSTOP)
+COMPATIBLE_IOCTL(CDROMSTART)
+COMPATIBLE_IOCTL(CDROMEJECT)
+COMPATIBLE_IOCTL(CDROMVOLCTRL)
+COMPATIBLE_IOCTL(CDROMSUBCHNL)
+ULONG_IOCTL(CDROMEJECT_SW)
+COMPATIBLE_IOCTL(CDROMMULTISESSION)
+COMPATIBLE_IOCTL(CDROM_GET_MCN)
+COMPATIBLE_IOCTL(CDROMRESET)
+COMPATIBLE_IOCTL(CDROMVOLREAD)
+COMPATIBLE_IOCTL(CDROMSEEK)
+COMPATIBLE_IOCTL(CDROMPLAYBLK)
+COMPATIBLE_IOCTL(CDROMCLOSETRAY)
+ULONG_IOCTL(CDROM_SET_OPTIONS)
+ULONG_IOCTL(CDROM_CLEAR_OPTIONS)
+ULONG_IOCTL(CDROM_SELECT_SPEED)
+ULONG_IOCTL(CDROM_SELECT_DISC)
+ULONG_IOCTL(CDROM_MEDIA_CHANGED)
+ULONG_IOCTL(CDROM_DRIVE_STATUS)
+COMPATIBLE_IOCTL(CDROM_DISC_STATUS)
+COMPATIBLE_IOCTL(CDROM_CHANGER_NSLOTS)
+ULONG_IOCTL(CDROM_LOCKDOOR)
+ULONG_IOCTL(CDROM_DEBUG)
+COMPATIBLE_IOCTL(CDROM_GET_CAPABILITY)
+/* Ignore cdrom.h about these next 5 ioctls, they absolutely do
+ * not take a struct cdrom_read, instead they take a struct cdrom_msf
+ * which is compatible.
+ */
+COMPATIBLE_IOCTL(CDROMREADMODE2)
+COMPATIBLE_IOCTL(CDROMREADMODE1)
+COMPATIBLE_IOCTL(CDROMREADRAW)
+COMPATIBLE_IOCTL(CDROMREADCOOKED)
+COMPATIBLE_IOCTL(CDROMREADALL)
+/* DVD ioctls */
+COMPATIBLE_IOCTL(DVD_READ_STRUCT)
+COMPATIBLE_IOCTL(DVD_WRITE_STRUCT)
+COMPATIBLE_IOCTL(DVD_AUTH)
+/* pktcdvd */
+COMPATIBLE_IOCTL(PACKET_CTRL_CMD)
+/* Big A */
+/* sparc only */
+/* Big Q for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_SEQ_RESET)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_SYNC)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_INFO)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_CTRLRATE)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_GETOUTCOUNT)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_GETINCOUNT)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_PERCMODE)
+COMPATIBLE_IOCTL(SNDCTL_FM_LOAD_INSTR)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_TESTMIDI)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_RESETSAMPLES)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_NRSYNTHS)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_NRMIDIS)
+COMPATIBLE_IOCTL(SNDCTL_MIDI_INFO)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_THRESHOLD)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_MEMAVL)
+COMPATIBLE_IOCTL(SNDCTL_FM_4OP_ENABLE)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_PANIC)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_OUTOFBAND)
+COMPATIBLE_IOCTL(SNDCTL_SEQ_GETTIME)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_ID)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_CONTROL)
+COMPATIBLE_IOCTL(SNDCTL_SYNTH_REMOVESAMPLE)
+/* Big T for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_TMR_TIMEBASE)
+COMPATIBLE_IOCTL(SNDCTL_TMR_START)
+COMPATIBLE_IOCTL(SNDCTL_TMR_STOP)
+COMPATIBLE_IOCTL(SNDCTL_TMR_CONTINUE)
+COMPATIBLE_IOCTL(SNDCTL_TMR_TEMPO)
+COMPATIBLE_IOCTL(SNDCTL_TMR_SOURCE)
+COMPATIBLE_IOCTL(SNDCTL_TMR_METRONOME)
+COMPATIBLE_IOCTL(SNDCTL_TMR_SELECT)
+/* Little m for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_MIDI_PRETIME)
+COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUMODE)
+COMPATIBLE_IOCTL(SNDCTL_MIDI_MPUCMD)
+/* Big P for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_DSP_RESET)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SYNC)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SPEED)
+COMPATIBLE_IOCTL(SNDCTL_DSP_STEREO)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETBLKSIZE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_CHANNELS)
+COMPATIBLE_IOCTL(SOUND_PCM_WRITE_FILTER)
+COMPATIBLE_IOCTL(SNDCTL_DSP_POST)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SUBDIVIDE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETFRAGMENT)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETFMTS)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETFMT)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETOSPACE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETISPACE)
+COMPATIBLE_IOCTL(SNDCTL_DSP_NONBLOCK)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETCAPS)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETTRIGGER)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETTRIGGER)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETIPTR)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETOPTR)
+/* SNDCTL_DSP_MAPINBUF,  XXX needs translation */
+/* SNDCTL_DSP_MAPOUTBUF,  XXX needs translation */
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETSYNCRO)
+COMPATIBLE_IOCTL(SNDCTL_DSP_SETDUPLEX)
+COMPATIBLE_IOCTL(SNDCTL_DSP_GETODELAY)
+COMPATIBLE_IOCTL(SNDCTL_DSP_PROFILE)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_RATE)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_CHANNELS)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_BITS)
+COMPATIBLE_IOCTL(SOUND_PCM_READ_FILTER)
+/* Big C for sound/OSS */
+COMPATIBLE_IOCTL(SNDCTL_COPR_RESET)
+COMPATIBLE_IOCTL(SNDCTL_COPR_LOAD)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RDATA)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RCODE)
+COMPATIBLE_IOCTL(SNDCTL_COPR_WDATA)
+COMPATIBLE_IOCTL(SNDCTL_COPR_WCODE)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RUN)
+COMPATIBLE_IOCTL(SNDCTL_COPR_HALT)
+COMPATIBLE_IOCTL(SNDCTL_COPR_SENDMSG)
+COMPATIBLE_IOCTL(SNDCTL_COPR_RCVMSG)
+/* Big M for sound/OSS */
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_VOLUME)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_BASS)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_TREBLE)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_SYNTH)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_PCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_SPEAKER)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_MIC)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_CD)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_IMIX)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_ALTPCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECLEV)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_IGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_OGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE1)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE2)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_LINE3)
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL1))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL2))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_DIGITAL3))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEIN))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_PHONEOUT))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_VIDEO))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_RADIO))
+COMPATIBLE_IOCTL(MIXER_READ(SOUND_MIXER_MONITOR))
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_MUTE)
+/* SOUND_MIXER_READ_ENHANCE,  same value as READ_MUTE */
+/* SOUND_MIXER_READ_LOUD,  same value as READ_MUTE */
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECSRC)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_DEVMASK)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_RECMASK)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_STEREODEVS)
+COMPATIBLE_IOCTL(SOUND_MIXER_READ_CAPS)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_VOLUME)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_BASS)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_TREBLE)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SYNTH)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_PCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_SPEAKER)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MIC)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_CD)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IMIX)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_ALTPCM)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECLEV)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_IGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_OGAIN)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE1)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE2)
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_LINE3)
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL1))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL2))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_DIGITAL3))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEIN))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_PHONEOUT))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_VIDEO))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_RADIO))
+COMPATIBLE_IOCTL(MIXER_WRITE(SOUND_MIXER_MONITOR))
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_MUTE)
+/* SOUND_MIXER_WRITE_ENHANCE,  same value as WRITE_MUTE */
+/* SOUND_MIXER_WRITE_LOUD,  same value as WRITE_MUTE */
+COMPATIBLE_IOCTL(SOUND_MIXER_WRITE_RECSRC)
+COMPATIBLE_IOCTL(SOUND_MIXER_INFO)
+COMPATIBLE_IOCTL(SOUND_OLD_MIXER_INFO)
+COMPATIBLE_IOCTL(SOUND_MIXER_ACCESS)
+COMPATIBLE_IOCTL(SOUND_MIXER_AGC)
+COMPATIBLE_IOCTL(SOUND_MIXER_3DSE)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE1)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE2)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE3)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE4)
+COMPATIBLE_IOCTL(SOUND_MIXER_PRIVATE5)
+COMPATIBLE_IOCTL(SOUND_MIXER_GETLEVELS)
+COMPATIBLE_IOCTL(SOUND_MIXER_SETLEVELS)
+COMPATIBLE_IOCTL(OSS_GETVERSION)
+/* AUTOFS */
+ULONG_IOCTL(AUTOFS_IOC_READY)
+ULONG_IOCTL(AUTOFS_IOC_FAIL)
+COMPATIBLE_IOCTL(AUTOFS_IOC_CATATONIC)
+COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOVER)
+COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE)
+COMPATIBLE_IOCTL(AUTOFS_IOC_EXPIRE_MULTI)
+COMPATIBLE_IOCTL(AUTOFS_IOC_PROTOSUBVER)
+COMPATIBLE_IOCTL(AUTOFS_IOC_ASKREGHOST)
+COMPATIBLE_IOCTL(AUTOFS_IOC_TOGGLEREGHOST)
+COMPATIBLE_IOCTL(AUTOFS_IOC_ASKUMOUNT)
+/* Raw devices */
+COMPATIBLE_IOCTL(RAW_SETBIND)
+COMPATIBLE_IOCTL(RAW_GETBIND)
+/* SMB ioctls which do not need any translations */
+COMPATIBLE_IOCTL(SMB_IOC_NEWCONN)
+/* Little a */
+COMPATIBLE_IOCTL(ATMSIGD_CTRL)
+COMPATIBLE_IOCTL(ATMARPD_CTRL)
+COMPATIBLE_IOCTL(ATMLEC_CTRL)
+COMPATIBLE_IOCTL(ATMLEC_MCAST)
+COMPATIBLE_IOCTL(ATMLEC_DATA)
+COMPATIBLE_IOCTL(ATM_SETSC)
+COMPATIBLE_IOCTL(SIOCSIFATMTCP)
+COMPATIBLE_IOCTL(SIOCMKCLIP)
+COMPATIBLE_IOCTL(ATMARP_MKIP)
+COMPATIBLE_IOCTL(ATMARP_SETENTRY)
+COMPATIBLE_IOCTL(ATMARP_ENCAP)
+COMPATIBLE_IOCTL(ATMTCP_CREATE)
+COMPATIBLE_IOCTL(ATMTCP_REMOVE)
+COMPATIBLE_IOCTL(ATMMPC_CTRL)
+COMPATIBLE_IOCTL(ATMMPC_DATA)
+/* Watchdog */
+COMPATIBLE_IOCTL(WDIOC_GETSUPPORT)
+COMPATIBLE_IOCTL(WDIOC_GETSTATUS)
+COMPATIBLE_IOCTL(WDIOC_GETBOOTSTATUS)
+COMPATIBLE_IOCTL(WDIOC_GETTEMP)
+COMPATIBLE_IOCTL(WDIOC_SETOPTIONS)
+COMPATIBLE_IOCTL(WDIOC_KEEPALIVE)
+COMPATIBLE_IOCTL(WDIOC_SETTIMEOUT)
+COMPATIBLE_IOCTL(WDIOC_GETTIMEOUT)
+/* Big R */
+COMPATIBLE_IOCTL(RNDGETENTCNT)
+COMPATIBLE_IOCTL(RNDADDTOENTCNT)
+COMPATIBLE_IOCTL(RNDGETPOOL)
+COMPATIBLE_IOCTL(RNDADDENTROPY)
+COMPATIBLE_IOCTL(RNDZAPENTCNT)
+COMPATIBLE_IOCTL(RNDCLEARPOOL)
+/* Bluetooth */
+COMPATIBLE_IOCTL(HCIDEVUP)
+COMPATIBLE_IOCTL(HCIDEVDOWN)
+COMPATIBLE_IOCTL(HCIDEVRESET)
+COMPATIBLE_IOCTL(HCIDEVRESTAT)
+COMPATIBLE_IOCTL(HCIGETDEVLIST)
+COMPATIBLE_IOCTL(HCIGETDEVINFO)
+COMPATIBLE_IOCTL(HCIGETCONNLIST)
+COMPATIBLE_IOCTL(HCIGETCONNINFO)
+COMPATIBLE_IOCTL(HCISETRAW)
+COMPATIBLE_IOCTL(HCISETSCAN)
+COMPATIBLE_IOCTL(HCISETAUTH)
+COMPATIBLE_IOCTL(HCISETENCRYPT)
+COMPATIBLE_IOCTL(HCISETPTYPE)
+COMPATIBLE_IOCTL(HCISETLINKPOL)
+COMPATIBLE_IOCTL(HCISETLINKMODE)
+COMPATIBLE_IOCTL(HCISETACLMTU)
+COMPATIBLE_IOCTL(HCISETSCOMTU)
+COMPATIBLE_IOCTL(HCIINQUIRY)
+COMPATIBLE_IOCTL(HCIUARTSETPROTO)
+COMPATIBLE_IOCTL(HCIUARTGETPROTO)
+COMPATIBLE_IOCTL(RFCOMMCREATEDEV)
+COMPATIBLE_IOCTL(RFCOMMRELEASEDEV)
+COMPATIBLE_IOCTL(RFCOMMGETDEVLIST)
+COMPATIBLE_IOCTL(RFCOMMGETDEVINFO)
+COMPATIBLE_IOCTL(RFCOMMSTEALDLC)
+COMPATIBLE_IOCTL(BNEPCONNADD)
+COMPATIBLE_IOCTL(BNEPCONNDEL)
+COMPATIBLE_IOCTL(BNEPGETCONNLIST)
+COMPATIBLE_IOCTL(BNEPGETCONNINFO)
+COMPATIBLE_IOCTL(CMTPCONNADD)
+COMPATIBLE_IOCTL(CMTPCONNDEL)
+COMPATIBLE_IOCTL(CMTPGETCONNLIST)
+COMPATIBLE_IOCTL(CMTPGETCONNINFO)
+COMPATIBLE_IOCTL(HIDPCONNADD)
+COMPATIBLE_IOCTL(HIDPCONNDEL)
+COMPATIBLE_IOCTL(HIDPGETCONNLIST)
+COMPATIBLE_IOCTL(HIDPGETCONNINFO)
+/* CAPI */
+COMPATIBLE_IOCTL(CAPI_REGISTER)
+COMPATIBLE_IOCTL(CAPI_GET_MANUFACTURER)
+COMPATIBLE_IOCTL(CAPI_GET_VERSION)
+COMPATIBLE_IOCTL(CAPI_GET_SERIAL)
+COMPATIBLE_IOCTL(CAPI_GET_PROFILE)
+COMPATIBLE_IOCTL(CAPI_MANUFACTURER_CMD)
+COMPATIBLE_IOCTL(CAPI_GET_ERRCODE)
+COMPATIBLE_IOCTL(CAPI_INSTALLED)
+COMPATIBLE_IOCTL(CAPI_GET_FLAGS)
+COMPATIBLE_IOCTL(CAPI_SET_FLAGS)
+COMPATIBLE_IOCTL(CAPI_CLR_FLAGS)
+COMPATIBLE_IOCTL(CAPI_NCCI_OPENCOUNT)
+COMPATIBLE_IOCTL(CAPI_NCCI_GETUNIT)
+/* Siemens Gigaset */
+COMPATIBLE_IOCTL(GIGASET_REDIR)
+COMPATIBLE_IOCTL(GIGASET_CONFIG)
+COMPATIBLE_IOCTL(GIGASET_BRKCHARS)
+COMPATIBLE_IOCTL(GIGASET_VERSION)
+/* Misc. */
+COMPATIBLE_IOCTL(0x41545900)            /* ATYIO_CLKR */
+COMPATIBLE_IOCTL(0x41545901)            /* ATYIO_CLKW */
+COMPATIBLE_IOCTL(PCIIOC_CONTROLLER)
+COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_IO)
+COMPATIBLE_IOCTL(PCIIOC_MMAP_IS_MEM)
+COMPATIBLE_IOCTL(PCIIOC_WRITE_COMBINE)
+/* USB */
+COMPATIBLE_IOCTL(USBDEVFS_RESETEP)
+COMPATIBLE_IOCTL(USBDEVFS_SETINTERFACE)
+COMPATIBLE_IOCTL(USBDEVFS_SETCONFIGURATION)
+COMPATIBLE_IOCTL(USBDEVFS_GETDRIVER)
+COMPATIBLE_IOCTL(USBDEVFS_DISCARDURB)
+COMPATIBLE_IOCTL(USBDEVFS_CLAIMINTERFACE)
+COMPATIBLE_IOCTL(USBDEVFS_RELEASEINTERFACE)
+COMPATIBLE_IOCTL(USBDEVFS_CONNECTINFO)
+COMPATIBLE_IOCTL(USBDEVFS_HUB_PORTINFO)
+COMPATIBLE_IOCTL(USBDEVFS_RESET)
+COMPATIBLE_IOCTL(USBDEVFS_SUBMITURB32)
+COMPATIBLE_IOCTL(USBDEVFS_REAPURB32)
+COMPATIBLE_IOCTL(USBDEVFS_REAPURBNDELAY32)
+COMPATIBLE_IOCTL(USBDEVFS_CLEAR_HALT)
+/* MTD */
+COMPATIBLE_IOCTL(MEMGETINFO)
+COMPATIBLE_IOCTL(MEMERASE)
+COMPATIBLE_IOCTL(MEMLOCK)
+COMPATIBLE_IOCTL(MEMUNLOCK)
+COMPATIBLE_IOCTL(MEMGETREGIONCOUNT)
+COMPATIBLE_IOCTL(MEMGETREGIONINFO)
+COMPATIBLE_IOCTL(MEMGETBADBLOCK)
+COMPATIBLE_IOCTL(MEMSETBADBLOCK)
+/* NBD */
+ULONG_IOCTL(NBD_SET_SOCK)
+ULONG_IOCTL(NBD_SET_BLKSIZE)
+ULONG_IOCTL(NBD_SET_SIZE)
+COMPATIBLE_IOCTL(NBD_DO_IT)
+COMPATIBLE_IOCTL(NBD_CLEAR_SOCK)
+COMPATIBLE_IOCTL(NBD_CLEAR_QUE)
+COMPATIBLE_IOCTL(NBD_PRINT_DEBUG)
+ULONG_IOCTL(NBD_SET_SIZE_BLOCKS)
+COMPATIBLE_IOCTL(NBD_DISCONNECT)
+/* i2c */
+COMPATIBLE_IOCTL(I2C_SLAVE)
+COMPATIBLE_IOCTL(I2C_SLAVE_FORCE)
+COMPATIBLE_IOCTL(I2C_TENBIT)
+COMPATIBLE_IOCTL(I2C_PEC)
+COMPATIBLE_IOCTL(I2C_RETRIES)
+COMPATIBLE_IOCTL(I2C_TIMEOUT)
+/* wireless */
+COMPATIBLE_IOCTL(SIOCSIWCOMMIT)
+COMPATIBLE_IOCTL(SIOCGIWNAME)
+COMPATIBLE_IOCTL(SIOCSIWNWID)
+COMPATIBLE_IOCTL(SIOCGIWNWID)
+COMPATIBLE_IOCTL(SIOCSIWFREQ)
+COMPATIBLE_IOCTL(SIOCGIWFREQ)
+COMPATIBLE_IOCTL(SIOCSIWMODE)
+COMPATIBLE_IOCTL(SIOCGIWMODE)
+COMPATIBLE_IOCTL(SIOCSIWSENS)
+COMPATIBLE_IOCTL(SIOCGIWSENS)
+COMPATIBLE_IOCTL(SIOCSIWRANGE)
+COMPATIBLE_IOCTL(SIOCSIWPRIV)
+COMPATIBLE_IOCTL(SIOCGIWPRIV)
+COMPATIBLE_IOCTL(SIOCSIWSTATS)
+COMPATIBLE_IOCTL(SIOCGIWSTATS)
+COMPATIBLE_IOCTL(SIOCSIWAP)
+COMPATIBLE_IOCTL(SIOCGIWAP)
+COMPATIBLE_IOCTL(SIOCSIWSCAN)
+COMPATIBLE_IOCTL(SIOCSIWRATE)
+COMPATIBLE_IOCTL(SIOCGIWRATE)
+COMPATIBLE_IOCTL(SIOCSIWRTS)
+COMPATIBLE_IOCTL(SIOCGIWRTS)
+COMPATIBLE_IOCTL(SIOCSIWFRAG)
+COMPATIBLE_IOCTL(SIOCGIWFRAG)
+COMPATIBLE_IOCTL(SIOCSIWTXPOW)
+COMPATIBLE_IOCTL(SIOCGIWTXPOW)
+COMPATIBLE_IOCTL(SIOCSIWRETRY)
+COMPATIBLE_IOCTL(SIOCGIWRETRY)
+COMPATIBLE_IOCTL(SIOCSIWPOWER)
+COMPATIBLE_IOCTL(SIOCGIWPOWER)
+/* hiddev */
+COMPATIBLE_IOCTL(HIDIOCGVERSION)
+COMPATIBLE_IOCTL(HIDIOCAPPLICATION)
+COMPATIBLE_IOCTL(HIDIOCGDEVINFO)
+COMPATIBLE_IOCTL(HIDIOCGSTRING)
+COMPATIBLE_IOCTL(HIDIOCINITREPORT)
+COMPATIBLE_IOCTL(HIDIOCGREPORT)
+COMPATIBLE_IOCTL(HIDIOCSREPORT)
+COMPATIBLE_IOCTL(HIDIOCGREPORTINFO)
+COMPATIBLE_IOCTL(HIDIOCGFIELDINFO)
+COMPATIBLE_IOCTL(HIDIOCGUSAGE)
+COMPATIBLE_IOCTL(HIDIOCSUSAGE)
+COMPATIBLE_IOCTL(HIDIOCGUCODE)
+COMPATIBLE_IOCTL(HIDIOCGFLAG)
+COMPATIBLE_IOCTL(HIDIOCSFLAG)
+COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINDEX)
+COMPATIBLE_IOCTL(HIDIOCGCOLLECTIONINFO)
+/* dvb */
+COMPATIBLE_IOCTL(AUDIO_STOP)
+COMPATIBLE_IOCTL(AUDIO_PLAY)
+COMPATIBLE_IOCTL(AUDIO_PAUSE)
+COMPATIBLE_IOCTL(AUDIO_CONTINUE)
+COMPATIBLE_IOCTL(AUDIO_SELECT_SOURCE)
+COMPATIBLE_IOCTL(AUDIO_SET_MUTE)
+COMPATIBLE_IOCTL(AUDIO_SET_AV_SYNC)
+COMPATIBLE_IOCTL(AUDIO_SET_BYPASS_MODE)
+COMPATIBLE_IOCTL(AUDIO_CHANNEL_SELECT)
+COMPATIBLE_IOCTL(AUDIO_GET_STATUS)
+COMPATIBLE_IOCTL(AUDIO_GET_CAPABILITIES)
+COMPATIBLE_IOCTL(AUDIO_CLEAR_BUFFER)
+COMPATIBLE_IOCTL(AUDIO_SET_ID)
+COMPATIBLE_IOCTL(AUDIO_SET_MIXER)
+COMPATIBLE_IOCTL(AUDIO_SET_STREAMTYPE)
+COMPATIBLE_IOCTL(AUDIO_SET_EXT_ID)
+COMPATIBLE_IOCTL(AUDIO_SET_ATTRIBUTES)
+COMPATIBLE_IOCTL(AUDIO_SET_KARAOKE)
+COMPATIBLE_IOCTL(DMX_START)
+COMPATIBLE_IOCTL(DMX_STOP)
+COMPATIBLE_IOCTL(DMX_SET_FILTER)
+COMPATIBLE_IOCTL(DMX_SET_PES_FILTER)
+COMPATIBLE_IOCTL(DMX_SET_BUFFER_SIZE)
+COMPATIBLE_IOCTL(DMX_GET_PES_PIDS)
+COMPATIBLE_IOCTL(DMX_GET_CAPS)
+COMPATIBLE_IOCTL(DMX_SET_SOURCE)
+COMPATIBLE_IOCTL(DMX_GET_STC)
+COMPATIBLE_IOCTL(FE_GET_INFO)
+COMPATIBLE_IOCTL(FE_DISEQC_RESET_OVERLOAD)
+COMPATIBLE_IOCTL(FE_DISEQC_SEND_MASTER_CMD)
+COMPATIBLE_IOCTL(FE_DISEQC_RECV_SLAVE_REPLY)
+COMPATIBLE_IOCTL(FE_DISEQC_SEND_BURST)
+COMPATIBLE_IOCTL(FE_SET_TONE)
+COMPATIBLE_IOCTL(FE_SET_VOLTAGE)
+COMPATIBLE_IOCTL(FE_ENABLE_HIGH_LNB_VOLTAGE)
+COMPATIBLE_IOCTL(FE_READ_STATUS)
+COMPATIBLE_IOCTL(FE_READ_BER)
+COMPATIBLE_IOCTL(FE_READ_SIGNAL_STRENGTH)
+COMPATIBLE_IOCTL(FE_READ_SNR)
+COMPATIBLE_IOCTL(FE_READ_UNCORRECTED_BLOCKS)
+COMPATIBLE_IOCTL(FE_SET_FRONTEND)
+COMPATIBLE_IOCTL(FE_GET_FRONTEND)
+COMPATIBLE_IOCTL(FE_GET_EVENT)
+COMPATIBLE_IOCTL(FE_DISHNETWORK_SEND_LEGACY_CMD)
+COMPATIBLE_IOCTL(VIDEO_STOP)
+COMPATIBLE_IOCTL(VIDEO_PLAY)
+COMPATIBLE_IOCTL(VIDEO_FREEZE)
+COMPATIBLE_IOCTL(VIDEO_CONTINUE)
+COMPATIBLE_IOCTL(VIDEO_SELECT_SOURCE)
+COMPATIBLE_IOCTL(VIDEO_SET_BLANK)
+COMPATIBLE_IOCTL(VIDEO_GET_STATUS)
+COMPATIBLE_IOCTL(VIDEO_SET_DISPLAY_FORMAT)
+COMPATIBLE_IOCTL(VIDEO_FAST_FORWARD)
+COMPATIBLE_IOCTL(VIDEO_SLOWMOTION)
+COMPATIBLE_IOCTL(VIDEO_GET_CAPABILITIES)
+COMPATIBLE_IOCTL(VIDEO_CLEAR_BUFFER)
+COMPATIBLE_IOCTL(VIDEO_SET_ID)
+COMPATIBLE_IOCTL(VIDEO_SET_STREAMTYPE)
+COMPATIBLE_IOCTL(VIDEO_SET_FORMAT)
+COMPATIBLE_IOCTL(VIDEO_SET_SYSTEM)
+COMPATIBLE_IOCTL(VIDEO_SET_HIGHLIGHT)
+COMPATIBLE_IOCTL(VIDEO_SET_SPU)
+COMPATIBLE_IOCTL(VIDEO_GET_NAVI)
+COMPATIBLE_IOCTL(VIDEO_SET_ATTRIBUTES)
+COMPATIBLE_IOCTL(VIDEO_GET_SIZE)
+COMPATIBLE_IOCTL(VIDEO_GET_FRAME_RATE)
+/* now things that need handlers */
 HANDLE_IOCTL(MEMREADOOB32, mtd_rw_oob)
 HANDLE_IOCTL(MEMWRITEOOB32, mtd_rw_oob)
 #ifdef CONFIG_NET
@@ -2638,4 +3474,156 @@ IGNORE_IOCTL(VFAT_IOCTL_READDIR_BOTH32)
 IGNORE_IOCTL(VFAT_IOCTL_READDIR_SHORT32)
 };
-int ioctl_table_size = ARRAY_SIZE(ioctl_start);
+#define IOCTL_HASHSIZE 256
+static struct ioctl_trans *ioctl32_hash_table[IOCTL_HASHSIZE];
+static inline unsigned long ioctl32_hash(unsigned long cmd)
+{
+        return (((cmd >> 6) ^ (cmd >> 4) ^ cmd)) % IOCTL_HASHSIZE;
+}
+static void compat_ioctl_error(struct file *filp, unsigned int fd,
+                unsigned int cmd, unsigned long arg)
+{
+        char buf[10];
+        char *fn = "?";
+        char *path;
+        /* find the name of the device. */
+        path = (char *)__get_free_page(GFP_KERNEL);
+        if (path) {
+                fn = d_path(filp->f_path.dentry, filp->f_path.mnt, path, PAGE_SIZE);
+                if (IS_ERR(fn))
+                        fn = "?";
+        }
+         sprintf(buf,"'%c'", (cmd>>_IOC_TYPESHIFT) & _IOC_TYPEMASK);
+        if (!isprint(buf[1]))
+                sprintf(buf, "%02x", buf[1]);
+        compat_printk("ioctl32(%s:%d): Unknown cmd fd(%d) "
+                        "cmd(%08x){t:%s;sz:%u} arg(%08x) on %s\n",
+                        current->comm, current->pid,
+                        (int)fd, (unsigned int)cmd, buf,
+                        (cmd >> _IOC_SIZESHIFT) & _IOC_SIZEMASK,
+                        (unsigned int)arg, fn);
+        if (path)
+                free_page((unsigned long)path);
+}
+asmlinkage long compat_sys_ioctl(unsigned int fd, unsigned int cmd,
+                                unsigned long arg)
+{
+        struct file *filp;
+        int error = -EBADF;
+        struct ioctl_trans *t;
+        int fput_needed;
+        filp = fget_light(fd, &fput_needed);
+        if (!filp)
+                goto out;
+        /* RED-PEN how should LSM module know it's handling 32bit? */
+        error = security_file_ioctl(filp, cmd, arg);
+        if (error)
+                goto out_fput;
+        /*
+         * To allow the compat_ioctl handlers to be self contained
+         * we need to check the common ioctls here first.
+         * Just handle them with the standard handlers below.
+         */
+        switch (cmd) {
+        case FIOCLEX:
+        case FIONCLEX:
+        case FIONBIO:
+        case FIOASYNC:
+        case FIOQSIZE:
+                break;
+        case FIBMAP:
+        case FIGETBSZ:
+        case FIONREAD:
+                if (S_ISREG(filp->f_path.dentry->d_inode->i_mode))
+                        break;
+                /*FALL THROUGH*/
+        default:
+                if (filp->f_op && filp->f_op->compat_ioctl) {
+                        error = filp->f_op->compat_ioctl(filp, cmd, arg);
+                        if (error != -ENOIOCTLCMD)
+                                goto out_fput;
+                }
+                if (!filp->f_op ||
+                    (!filp->f_op->ioctl && !filp->f_op->unlocked_ioctl))
+                        goto do_ioctl;
+                break;
+        }
+        for (t = ioctl32_hash_table[ioctl32_hash(cmd)]; t; t = t->next) {
+                if (t->cmd == cmd)
+                        goto found_handler;
+        }
+        if (S_ISSOCK(filp->f_path.dentry->d_inode->i_mode) &&
+            cmd >= SIOCDEVPRIVATE && cmd <= (SIOCDEVPRIVATE + 15)) {
+                error = siocdevprivate_ioctl(fd, cmd, arg);
+        } else {
+                static int count;
+                if (++count <= 50)
+                        compat_ioctl_error(filp, fd, cmd, arg);
+                error = -EINVAL;
+        }
+        goto out_fput;
+ found_handler:
+        if (t->handler) {
+                lock_kernel();
+                error = t->handler(fd, cmd, arg, filp);
+                unlock_kernel();
+                goto out_fput;
+        }
+ do_ioctl:
+        error = vfs_ioctl(filp, fd, cmd, arg);
+ out_fput:
+        fput_light(filp, fput_needed);
+ out:
+        return error;
+}
+static void ioctl32_insert_translation(struct ioctl_trans *trans)
+{
+        unsigned long hash;
+        struct ioctl_trans *t;
+        hash = ioctl32_hash (trans->cmd);
+        if (!ioctl32_hash_table[hash])
+                ioctl32_hash_table[hash] = trans;
+        else {
+                t = ioctl32_hash_table[hash];
+                while (t->next)
+                        t = t->next;
+                trans->next = NULL;
+                t->next = trans;
+        }
+}
+static int __init init_sys32_ioctl(void)
+{
+        int i;
+        for (i = 0; i < ARRAY_SIZE(ioctl_start); i++) {
+                if (ioctl_start[i].next != 0) {
+                        printk("ioctl translation %d bad\n",i);
+                        return -1;
+                }
+                ioctl32_insert_translation(&ioctl_start[i]);
+        }
+        return 0;
+}
+__initcall(init_sys32_ioctl);
diff --git a/fs/dcache.c b/fs/dcache.c
index d1bf5d8aeb5a..0e73aa0a0e8b 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -21,7 +21,6 @@
 #include <linux/fsnotify.h>
 #include <linux/slab.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/hash.h>
 #include <linux/cache.h>
 #include <linux/module.h>
@@ -121,6 +120,28 @@ static void dentry_iput(struct dentry * dentry)
        }
 }
+/**
+ * d_kill - kill dentry and return parent
+ * @dentry: dentry to kill
+ *
+ * Called with dcache_lock and d_lock, releases both.  The dentry must
+ * already be unhashed and removed from the LRU.
+ *
+ * If this is the root of the dentry tree, return NULL.
+ */
+static struct dentry *d_kill(struct dentry *dentry)
+{
+        struct dentry *parent;
+        list_del(&dentry->d_u.d_child);
+        dentry_stat.nr_dentry--;        /* For d_free, below */
+        /*drops the locks, at that point nobody can reach this dentry */
+        dentry_iput(dentry);
+        parent = dentry->d_parent;
+        d_free(dentry);
+        return dentry == parent ? NULL : parent;
+}
 /* 
 * This is dput
 *
@@ -189,28 +210,17 @@ repeat:
 unhash_it:
        __d_drop(dentry);
+kill_it:
-kill_it: {
+        /* If dentry was on d_lru list
-                struct dentry *parent;
+         * delete it from there
+         */
-                /* If dentry was on d_lru list
+        if (!list_empty(&dentry->d_lru)) {
-                 * delete it from there
+                list_del(&dentry->d_lru);
-                 */
+                dentry_stat.nr_unused--;
-                if (!list_empty(&dentry->d_lru)) {
-                        list_del(&dentry->d_lru);
-                        dentry_stat.nr_unused--;
-                }
-                list_del(&dentry->d_u.d_child);
-                dentry_stat.nr_dentry--;        /* For d_free, below */
-                /*drops the locks, at that point nobody can reach this dentry */
-                dentry_iput(dentry);
-                parent = dentry->d_parent;
-                d_free(dentry);
-                if (dentry == parent)
-                        return;
-                dentry = parent;
-                goto repeat;
        }
+        dentry = d_kill(dentry);
+        if (dentry)
+                goto repeat;
 }
 /**
@@ -371,22 +381,40 @@ restart:
 * Throw away a dentry - free the inode, dput the parent.  This requires that
 * the LRU list has already been removed.
 *
+ * If prune_parents is true, try to prune ancestors as well.
+ *
 * Called with dcache_lock, drops it and then regains.
 * Called with dentry->d_lock held, drops it.
 */
-static void prune_one_dentry(struct dentry * dentry)
+static void prune_one_dentry(struct dentry * dentry, int prune_parents)
 {
-        struct dentry * parent;
        __d_drop(dentry);
-        list_del(&dentry->d_u.d_child);
+        dentry = d_kill(dentry);
-        dentry_stat.nr_dentry--;        /* For d_free, below */
+        if (!prune_parents) {
-        dentry_iput(dentry);
+                dput(dentry);
-        parent = dentry->d_parent;
+                spin_lock(&dcache_lock);
-        d_free(dentry);
+                return;
-        if (parent != dentry)
+        }
-                dput(parent);
+        /*
+         * Prune ancestors.  Locking is simpler than in dput(),
+         * because dcache_lock needs to be taken anyway.
+         */
        spin_lock(&dcache_lock);
+        while (dentry) {
+                if (!atomic_dec_and_lock(&dentry->d_count, &dentry->d_lock))
+                        return;
+                if (dentry->d_op && dentry->d_op->d_delete)
+                        dentry->d_op->d_delete(dentry);
+                if (!list_empty(&dentry->d_lru)) {
+                        list_del(&dentry->d_lru);
+                        dentry_stat.nr_unused--;
+                }
+                __d_drop(dentry);
+                dentry = d_kill(dentry);
+                spin_lock(&dcache_lock);
+        }
 }
 /**
@@ -394,6 +422,7 @@ static void prune_one_dentry(struct dentry * dentry)
 * @count: number of entries to try and free
 * @sb: if given, ignore dentries for other superblocks
 *         which are being unmounted.
+ * @prune_parents: if true, try to prune ancestors as well in one go
 *
 * Shrink the dcache. This is done when we need
 * more memory, or simply when we need to unmount
@@ -404,7 +433,7 @@ static void prune_one_dentry(struct dentry * dentry)
 * all the dentries are in use.
 */
 
-static void prune_dcache(int count, struct super_block *sb)
+static void prune_dcache(int count, struct super_block *sb, int prune_parents)
 {
        spin_lock(&dcache_lock);
        for (; count ; count--) {
@@ -464,7 +493,7 @@ static void prune_dcache(int count, struct super_block *sb)
                 * without taking the s_umount lock (I already hold it).
                 */
                if (sb && dentry->d_sb == sb) {
-                        prune_one_dentry(dentry);
+                        prune_one_dentry(dentry, prune_parents);
                        continue;
                }
                /*
@@ -479,7 +508,7 @@ static void prune_dcache(int count, struct super_block *sb)
                s_umount = &dentry->d_sb->s_umount;
                if (down_read_trylock(s_umount)) {
                        if (dentry->d_sb->s_root != NULL) {
-                                prune_one_dentry(dentry);
+                                prune_one_dentry(dentry, prune_parents);
                                up_read(s_umount);
                                continue;
                        }
@@ -550,7 +579,7 @@ repeat:
                        spin_unlock(&dentry->d_lock);
                        continue;
                }
-                prune_one_dentry(dentry);
+                prune_one_dentry(dentry, 1);
                cond_resched_lock(&dcache_lock);
                goto repeat;
        }
@@ -829,7 +858,7 @@ void shrink_dcache_parent(struct dentry * parent)
        int found;
        while ((found = select_parent(parent)) != 0)
-                prune_dcache(found, parent->d_sb);
+                prune_dcache(found, parent->d_sb, 1);
 }
 /*
@@ -849,7 +878,7 @@ static int shrink_dcache_memory(int nr, gfp_t gfp_mask)
        if (nr) {
                if (!(gfp_mask & __GFP_FS))
                        return -1;
-                prune_dcache(nr, NULL);
+                prune_dcache(nr, NULL, 1);
        }
        return (dentry_stat.nr_unused / 100) * sysctl_vfs_cache_pressure;
 }
@@ -1823,6 +1852,16 @@ char * d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
        struct vfsmount *rootmnt;
        struct dentry *root;
+        /*
+         * We have various synthetic filesystems that never get mounted.  On
+         * these filesystems dentries are never used for lookup purposes, and
+         * thus don't need to be hashed.  They also don't need a name until a
+         * user wants to identify the object in /proc/pid/fd/.  The little hack
+         * below allows us to generate a name for these objects on demand:
+         */
+        if (dentry->d_op && dentry->d_op->d_dname)
+                return dentry->d_op->d_dname(dentry, buf, buflen);
        read_lock(&current->fs->lock);
        rootmnt = mntget(current->fs->rootmnt);
        root = dget(current->fs->root);
@@ -1836,6 +1875,27 @@ char * d_path(struct dentry *dentry, struct vfsmount *vfsmnt,
 }
 /*
+ * Helper function for dentry_operations.d_dname() members
+ */
+char *dynamic_dname(struct dentry *dentry, char *buffer, int buflen,
+                        const char *fmt, ...)
+{
+        va_list args;
+        char temp[64];
+        int sz;
+        va_start(args, fmt);
+        sz = vsnprintf(temp, sizeof(temp), fmt, args) + 1;
+        va_end(args);
+        if (sz > sizeof(temp) || sz > buflen)
+                return ERR_PTR(-ENAMETOOLONG);
+        buffer += buflen - sz;
+        return memcpy(buffer, temp, sz);
+}
+/*
 * NOTE! The user-level library version returns a
 * character pointer. The kernel system call just
 * returns the length of the buffer filled (which
diff --git a/fs/devpts/inode.c b/fs/devpts/inode.c
index 643e57b622bd..06ef9a255c76 100644
--- a/fs/devpts/inode.c
+++ b/fs/devpts/inode.c
@@ -19,6 +19,7 @@
 #include <linux/tty.h>
 #include <linux/devpts_fs.h>
 #include <linux/parser.h>
+#include <linux/fsnotify.h>
 #define DEVPTS_SUPER_MAGIC 0x1cd1
@@ -178,8 +179,10 @@ int devpts_pty_new(struct tty_struct *tty)
        inode->i_private = tty;
        dentry = get_node(number);
-        if (!IS_ERR(dentry) && !dentry->d_inode)
+        if (!IS_ERR(dentry) && !dentry->d_inode) {
                d_instantiate(dentry, inode);
+                fsnotify_create(devpts_root->d_inode, dentry);
+        }
        mutex_unlock(&devpts_root->d_inode->i_mutex);
diff --git a/fs/dquot.c b/fs/dquot.c
index 0a5febc159f2..3a995841de90 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -69,7 +69,6 @@
 #include <linux/file.h>
 #include <linux/slab.h>
 #include <linux/sysctl.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/proc_fs.h>
@@ -475,7 +474,7 @@ int vfs_quota_sync(struct super_block *sb, int type)
                spin_lock(&dq_list_lock);
                dirty = &dqopt->info[cnt].dqi_dirty_list;
                while (!list_empty(dirty)) {
-                        dquot = list_entry(dirty->next, struct dquot, dq_dirty);
+                        dquot = list_first_entry(dirty, struct dquot, dq_dirty);
                        /* Dirty and inactive can be only bad dquot... */
                        if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
                                clear_dquot_dirty(dquot);
@@ -721,7 +720,8 @@ static inline int dqput_blocks(struct dquot *dquot)
 /* Remove references to dquots from inode - add dquot to list for freeing if needed */
 /* We can't race with anybody because we hold dqptr_sem for writing... */
-int remove_inode_dquot_ref(struct inode *inode, int type, struct list_head *tofree_head)
+static int remove_inode_dquot_ref(struct inode *inode, int type,
+                                  struct list_head *tofree_head)
 {
        struct dquot *dquot = inode->i_dquot[type];
diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index 7a7d25d541e7..9881b5c5de59 100644
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -28,7 +28,6 @@
 #include <linux/mount.h>
 #include <linux/pagemap.h>
 #include <linux/security.h>
-#include <linux/smp_lock.h>
 #include <linux/compat.h>
 #include <linux/fs_stack.h>
 #include "ecryptfs_kernel.h"
diff --git a/fs/eventpoll.c b/fs/eventpoll.c
index 3ae644e7e860..b5c7ca584939 100644
--- a/fs/eventpoll.c
+++ b/fs/eventpoll.c
@@ -22,7 +22,6 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/poll.h>
-#include <linux/smp_lock.h>
 #include <linux/string.h>
 #include <linux/list.h>
 #include <linux/hash.h>
@@ -185,7 +184,7 @@ struct eppoll_entry {
 /*
 * Each file descriptor added to the eventpoll interface will
- * have an entry of this type linked to the hash.
+ * have an entry of this type linked to the "rbr" RB tree.
 */
 struct epitem {
        /* RB-Tree node used to link this structure to the eventpoll rb-tree */
@@ -217,15 +216,6 @@ struct epitem {
        /* List header used to link this item to the "struct file" items list */
        struct list_head fllink;
-        /* List header used to link the item to the transfer list */
-        struct list_head txlink;
-        /*
-         * This is used during the collection/transfer of events to userspace
-         * to pin items empty events set.
-         */
-        unsigned int revents;
 };
 /* Wrapper struct used by poll queueing */
@@ -258,11 +248,8 @@ static int ep_remove(struct eventpoll *ep, struct epitem *epi);
 static int ep_poll_callback(wait_queue_t *wait, unsigned mode, int sync, void *key);
 static int ep_eventpoll_close(struct inode *inode, struct file *file);
 static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait);
-static int ep_collect_ready_items(struct eventpoll *ep,
-                                  struct list_head *txlist, int maxevents);
 static int ep_send_events(struct eventpoll *ep, struct list_head *txlist,
-                          struct epoll_event __user *events);
+                          struct epoll_event __user *events, int maxevents);
-static void ep_reinject_items(struct eventpoll *ep, struct list_head *txlist);
 static int ep_events_transfer(struct eventpoll *ep,
                              struct epoll_event __user *events,
                              int maxevents);
@@ -355,17 +342,6 @@ static inline int ep_rb_linked(struct rb_node *n)
        return rb_parent(n) != n;
 }
-/*
- * Remove the item from the list and perform its initialization.
- * This is useful for us because we can test if the item is linked
- * using "ep_is_linked(p)".
- */
-static inline void ep_list_del(struct list_head *p)
-{
-        list_del(p);
-        INIT_LIST_HEAD(p);
-}
 /* Tells us if the item is currently linked */
 static inline int ep_is_linked(struct list_head *p)
 {
@@ -385,7 +361,7 @@ static inline struct epitem * ep_item_from_epqueue(poll_table *p)
 }
 /* Tells if the epoll_ctl(2) operation needs an event copy from userspace */
-static inline int ep_op_hash_event(int op)
+static inline int ep_op_has_event(int op)
 {
        return op != EPOLL_CTL_DEL;
 }
@@ -477,10 +453,10 @@ void eventpoll_release_file(struct file *file)
        mutex_lock(&epmutex);
        while (!list_empty(lsthead)) {
-                epi = list_entry(lsthead->next, struct epitem, fllink);
+                epi = list_first_entry(lsthead, struct epitem, fllink);
                ep = epi->ep;
-                ep_list_del(&epi->fllink);
+                list_del_init(&epi->fllink);
                down_write(&ep->sem);
                ep_remove(ep, epi);
                up_write(&ep->sem);
@@ -557,7 +533,7 @@ sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event __user *event)
                     current, epfd, op, fd, event));
        error = -EFAULT;
-        if (ep_op_hash_event(op) &&
+        if (ep_op_has_event(op) &&
            copy_from_user(&epds, event, sizeof(struct epoll_event)))
                goto eexit_1;
@@ -594,7 +570,7 @@ sys_epoll_ctl(int epfd, int op, int fd, struct epoll_event __user *event)
        down_write(&ep->sem);
-        /* Try to lookup the file inside our hash table */
+        /* Try to lookup the file inside our RB tree */
        epi = ep_find(ep, tfile, fd);
        error = -EINVAL;
@@ -876,7 +852,7 @@ static void ep_free(struct eventpoll *ep)
        }
        /*
-         * Walks through the whole hash by freeing each "struct epitem". At this
+         * Walks through the whole tree by freeing each "struct epitem". At this
         * point we are sure no poll callbacks will be lingering around, and also by
         * write-holding "sem" we can be sure that no file cleanup code will hit
         * us during this operation. So we can avoid the lock on "ep->lock".
@@ -891,7 +867,7 @@ static void ep_free(struct eventpoll *ep)
 /*
- * Search the file inside the eventpoll hash. It add usage count to
+ * Search the file inside the eventpoll tree. It add usage count to
 * the returned item, so the caller must call ep_release_epitem()
 * after finished using the "struct epitem".
 */
@@ -1011,7 +987,6 @@ static int ep_insert(struct eventpoll *ep, struct epoll_event *event,
        ep_rb_initnode(&epi->rbn);
        INIT_LIST_HEAD(&epi->rdllink);
        INIT_LIST_HEAD(&epi->fllink);
-        INIT_LIST_HEAD(&epi->txlink);
        INIT_LIST_HEAD(&epi->pwqlist);
        epi->ep = ep;
        ep_set_ffd(&epi->ffd, tfile, fd);
@@ -1080,7 +1055,7 @@ eexit_2:
         */
        write_lock_irqsave(&ep->lock, flags);
        if (ep_is_linked(&epi->rdllink))
-                ep_list_del(&epi->rdllink);
+                list_del_init(&epi->rdllink);
        write_unlock_irqrestore(&ep->lock, flags);
        kmem_cache_free(epi_cache, epi);
@@ -1119,7 +1094,7 @@ static int ep_modify(struct eventpoll *ep, struct epitem *epi, struct epoll_even
        epi->event.data = event->data;
        /*
-         * If the item is not linked to the hash it means that it's on its
+         * If the item is not linked to the RB tree it means that it's on its
         * way toward the removal. Do nothing in this case.
         */
        if (ep_rb_linked(&epi->rbn)) {
@@ -1168,9 +1143,9 @@ static void ep_unregister_pollwait(struct eventpoll *ep, struct epitem *epi)
        if (nwait) {
                while (!list_empty(lsthead)) {
-                        pwq = list_entry(lsthead->next, struct eppoll_entry, llink);
+                        pwq = list_first_entry(lsthead, struct eppoll_entry, llink);
-                        ep_list_del(&pwq->llink);
+                        list_del_init(&pwq->llink);
                        remove_wait_queue(pwq->whead, &pwq->wait);
                        kmem_cache_free(pwq_cache, pwq);
                }
@@ -1213,7 +1188,7 @@ static int ep_unlink(struct eventpoll *ep, struct epitem *epi)
         * we want to remove it from this list to avoid stale events.
         */
        if (ep_is_linked(&epi->rdllink))
-                ep_list_del(&epi->rdllink);
+                list_del_init(&epi->rdllink);
        error = 0;
 eexit_1:
@@ -1226,7 +1201,7 @@ eexit_1:
 /*
- * Removes a "struct epitem" from the eventpoll hash and deallocates
+ * Removes a "struct epitem" from the eventpoll RB tree and deallocates
 * all the associated resources.
 */
 static int ep_remove(struct eventpoll *ep, struct epitem *epi)
@@ -1248,13 +1223,13 @@ static int ep_remove(struct eventpoll *ep, struct epitem *epi)
        /* Remove the current item from the list of epoll hooks */
        spin_lock(&file->f_ep_lock);
        if (ep_is_linked(&epi->fllink))
-                ep_list_del(&epi->fllink);
+                list_del_init(&epi->fllink);
        spin_unlock(&file->f_ep_lock);
        /* We need to acquire the write IRQ lock before calling ep_unlink() */
        write_lock_irqsave(&ep->lock, flags);
-        /* Really unlink the item from the hash */
+        /* Really unlink the item from the RB tree */
        error = ep_unlink(ep, epi);
        write_unlock_irqrestore(&ep->lock, flags);
@@ -1362,71 +1337,30 @@ static unsigned int ep_eventpoll_poll(struct file *file, poll_table *wait)
 /*
- * Since we have to release the lock during the __copy_to_user() operation and
- * during the f_op->poll() call, we try to collect the maximum number of items
- * by reducing the irqlock/irqunlock switching rate.
- */
-static int ep_collect_ready_items(struct eventpoll *ep, struct list_head *txlist, int maxevents)
-{
-        int nepi;
-        unsigned long flags;
-        struct list_head *lsthead = &ep->rdllist, *lnk;
-        struct epitem *epi;
-        write_lock_irqsave(&ep->lock, flags);
-        for (nepi = 0, lnk = lsthead->next; lnk != lsthead && nepi < maxevents;) {
-                epi = list_entry(lnk, struct epitem, rdllink);
-                lnk = lnk->next;
-                /* If this file is already in the ready list we exit soon */
-                if (!ep_is_linked(&epi->txlink)) {
-                        /*
-                         * This is initialized in this way so that the default
-                         * behaviour of the reinjecting code will be to push back
-                         * the item inside the ready list.
-                         */
-                        epi->revents = epi->event.events;
-                        /* Link the ready item into the transfer list */
-                        list_add(&epi->txlink, txlist);
-                        nepi++;
-                        /*
-                         * Unlink the item from the ready list.
-                         */
-                        ep_list_del(&epi->rdllink);
-                }
-        }
-        write_unlock_irqrestore(&ep->lock, flags);
-        return nepi;
-}
-/*
 * This function is called without holding the "ep->lock" since the call to
 * __copy_to_user() might sleep, and also f_op->poll() might reenable the IRQ
 * because of the way poll() is traditionally implemented in Linux.
 */
 static int ep_send_events(struct eventpoll *ep, struct list_head *txlist,
-                          struct epoll_event __user *events)
+                          struct epoll_event __user *events, int maxevents)
 {
-        int eventcnt = 0;
+        int eventcnt, error = -EFAULT, pwake = 0;
        unsigned int revents;
-        struct list_head *lnk;
+        unsigned long flags;
        struct epitem *epi;
+        struct list_head injlist;
+        INIT_LIST_HEAD(&injlist);
        /*
         * We can loop without lock because this is a task private list.
-         * The test done during the collection loop will guarantee us that
+         * We just splice'd out the ep->rdllist in ep_collect_ready_items().
-         * another task will not try to collect this file. Also, items
+         * Items cannot vanish during the loop because we are holding "sem" in
-         * cannot vanish during the loop because we are holding "sem".
+         * read.
         */
-        list_for_each(lnk, txlist) {
+        for (eventcnt = 0; !list_empty(txlist) && eventcnt < maxevents;) {
-                epi = list_entry(lnk, struct epitem, txlink);
+                epi = list_first_entry(txlist, struct epitem, rdllink);
+                prefetch(epi->rdllink.next);
                /*
                 * Get the ready file event set. We can safely use the file
@@ -1434,64 +1368,65 @@ static int ep_send_events(struct eventpoll *ep, struct list_head *txlist,
                 * guarantee that both the file and the item will not vanish.
                 */
                revents = epi->ffd.file->f_op->poll(epi->ffd.file, NULL);
+                revents &= epi->event.events;
                /*
-                 * Set the return event set for the current file descriptor.
+                 * Is the event mask intersect the caller-requested one,
-                 * Note that only the task task was successfully able to link
+                 * deliver the event to userspace. Again, we are holding
-                 * the item to its "txlist" will write this field.
+                 * "sem" in read, so no operations coming from userspace
+                 * can change the item.
                 */
-                epi->revents = revents & epi->event.events;
+                if (revents) {
+                        if (__put_user(revents,
-                if (epi->revents) {
-                        if (__put_user(epi->revents,
                                       &events[eventcnt].events) ||
                            __put_user(epi->event.data,
                                       &events[eventcnt].data))
-                                return -EFAULT;
+                                goto errxit;
                        if (epi->event.events & EPOLLONESHOT)
                                epi->event.events &= EP_PRIVATE_BITS;
                        eventcnt++;
                }
-        }
-        return eventcnt;
-}
-/*
- * Walk through the transfer list we collected with ep_collect_ready_items()
- * and, if 1) the item is still "alive" 2) its event set is not empty 3) it's
- * not already linked, links it to the ready list. Same as above, we are holding
- * "sem" so items cannot vanish underneath our nose.
- */
-static void ep_reinject_items(struct eventpoll *ep, struct list_head *txlist)
-{
-        int ricnt = 0, pwake = 0;
-        unsigned long flags;
-        struct epitem *epi;
-        write_lock_irqsave(&ep->lock, flags);
-        while (!list_empty(txlist)) {
-                epi = list_entry(txlist->next, struct epitem, txlink);
-                /* Unlink the current item from the transfer list */
-                ep_list_del(&epi->txlink);
                /*
-                 * If the item is no more linked to the interest set, we don't
+                 * This is tricky. We are holding the "sem" in read, and this
-                 * have to push it inside the ready list because the following
+                 * means that the operations that can change the "linked" status
-                 * ep_release_epitem() is going to drop it. Also, if the current
+                 * of the epoll item (epi->rbn and epi->rdllink), cannot touch
-                 * item is set to have an Edge Triggered behaviour, we don't have
+                 * them.  Also, since we are "linked" from a epi->rdllink POV
-                 * to push it back either.
+                 * (the item is linked to our transmission list we just
+                 * spliced), the ep_poll_callback() cannot touch us either,
+                 * because of the check present in there. Another parallel
+                 * epoll_wait() will not get the same result set, since we
+                 * spliced the ready list before.  Note that list_del() still
+                 * shows the item as linked to the test in ep_poll_callback().
                 */
-                if (ep_rb_linked(&epi->rbn) && !(epi->event.events & EPOLLET) &&
+                list_del(&epi->rdllink);
-                    (epi->revents & epi->event.events) && !ep_is_linked(&epi->rdllink)) {
+                if (!(epi->event.events & EPOLLET) &&
-                        list_add_tail(&epi->rdllink, &ep->rdllist);
+                                (revents & epi->event.events))
-                        ricnt++;
+                        list_add_tail(&epi->rdllink, &injlist);
+                else {
+                        /*
+                         * Be sure the item is totally detached before re-init
+                         * the list_head. After INIT_LIST_HEAD() is committed,
+                         * the ep_poll_callback() can requeue the item again,
+                         * but we don't care since we are already past it.
+                         */
+                        smp_mb();
+                        INIT_LIST_HEAD(&epi->rdllink);
                }
        }
+        error = 0;
-        if (ricnt) {
+        errxit:
+        /*
+         * If the re-injection list or the txlist are not empty, re-splice
+         * them to the ready list and do proper wakeups.
+         */
+        if (!list_empty(&injlist) || !list_empty(txlist)) {
+                write_lock_irqsave(&ep->lock, flags);
+                list_splice(txlist, &ep->rdllist);
+                list_splice(&injlist, &ep->rdllist);
                /*
                 * Wake up ( if active ) both the eventpoll wait list and the ->poll()
                 * wait list.
@@ -1501,13 +1436,15 @@ static void ep_reinject_items(struct eventpoll *ep, struct list_head *txlist)
                                         TASK_INTERRUPTIBLE);
                if (waitqueue_active(&ep->poll_wait))
                        pwake++;
-        }
-        write_unlock_irqrestore(&ep->lock, flags);
+                write_unlock_irqrestore(&ep->lock, flags);
+        }
        /* We have to call this outside the lock */
        if (pwake)
                ep_poll_safewake(&psw, &ep->poll_wait);
+        return eventcnt == 0 ? error: eventcnt;
 }
@@ -1517,7 +1454,8 @@ static void ep_reinject_items(struct eventpoll *ep, struct list_head *txlist)
 static int ep_events_transfer(struct eventpoll *ep,
                              struct epoll_event __user *events, int maxevents)
 {
-        int eventcnt = 0;
+        int eventcnt;
+        unsigned long flags;
        struct list_head txlist;
        INIT_LIST_HEAD(&txlist);
@@ -1528,14 +1466,17 @@ static int ep_events_transfer(struct eventpoll *ep,
         */
        down_read(&ep->sem);
-        /* Collect/extract ready items */
+        /*
-        if (ep_collect_ready_items(ep, &txlist, maxevents) > 0) {
+         * Steal the ready list, and re-init the original one to the
-                /* Build result set in userspace */
+         * empty list.
-                eventcnt = ep_send_events(ep, &txlist, events);
+         */
+        write_lock_irqsave(&ep->lock, flags);
+        list_splice(&ep->rdllist, &txlist);
+        INIT_LIST_HEAD(&ep->rdllist);
+        write_unlock_irqrestore(&ep->lock, flags);
-                /* Reinject ready items into the ready list */
+        /* Build result set in userspace */
-                ep_reinject_items(ep, &txlist);
+        eventcnt = ep_send_events(ep, &txlist, events, maxevents);
-        }
        up_read(&ep->sem);
@@ -1612,14 +1553,12 @@ retry:
        return res;
 }
 static int eventpollfs_delete_dentry(struct dentry *dentry)
 {
        return 1;
 }
 static struct inode *ep_eventpoll_inode(void)
 {
        int error = -ENOMEM;
@@ -1647,7 +1586,6 @@ eexit_1:
        return ERR_PTR(error);
 }
 static int
 eventpollfs_get_sb(struct file_system_type *fs_type, int flags,
                   const char *dev_name, void *data, struct vfsmount *mnt)
diff --git a/fs/exec.c b/fs/exec.c
index 3155e915307a..1ba85c7fc6af 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -100,6 +100,7 @@ int unregister_binfmt(struct linux_binfmt * fmt)
        while (*tmp) {
                if (fmt == *tmp) {
                        *tmp = fmt->next;
+                        fmt->next = NULL;
                        write_unlock(&binfmt_lock);
                        return 0;
                }
@@ -982,33 +983,51 @@ void compute_creds(struct linux_binprm *bprm)
        task_unlock(current);
        security_bprm_post_apply_creds(bprm);
 }
 EXPORT_SYMBOL(compute_creds);
+/*
+ * Arguments are '\0' separated strings found at the location bprm->p
+ * points to; chop off the first by relocating brpm->p to right after
+ * the first '\0' encountered.
+ */
 void remove_arg_zero(struct linux_binprm *bprm)
 {
        if (bprm->argc) {
-                unsigned long offset;
+                char ch;
-                char * kaddr;
-                struct page *page;
-                offset = bprm->p % PAGE_SIZE;
+                do {
-                goto inside;
+                        unsigned long offset;
+                        unsigned long index;
+                        char *kaddr;
+                        struct page *page;
-                while (bprm->p++, *(kaddr+offset++)) {
+                        offset = bprm->p & ~PAGE_MASK;
-                        if (offset != PAGE_SIZE)
+                        index = bprm->p >> PAGE_SHIFT;
-                                continue;
-                        offset = 0;
+                        page = bprm->page[index];
-                        kunmap_atomic(kaddr, KM_USER0);
-inside:
-                        page = bprm->page[bprm->p/PAGE_SIZE];
                        kaddr = kmap_atomic(page, KM_USER0);
-                }
-                kunmap_atomic(kaddr, KM_USER0);
+                        /* run through page until we reach end or find NUL */
+                        do {
+                                ch = *(kaddr + offset);
+                                /* discard that character... */
+                                bprm->p++;
+                                offset++;
+                        } while (offset < PAGE_SIZE && ch != '\0');
+                        kunmap_atomic(kaddr, KM_USER0);
+                        /* free the old page */
+                        if (offset == PAGE_SIZE) {
+                                __free_page(page);
+                                bprm->page[index] = NULL;
+                        }
+                } while (ch != '\0');
                bprm->argc--;
        }
 }
 EXPORT_SYMBOL(remove_arg_zero);
 /*
diff --git a/fs/exportfs/expfs.c b/fs/exportfs/expfs.c
index 93e77c3d2490..e98f6cd7200c 100644
--- a/fs/exportfs/expfs.c
+++ b/fs/exportfs/expfs.c
@@ -2,7 +2,6 @@
 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/namei.h>
 struct export_operations export_op_default;
diff --git a/fs/ext2/dir.c b/fs/ext2/dir.c
index 1d1e7e30d70e..2bf49d7ef841 100644
--- a/fs/ext2/dir.c
+++ b/fs/ext2/dir.c
@@ -23,7 +23,6 @@
 #include "ext2.h"
 #include <linux/pagemap.h>
-#include <linux/smp_lock.h>
 typedef struct ext2_dir_entry_2 ext2_dirent;
diff --git a/fs/ext2/ext2.h b/fs/ext2/ext2.h
index e2a0ea50af1d..9fd0ec5ba0d0 100644
--- a/fs/ext2/ext2.h
+++ b/fs/ext2/ext2.h
@@ -133,6 +133,7 @@ extern int ext2_get_block(struct inode *, sector_t, struct buffer_head *, int);
 extern void ext2_truncate (struct inode *);
 extern int ext2_setattr (struct dentry *, struct iattr *);
 extern void ext2_set_inode_flags(struct inode *inode);
+extern void ext2_get_inode_flags(struct ext2_inode_info *);
 /* ioctl.c */
 extern int ext2_ioctl (struct inode *, struct file *, unsigned int,
diff --git a/fs/ext2/fsync.c b/fs/ext2/fsync.c
index 7806b9e8155b..fc66c93fcb5c 100644
--- a/fs/ext2/fsync.c
+++ b/fs/ext2/fsync.c
@@ -23,7 +23,6 @@
 */
 #include "ext2.h"
-#include <linux/smp_lock.h>
 #include <linux/buffer_head.h>          /* for sync_mapping_buffers() */
diff --git a/fs/ext2/inode.c b/fs/ext2/inode.c
index dd4e14c221e0..0079b2cd5314 100644
--- a/fs/ext2/inode.c
+++ b/fs/ext2/inode.c
@@ -1055,6 +1055,25 @@ void ext2_set_inode_flags(struct inode *inode)
                inode->i_flags |= S_DIRSYNC;
 }
+/* Propagate flags from i_flags to EXT2_I(inode)->i_flags */
+void ext2_get_inode_flags(struct ext2_inode_info *ei)
+{
+        unsigned int flags = ei->vfs_inode.i_flags;
+        ei->i_flags &= ~(EXT2_SYNC_FL|EXT2_APPEND_FL|
+                        EXT2_IMMUTABLE_FL|EXT2_NOATIME_FL|EXT2_DIRSYNC_FL);
+        if (flags & S_SYNC)
+                ei->i_flags |= EXT2_SYNC_FL;
+        if (flags & S_APPEND)
+                ei->i_flags |= EXT2_APPEND_FL;
+        if (flags & S_IMMUTABLE)
+                ei->i_flags |= EXT2_IMMUTABLE_FL;
+        if (flags & S_NOATIME)
+                ei->i_flags |= EXT2_NOATIME_FL;
+        if (flags & S_DIRSYNC)
+                ei->i_flags |= EXT2_DIRSYNC_FL;
+}
 void ext2_read_inode (struct inode * inode)
 {
        struct ext2_inode_info *ei = EXT2_I(inode);
@@ -1079,9 +1098,9 @@ void ext2_read_inode (struct inode * inode)
        }
        inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
        inode->i_size = le32_to_cpu(raw_inode->i_size);
-        inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
+        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
-        inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
+        inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
-        inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
+        inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
        inode->i_atime.tv_nsec = inode->i_mtime.tv_nsec = inode->i_ctime.tv_nsec = 0;
        ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
        /* We now have enough fields to check if the inode was active or not.
@@ -1188,6 +1207,7 @@ static int ext2_update_inode(struct inode * inode, int do_sync)
        if (ei->i_state & EXT2_STATE_NEW)
                memset(raw_inode, 0, EXT2_SB(sb)->s_inode_size);
+        ext2_get_inode_flags(ei);
        raw_inode->i_mode = cpu_to_le16(inode->i_mode);
        if (!(test_opt(sb, NO_UID32))) {
                raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
diff --git a/fs/ext2/ioctl.c b/fs/ext2/ioctl.c
index 4b099d310712..e85c48218239 100644
--- a/fs/ext2/ioctl.c
+++ b/fs/ext2/ioctl.c
@@ -27,6 +27,7 @@ int ext2_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
        switch (cmd) {
        case EXT2_IOC_GETFLAGS:
+                ext2_get_inode_flags(ei);
                flags = ei->i_flags & EXT2_FL_USER_VISIBLE;
                return put_user(flags, (int __user *) arg);
        case EXT2_IOC_SETFLAGS: {
diff --git a/fs/ext2/xattr_security.c b/fs/ext2/xattr_security.c
index a26612798471..eaa23d2d5213 100644
--- a/fs/ext2/xattr_security.c
+++ b/fs/ext2/xattr_security.c
@@ -6,7 +6,6 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext2_fs.h>
 #include <linux/security.h>
 #include "xattr.h"
diff --git a/fs/ext2/xattr_trusted.c b/fs/ext2/xattr_trusted.c
index f28a6a499c96..83ee149f353d 100644
--- a/fs/ext2/xattr_trusted.c
+++ b/fs/ext2/xattr_trusted.c
@@ -9,7 +9,6 @@
 #include <linux/string.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext2_fs.h>
 #include "xattr.h"
diff --git a/fs/ext3/dir.c b/fs/ext3/dir.c
index 665adee99b31..852869840f24 100644
--- a/fs/ext3/dir.c
+++ b/fs/ext3/dir.c
@@ -25,7 +25,6 @@
 #include <linux/jbd.h>
 #include <linux/ext3_fs.h>
 #include <linux/buffer_head.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/rbtree.h>
diff --git a/fs/ext3/inode.c b/fs/ext3/inode.c
index a5b150f7e8a2..e1bb03171986 100644
--- a/fs/ext3/inode.c
+++ b/fs/ext3/inode.c
@@ -27,7 +27,6 @@
 #include <linux/time.h>
 #include <linux/ext3_jbd.h>
 #include <linux/jbd.h>
-#include <linux/smp_lock.h>
 #include <linux/highuid.h>
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
@@ -2581,6 +2580,25 @@ void ext3_set_inode_flags(struct inode *inode)
                inode->i_flags |= S_DIRSYNC;
 }
+/* Propagate flags from i_flags to EXT3_I(inode)->i_flags */
+void ext3_get_inode_flags(struct ext3_inode_info *ei)
+{
+        unsigned int flags = ei->vfs_inode.i_flags;
+        ei->i_flags &= ~(EXT3_SYNC_FL|EXT3_APPEND_FL|
+                        EXT3_IMMUTABLE_FL|EXT3_NOATIME_FL|EXT3_DIRSYNC_FL);
+        if (flags & S_SYNC)
+                ei->i_flags |= EXT3_SYNC_FL;
+        if (flags & S_APPEND)
+                ei->i_flags |= EXT3_APPEND_FL;
+        if (flags & S_IMMUTABLE)
+                ei->i_flags |= EXT3_IMMUTABLE_FL;
+        if (flags & S_NOATIME)
+                ei->i_flags |= EXT3_NOATIME_FL;
+        if (flags & S_DIRSYNC)
+                ei->i_flags |= EXT3_DIRSYNC_FL;
+}
 void ext3_read_inode(struct inode * inode)
 {
        struct ext3_iloc iloc;
@@ -2608,9 +2626,9 @@ void ext3_read_inode(struct inode * inode)
        }
        inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
        inode->i_size = le32_to_cpu(raw_inode->i_size);
-        inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
+        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
-        inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
+        inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
-        inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
+        inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
        inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
        ei->i_state = 0;
@@ -2736,6 +2754,7 @@ static int ext3_do_update_inode(handle_t *handle,
        if (ei->i_state & EXT3_STATE_NEW)
                memset(raw_inode, 0, EXT3_SB(inode->i_sb)->s_inode_size);
+        ext3_get_inode_flags(ei);
        raw_inode->i_mode = cpu_to_le16(inode->i_mode);
        if(!(test_opt(inode->i_sb, NO_UID32))) {
                raw_inode->i_uid_low = cpu_to_le16(low_16_bits(inode->i_uid));
diff --git a/fs/ext3/ioctl.c b/fs/ext3/ioctl.c
index 9b8090d94e6c..965006dba6be 100644
--- a/fs/ext3/ioctl.c
+++ b/fs/ext3/ioctl.c
@@ -28,6 +28,7 @@ int ext3_ioctl (struct inode * inode, struct file * filp, unsigned int cmd,
        switch (cmd) {
        case EXT3_IOC_GETFLAGS:
+                ext3_get_inode_flags(ei);
                flags = ei->i_flags & EXT3_FL_USER_VISIBLE;
                return put_user(flags, (int __user *) arg);
        case EXT3_IOC_SETFLAGS: {
diff --git a/fs/ext3/namei.c b/fs/ext3/namei.c
index 49159f13cc1f..9bb046df827a 100644
--- a/fs/ext3/namei.c
+++ b/fs/ext3/namei.c
@@ -36,7 +36,6 @@
 #include <linux/quotaops.h>
 #include <linux/buffer_head.h>
 #include <linux/bio.h>
-#include <linux/smp_lock.h>
 #include "namei.h"
 #include "xattr.h"
@@ -969,6 +968,7 @@ static struct buffer_head * ext3_dx_find_entry(struct dentry *dentry,
                                  (block<<EXT3_BLOCK_SIZE_BITS(sb))
                                          +((char *)de - bh->b_data))) {
                                brelse (bh);
+                                *err = ERR_BAD_DX_DIR;
                                goto errout;
                        }
                        *res_dir = de;
@@ -1134,9 +1134,9 @@ static struct ext3_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
        char *data1 = (*bh)->b_data, *data2;
        unsigned split;
        struct ext3_dir_entry_2 *de = NULL, *de2;
-        int     err;
+        int     err = 0;
-        bh2 = ext3_append (handle, dir, &newblock, error);
+        bh2 = ext3_append (handle, dir, &newblock, &err);
        if (!(bh2)) {
                brelse(*bh);
                *bh = NULL;
@@ -1145,14 +1145,9 @@ static struct ext3_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
        BUFFER_TRACE(*bh, "get_write_access");
        err = ext3_journal_get_write_access(handle, *bh);
-        if (err) {
+        if (err)
-        journal_error:
+                goto journal_error;
-                brelse(*bh);
-                brelse(bh2);
-                *bh = NULL;
-                ext3_std_error(dir->i_sb, err);
-                goto errout;
-        }
        BUFFER_TRACE(frame->bh, "get_write_access");
        err = ext3_journal_get_write_access(handle, frame->bh);
        if (err)
@@ -1195,8 +1190,16 @@ static struct ext3_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
                goto journal_error;
        brelse (bh2);
        dxtrace(dx_show_index ("frame", frame->entries));
-errout:
        return de;
+journal_error:
+        brelse(*bh);
+        brelse(bh2);
+        *bh = NULL;
+        ext3_std_error(dir->i_sb, err);
+errout:
+        *error = err;
+        return NULL;
 }
 #endif
diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index ecf89904c113..2c97e09c6c6b 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -11,7 +11,6 @@
 #define EXT3FS_DEBUG
-#include <linux/smp_lock.h>
 #include <linux/ext3_jbd.h>
 #include <linux/errno.h>
diff --git a/fs/ext3/xattr_security.c b/fs/ext3/xattr_security.c
index b9c40c15647b..821efaf2b94e 100644
--- a/fs/ext3/xattr_security.c
+++ b/fs/ext3/xattr_security.c
@@ -6,7 +6,6 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext3_jbd.h>
 #include <linux/ext3_fs.h>
 #include <linux/security.h>
diff --git a/fs/ext3/xattr_trusted.c b/fs/ext3/xattr_trusted.c
index 86d91f1186dc..0327497a55ce 100644
--- a/fs/ext3/xattr_trusted.c
+++ b/fs/ext3/xattr_trusted.c
@@ -9,7 +9,6 @@
 #include <linux/string.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext3_jbd.h>
 #include <linux/ext3_fs.h>
 #include "xattr.h"
diff --git a/fs/ext3/xattr_user.c b/fs/ext3/xattr_user.c
index a85a0a17c4fd..1abd8f92c440 100644
--- a/fs/ext3/xattr_user.c
+++ b/fs/ext3/xattr_user.c
@@ -8,7 +8,6 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext3_jbd.h>
 #include <linux/ext3_fs.h>
 #include "xattr.h"
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index da80368b66f0..e8ad06e28318 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -25,7 +25,6 @@
 #include <linux/jbd2.h>
 #include <linux/ext4_fs.h>
 #include <linux/buffer_head.h>
-#include <linux/smp_lock.h>
 #include <linux/slab.h>
 #include <linux/rbtree.h>
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index 7916b50f9a13..a0f0c04e79b2 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -34,7 +34,6 @@
 #include <linux/time.h>
 #include <linux/ext4_jbd2.h>
 #include <linux/jbd.h>
-#include <linux/smp_lock.h>
 #include <linux/highuid.h>
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 810b6d6474bf..b34182b6ee4d 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -27,7 +27,6 @@
 #include <linux/time.h>
 #include <linux/ext4_jbd2.h>
 #include <linux/jbd2.h>
-#include <linux/smp_lock.h>
 #include <linux/highuid.h>
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
@@ -2611,9 +2610,9 @@ void ext4_read_inode(struct inode * inode)
        }
        inode->i_nlink = le16_to_cpu(raw_inode->i_links_count);
        inode->i_size = le32_to_cpu(raw_inode->i_size);
-        inode->i_atime.tv_sec = le32_to_cpu(raw_inode->i_atime);
+        inode->i_atime.tv_sec = (signed)le32_to_cpu(raw_inode->i_atime);
-        inode->i_ctime.tv_sec = le32_to_cpu(raw_inode->i_ctime);
+        inode->i_ctime.tv_sec = (signed)le32_to_cpu(raw_inode->i_ctime);
-        inode->i_mtime.tv_sec = le32_to_cpu(raw_inode->i_mtime);
+        inode->i_mtime.tv_sec = (signed)le32_to_cpu(raw_inode->i_mtime);
        inode->i_atime.tv_nsec = inode->i_ctime.tv_nsec = inode->i_mtime.tv_nsec = 0;
        ei->i_state = 0;
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index e7e1d79a7d75..4ec57be5baf5 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -36,7 +36,6 @@
 #include <linux/quotaops.h>
 #include <linux/buffer_head.h>
 #include <linux/bio.h>
-#include <linux/smp_lock.h>
 #include "namei.h"
 #include "xattr.h"
@@ -967,6 +966,7 @@ static struct buffer_head * ext4_dx_find_entry(struct dentry *dentry,
                                  (block<<EXT4_BLOCK_SIZE_BITS(sb))
                                          +((char *)de - bh->b_data))) {
                                brelse (bh);
+                                *err = ERR_BAD_DX_DIR;
                                goto errout;
                        }
                        *res_dir = de;
@@ -1132,9 +1132,9 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
        char *data1 = (*bh)->b_data, *data2;
        unsigned split;
        struct ext4_dir_entry_2 *de = NULL, *de2;
-        int     err;
+        int     err = 0;
-        bh2 = ext4_append (handle, dir, &newblock, error);
+        bh2 = ext4_append (handle, dir, &newblock, &err);
        if (!(bh2)) {
                brelse(*bh);
                *bh = NULL;
@@ -1143,14 +1143,9 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
        BUFFER_TRACE(*bh, "get_write_access");
        err = ext4_journal_get_write_access(handle, *bh);
-        if (err) {
+        if (err)
-        journal_error:
+                goto journal_error;
-                brelse(*bh);
-                brelse(bh2);
-                *bh = NULL;
-                ext4_std_error(dir->i_sb, err);
-                goto errout;
-        }
        BUFFER_TRACE(frame->bh, "get_write_access");
        err = ext4_journal_get_write_access(handle, frame->bh);
        if (err)
@@ -1193,8 +1188,16 @@ static struct ext4_dir_entry_2 *do_split(handle_t *handle, struct inode *dir,
                goto journal_error;
        brelse (bh2);
        dxtrace(dx_show_index ("frame", frame->entries));
-errout:
        return de;
+journal_error:
+        brelse(*bh);
+        brelse(bh2);
+        *bh = NULL;
+        ext4_std_error(dir->i_sb, err);
+errout:
+        *error = err;
+        return NULL;
 }
 #endif
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index ea99f6c97f56..aa11d7dbe970 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -11,7 +11,6 @@
 #define EXT4FS_DEBUG
-#include <linux/smp_lock.h>
 #include <linux/ext4_jbd2.h>
 #include <linux/errno.h>
diff --git a/fs/ext4/xattr_security.c b/fs/ext4/xattr_security.c
index b6a6861951f9..f17eaf2321b9 100644
--- a/fs/ext4/xattr_security.c
+++ b/fs/ext4/xattr_security.c
@@ -6,7 +6,6 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include <linux/security.h>
diff --git a/fs/ext4/xattr_trusted.c b/fs/ext4/xattr_trusted.c
index b76f2dbc82da..e0f05acdafec 100644
--- a/fs/ext4/xattr_trusted.c
+++ b/fs/ext4/xattr_trusted.c
@@ -9,7 +9,6 @@
 #include <linux/string.h>
 #include <linux/capability.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include "xattr.h"
diff --git a/fs/ext4/xattr_user.c b/fs/ext4/xattr_user.c
index c53cded0761a..7ed3d8ebf096 100644
--- a/fs/ext4/xattr_user.c
+++ b/fs/ext4/xattr_user.c
@@ -8,7 +8,6 @@
 #include <linux/module.h>
 #include <linux/string.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/ext4_jbd2.h>
 #include <linux/ext4_fs.h>
 #include "xattr.h"
diff --git a/fs/fat/dir.c b/fs/fat/dir.c
index c16af246d245..ccf161dffb63 100644
--- a/fs/fat/dir.c
+++ b/fs/fat/dir.c
@@ -422,7 +422,7 @@ EODir:
 EXPORT_SYMBOL_GPL(fat_search_long);
 struct fat_ioctl_filldir_callback {
-        struct dirent __user *dirent;
+        void __user *dirent;
        int result;
        /* for dir ioctl */
        const char *longname;
@@ -647,62 +647,85 @@ static int fat_readdir(struct file *filp, void *dirent, filldir_t filldir)
        return __fat_readdir(inode, filp, dirent, filldir, 0, 0);
 }
-static int fat_ioctl_filldir(void *__buf, const char *name, int name_len,
+#define FAT_IOCTL_FILLDIR_FUNC(func, dirent_type)                          \
-                             loff_t offset, u64 ino, unsigned int d_type)
+static int func(void *__buf, const char *name, int name_len,               \
+                             loff_t offset, u64 ino, unsigned int d_type)  \
+{                                                                          \
+        struct fat_ioctl_filldir_callback *buf = __buf;                    \
+        struct dirent_type __user *d1 = buf->dirent;                       \
+        struct dirent_type __user *d2 = d1 + 1;                            \
+                                                                           \
+        if (buf->result)                                                   \
+                return -EINVAL;                                            \
+        buf->result++;                                                     \
+                                                                           \
+        if (name != NULL) {                                                \
+                /* dirent has only short name */                           \
+                if (name_len >= sizeof(d1->d_name))                        \
+                        name_len = sizeof(d1->d_name) - 1;                 \
+                                                                           \
+                if (put_user(0, d2->d_name)                     ||         \
+                    put_user(0, &d2->d_reclen)                  ||         \
+                    copy_to_user(d1->d_name, name, name_len)    ||         \
+                    put_user(0, d1->d_name + name_len)          ||         \
+                    put_user(name_len, &d1->d_reclen))                     \
+                        goto efault;                                       \
+        } else {                                                           \
+                /* dirent has short and long name */                       \
+                const char *longname = buf->longname;                      \
+                int long_len = buf->long_len;                              \
+                const char *shortname = buf->shortname;                    \
+                int short_len = buf->short_len;                            \
+                                                                           \
+                if (long_len >= sizeof(d1->d_name))                        \
+                        long_len = sizeof(d1->d_name) - 1;                 \
+                if (short_len >= sizeof(d1->d_name))                       \
+                        short_len = sizeof(d1->d_name) - 1;                \
+                                                                           \
+                if (copy_to_user(d2->d_name, longname, long_len)        || \
+                    put_user(0, d2->d_name + long_len)                  || \
+                    put_user(long_len, &d2->d_reclen)                   || \
+                    put_user(ino, &d2->d_ino)                           || \
+                    put_user(offset, &d2->d_off)                        || \
+                    copy_to_user(d1->d_name, shortname, short_len)      || \
+                    put_user(0, d1->d_name + short_len)                 || \
+                    put_user(short_len, &d1->d_reclen))                    \
+                        goto efault;                                       \
+        }                                                                  \
+        return 0;                                                          \
+efault:                                                                    \
+        buf->result = -EFAULT;                                             \
+        return -EFAULT;                                                    \
+}
+FAT_IOCTL_FILLDIR_FUNC(fat_ioctl_filldir, dirent)
+static int fat_ioctl_readdir(struct inode *inode, struct file *filp,
+                             void __user *dirent, filldir_t filldir,
+                             int short_only, int both)
 {
-        struct fat_ioctl_filldir_callback *buf = __buf;
+        struct fat_ioctl_filldir_callback buf;
-        struct dirent __user *d1 = buf->dirent;
+        int ret;
-        struct dirent __user *d2 = d1 + 1;
+        buf.dirent = dirent;
-        if (buf->result)
+        buf.result = 0;
-                return -EINVAL;
+        mutex_lock(&inode->i_mutex);
-        buf->result++;
+        ret = -ENOENT;
+        if (!IS_DEADDIR(inode)) {
-        if (name != NULL) {
+                ret = __fat_readdir(inode, filp, &buf, filldir,
-                /* dirent has only short name */
+                                    short_only, both);
-                if (name_len >= sizeof(d1->d_name))
-                        name_len = sizeof(d1->d_name) - 1;
-                if (put_user(0, d2->d_name)                     ||
-                    put_user(0, &d2->d_reclen)                  ||
-                    copy_to_user(d1->d_name, name, name_len)    ||
-                    put_user(0, d1->d_name + name_len)          ||
-                    put_user(name_len, &d1->d_reclen))
-                        goto efault;
-        } else {
-                /* dirent has short and long name */
-                const char *longname = buf->longname;
-                int long_len = buf->long_len;
-                const char *shortname = buf->shortname;
-                int short_len = buf->short_len;
-                if (long_len >= sizeof(d1->d_name))
-                        long_len = sizeof(d1->d_name) - 1;
-                if (short_len >= sizeof(d1->d_name))
-                        short_len = sizeof(d1->d_name) - 1;
-                if (copy_to_user(d2->d_name, longname, long_len)        ||
-                    put_user(0, d2->d_name + long_len)                  ||
-                    put_user(long_len, &d2->d_reclen)                   ||
-                    put_user(ino, &d2->d_ino)                           ||
-                    put_user(offset, &d2->d_off)                        ||
-                    copy_to_user(d1->d_name, shortname, short_len)      ||
-                    put_user(0, d1->d_name + short_len)                 ||
-                    put_user(short_len, &d1->d_reclen))
-                        goto efault;
        }
-        return 0;
+        mutex_unlock(&inode->i_mutex);
-efault:
+        if (ret >= 0)
-        buf->result = -EFAULT;
+                ret = buf.result;
-        return -EFAULT;
+        return ret;
 }
-static int fat_dir_ioctl(struct inode * inode, struct file * filp,
+static int fat_dir_ioctl(struct inode *inode, struct file *filp,
-                  unsigned int cmd, unsigned long arg)
+                         unsigned int cmd, unsigned long arg)
 {
-        struct fat_ioctl_filldir_callback buf;
+        struct dirent __user *d1 = (struct dirent __user *)arg;
-        struct dirent __user *d1;
+        int short_only, both;
-        int ret, short_only, both;
        switch (cmd) {
        case VFAT_IOCTL_READDIR_SHORT:
@@ -717,7 +740,6 @@ static int fat_dir_ioctl(struct inode * inode, struct file * filp,
                return fat_generic_ioctl(inode, filp, cmd, arg);
        }
-        d1 = (struct dirent __user *)arg;
        if (!access_ok(VERIFY_WRITE, d1, sizeof(struct dirent[2])))
                return -EFAULT;
        /*
@@ -728,69 +750,48 @@ static int fat_dir_ioctl(struct inode * inode, struct file * filp,
        if (put_user(0, &d1->d_reclen))
                return -EFAULT;
-        buf.dirent = d1;
+        return fat_ioctl_readdir(inode, filp, d1, fat_ioctl_filldir,
-        buf.result = 0;
+                                 short_only, both);
-        mutex_lock(&inode->i_mutex);
-        ret = -ENOENT;
-        if (!IS_DEADDIR(inode)) {
-                ret = __fat_readdir(inode, filp, &buf, fat_ioctl_filldir,
-                                    short_only, both);
-        }
-        mutex_unlock(&inode->i_mutex);
-        if (ret >= 0)
-                ret = buf.result;
-        return ret;
 }
 #ifdef CONFIG_COMPAT
 #define VFAT_IOCTL_READDIR_BOTH32       _IOR('r', 1, struct compat_dirent[2])
 #define VFAT_IOCTL_READDIR_SHORT32      _IOR('r', 2, struct compat_dirent[2])
-static long fat_compat_put_dirent32(struct dirent *d,
+FAT_IOCTL_FILLDIR_FUNC(fat_compat_ioctl_filldir, compat_dirent)
-                                    struct compat_dirent __user *d32)
-{
-        if (!access_ok(VERIFY_WRITE, d32, sizeof(struct compat_dirent)))
-                return -EFAULT;
-        __put_user(d->d_ino, &d32->d_ino);
-        __put_user(d->d_off, &d32->d_off);
-        __put_user(d->d_reclen, &d32->d_reclen);
-        if (__copy_to_user(d32->d_name, d->d_name, d->d_reclen))
-                return -EFAULT;
-        return 0;
+static long fat_compat_dir_ioctl(struct file *filp, unsigned cmd,
-}
-static long fat_compat_dir_ioctl(struct file *file, unsigned cmd,
                                 unsigned long arg)
 {
-        struct compat_dirent __user *p = compat_ptr(arg);
+        struct inode *inode = filp->f_path.dentry->d_inode;
-        int ret;
+        struct compat_dirent __user *d1 = compat_ptr(arg);
-        mm_segment_t oldfs = get_fs();
+        int short_only, both;
-        struct dirent d[2];
        switch (cmd) {
-        case VFAT_IOCTL_READDIR_BOTH32:
-                cmd = VFAT_IOCTL_READDIR_BOTH;
-                break;
        case VFAT_IOCTL_READDIR_SHORT32:
-                cmd = VFAT_IOCTL_READDIR_SHORT;
+                short_only = 1;
+                both = 0;
+                break;
+        case VFAT_IOCTL_READDIR_BOTH32:
+                short_only = 0;
+                both = 1;
                break;
        default:
                return -ENOIOCTLCMD;
        }
-        set_fs(KERNEL_DS);
+        if (!access_ok(VERIFY_WRITE, d1, sizeof(struct compat_dirent[2])))
-        lock_kernel();
+                return -EFAULT;
-        ret = fat_dir_ioctl(file->f_path.dentry->d_inode, file,
+        /*
-                            cmd, (unsigned long) &d);
+         * Yes, we don't need this put_user() absolutely. However old
-        unlock_kernel();
+         * code didn't return the right value. So, app use this value,
-        set_fs(oldfs);
+         * in order to check whether it is EOF.
-        if (ret >= 0) {
+         */
-                ret |= fat_compat_put_dirent32(&d[0], p);
+        if (put_user(0, &d1->d_reclen))
-                ret |= fat_compat_put_dirent32(&d[1], p + 1);
+                return -EFAULT;
-        }
-        return ret;
+        return fat_ioctl_readdir(inode, filp, d1, fat_compat_ioctl_filldir,
+                                 short_only, both);
 }
 #endif /* CONFIG_COMPAT */
diff --git a/fs/fat/inode.c b/fs/fat/inode.c
index 65cb54bde481..2c55e8dce793 100644
--- a/fs/fat/inode.c
+++ b/fs/fat/inode.c
@@ -25,6 +25,7 @@
 #include <linux/parser.h>
 #include <linux/uio.h>
 #include <linux/writeback.h>
+#include <linux/log2.h>
 #include <asm/unaligned.h>
 #ifndef CONFIG_FAT_DEFAULT_IOCHARSET
@@ -824,6 +825,8 @@ static int fat_show_options(struct seq_file *m, struct vfsmount *mnt)
        }
        if (opts->name_check != 'n')
                seq_printf(m, ",check=%c", opts->name_check);
+        if (opts->usefree)
+                seq_puts(m, ",usefree");
        if (opts->quiet)
                seq_puts(m, ",quiet");
        if (opts->showexec)
@@ -849,7 +852,7 @@ static int fat_show_options(struct seq_file *m, struct vfsmount *mnt)
 enum {
        Opt_check_n, Opt_check_r, Opt_check_s, Opt_uid, Opt_gid,
-        Opt_umask, Opt_dmask, Opt_fmask, Opt_codepage, Opt_nocase,
+        Opt_umask, Opt_dmask, Opt_fmask, Opt_codepage, Opt_usefree, Opt_nocase,
        Opt_quiet, Opt_showexec, Opt_debug, Opt_immutable,
        Opt_dots, Opt_nodots,
        Opt_charset, Opt_shortname_lower, Opt_shortname_win95,
@@ -871,6 +874,7 @@ static match_table_t fat_tokens = {
        {Opt_dmask, "dmask=%o"},
        {Opt_fmask, "fmask=%o"},
        {Opt_codepage, "codepage=%u"},
+        {Opt_usefree, "usefree"},
        {Opt_nocase, "nocase"},
        {Opt_quiet, "quiet"},
        {Opt_showexec, "showexec"},
@@ -950,7 +954,7 @@ static int parse_options(char *options, int is_vfat, int silent, int *debug,
        opts->quiet = opts->showexec = opts->sys_immutable = opts->dotsOK =  0;
        opts->utf8 = opts->unicode_xlate = 0;
        opts->numtail = 1;
-        opts->nocase = 0;
+        opts->usefree = opts->nocase = 0;
        *debug = 0;
        if (!options)
@@ -978,6 +982,9 @@ static int parse_options(char *options, int is_vfat, int silent, int *debug,
                case Opt_check_n:
                        opts->name_check = 'n';
                        break;
+                case Opt_usefree:
+                        opts->usefree = 1;
+                        break;
                case Opt_nocase:
                        if (!is_vfat)
                                opts->nocase = 1;
@@ -1217,8 +1224,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent,
        }
        logical_sector_size =
                le16_to_cpu(get_unaligned((__le16 *)&b->sector_size));
-        if (!logical_sector_size
+        if (!is_power_of_2(logical_sector_size)
-            || (logical_sector_size & (logical_sector_size - 1))
            || (logical_sector_size < 512)
            || (PAGE_CACHE_SIZE < logical_sector_size)) {
                if (!silent)
@@ -1228,8 +1234,7 @@ int fat_fill_super(struct super_block *sb, void *data, int silent,
                goto out_invalid;
        }
        sbi->sec_per_clus = b->sec_per_clus;
-        if (!sbi->sec_per_clus
+        if (!is_power_of_2(sbi->sec_per_clus)) {
-            || (sbi->sec_per_clus & (sbi->sec_per_clus - 1))) {
                if (!silent)
                        printk(KERN_ERR "FAT: bogus sectors per cluster %u\n",
                               sbi->sec_per_clus);
@@ -1305,7 +1310,9 @@ int fat_fill_super(struct super_block *sb, void *data, int silent,
                               le32_to_cpu(fsinfo->signature2),
                               sbi->fsinfo_sector);
                } else {
-                        sbi->free_clusters = le32_to_cpu(fsinfo->free_clusters);
+                        if (sbi->options.usefree)
+                                sbi->free_clusters =
+                                        le32_to_cpu(fsinfo->free_clusters);
                        sbi->prev_free = le32_to_cpu(fsinfo->next_cluster);
                }
diff --git a/fs/fifo.c b/fs/fifo.c
index 49035b174b48..6e7df7256782 100644
--- a/fs/fifo.c
+++ b/fs/fifo.c
@@ -11,7 +11,6 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 #include <linux/pipe_fs_i.h>
diff --git a/fs/file_table.c b/fs/file_table.c
index 4c17a18d8c10..d17fd691b832 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -10,7 +10,6 @@
 #include <linux/file.h>
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 #include <linux/security.h>
 #include <linux/eventpoll.h>
diff --git a/fs/filesystems.c b/fs/filesystems.c
index 7a4f61aa05f8..f37f87262837 100644
--- a/fs/filesystems.c
+++ b/fs/filesystems.c
@@ -41,11 +41,12 @@ void put_filesystem(struct file_system_type *fs)
        module_put(fs->owner);
 }
-static struct file_system_type **find_filesystem(const char *name)
+static struct file_system_type **find_filesystem(const char *name, unsigned len)
 {
        struct file_system_type **p;
        for (p=&file_systems; *p; p=&(*p)->next)
-                if (strcmp((*p)->name,name) == 0)
+                if (strlen((*p)->name) == len &&
+                    strncmp((*p)->name, name, len) == 0)
                        break;
        return p;
 }
@@ -68,11 +69,12 @@ int register_filesystem(struct file_system_type * fs)
        int res = 0;
        struct file_system_type ** p;
+        BUG_ON(strchr(fs->name, '.'));
        if (fs->next)
                return -EBUSY;
        INIT_LIST_HEAD(&fs->fs_supers);
        write_lock(&file_systems_lock);
-        p = find_filesystem(fs->name);
+        p = find_filesystem(fs->name, strlen(fs->name));
        if (*p)
                res = -EBUSY;
        else
@@ -215,19 +217,26 @@ int get_filesystem_list(char * buf)
 struct file_system_type *get_fs_type(const char *name)
 {
        struct file_system_type *fs;
+        const char *dot = strchr(name, '.');
+        unsigned len = dot ? dot - name : strlen(name);
        read_lock(&file_systems_lock);
-        fs = *(find_filesystem(name));
+        fs = *(find_filesystem(name, len));
        if (fs && !try_module_get(fs->owner))
                fs = NULL;
        read_unlock(&file_systems_lock);
-        if (!fs && (request_module("%s", name) == 0)) {
+        if (!fs && (request_module("%.*s", len, name) == 0)) {
                read_lock(&file_systems_lock);
-                fs = *(find_filesystem(name));
+                fs = *(find_filesystem(name, len));
                if (fs && !try_module_get(fs->owner))
                        fs = NULL;
                read_unlock(&file_systems_lock);
        }
+        if (dot && fs && !(fs->fs_flags & FS_HAS_SUBTYPE)) {
+                put_filesystem(fs);
+                fs = NULL;
+        }
        return fs;
 }
diff --git a/fs/freevxfs/vxfs_bmap.c b/fs/freevxfs/vxfs_bmap.c
index 2d71128bd8d6..f86fd3cacd5a 100644
--- a/fs/freevxfs/vxfs_bmap.c
+++ b/fs/freevxfs/vxfs_bmap.c
@@ -137,7 +137,7 @@ vxfs_bmap_indir(struct inode *ip, long indir, int size, long block)
                bp = sb_bread(ip->i_sb,
                                indir + (i / VXFS_TYPED_PER_BLOCK(ip->i_sb)));
-                if (!buffer_mapped(bp))
+                if (!bp || !buffer_mapped(bp))
                        return 0;
                typ = ((struct vxfs_typed *)bp->b_data) +
diff --git a/fs/freevxfs/vxfs_inode.c b/fs/freevxfs/vxfs_inode.c
index 098a915fd9a1..d1f7c5b5b3c3 100644
--- a/fs/freevxfs/vxfs_inode.c
+++ b/fs/freevxfs/vxfs_inode.c
@@ -99,7 +99,7 @@ vxfs_blkiget(struct super_block *sbp, u_long extent, ino_t ino)
        offset = ((ino % (sbp->s_blocksize / VXFS_ISIZE)) * VXFS_ISIZE);
        bp = sb_bread(sbp, block);
-        if (buffer_mapped(bp)) {
+        if (bp && buffer_mapped(bp)) {
                struct vxfs_inode_info  *vip;
                struct vxfs_dinode      *dip;
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index d8003be56e05..1397018ff476 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -636,6 +636,7 @@ static int fuse_get_sb(struct file_system_type *fs_type,
 static struct file_system_type fuse_fs_type = {
        .owner          = THIS_MODULE,
        .name           = "fuse",
+        .fs_flags       = FS_HAS_SUBTYPE,
        .get_sb         = fuse_get_sb,
        .kill_sb        = kill_anon_super,
 };
@@ -652,6 +653,7 @@ static int fuse_get_sb_blk(struct file_system_type *fs_type,
 static struct file_system_type fuseblk_fs_type = {
        .owner          = THIS_MODULE,
        .name           = "fuseblk",
+        .fs_flags       = FS_HAS_SUBTYPE,
        .get_sb         = fuse_get_sb_blk,
        .kill_sb        = kill_block_super,
        .fs_flags       = FS_REQUIRES_DEV,
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index 39c8ae23bd9c..7b82657a9910 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -163,10 +163,7 @@ static void inode_go_sync(struct gfs2_glock *gl)
                if (ip) {
                        struct address_space *mapping = ip->i_inode.i_mapping;
                        int error = filemap_fdatawait(mapping);
-                        if (error == -ENOSPC)
+                        mapping_set_error(mapping, error);
-                                set_bit(AS_ENOSPC, &mapping->flags);
-                        else if (error)
-                                set_bit(AS_EIO, &mapping->flags);
                }
                clear_bit(GLF_DIRTY, &gl->gl_flags);
                gfs2_ail_empty_gl(gl);
diff --git a/fs/gfs2/locking/nolock/main.c b/fs/gfs2/locking/nolock/main.c
index 5cc1dfa7944a..0d149c8c493a 100644
--- a/fs/gfs2/locking/nolock/main.c
+++ b/fs/gfs2/locking/nolock/main.c
@@ -13,7 +13,6 @@
 #include <linux/init.h>
 #include <linux/types.h>
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 #include <linux/lm_interface.h>
 struct nolock_lockspace {
diff --git a/fs/gfs2/ops_dentry.c b/fs/gfs2/ops_dentry.c
index c6bac6b69420..a6fdc52f554a 100644
--- a/fs/gfs2/ops_dentry.c
+++ b/fs/gfs2/ops_dentry.c
@@ -11,7 +11,6 @@
 #include <linux/spinlock.h>
 #include <linux/completion.h>
 #include <linux/buffer_head.h>
-#include <linux/smp_lock.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
 #include <linux/lm_interface.h>
diff --git a/fs/gfs2/ops_file.c b/fs/gfs2/ops_file.c
index 329c4dcdecdb..064df8804582 100644
--- a/fs/gfs2/ops_file.c
+++ b/fs/gfs2/ops_file.c
@@ -15,7 +15,6 @@
 #include <linux/uio.h>
 #include <linux/blkdev.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/ext2_fs.h>
diff --git a/fs/hfs/btree.c b/fs/hfs/btree.c
index 5fd0ed71f923..8a3a650abc87 100644
--- a/fs/hfs/btree.c
+++ b/fs/hfs/btree.c
@@ -9,6 +9,7 @@
 */
 #include <linux/pagemap.h>
+#include <linux/log2.h>
 #include "btree.h"
@@ -76,7 +77,7 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id, btree_keycmp ke
        tree->depth = be16_to_cpu(head->depth);
        size = tree->node_size;
-        if (!size || size & (size - 1))
+        if (!is_power_of_2(size))
                goto fail_page;
        if (!tree->node_count)
                goto fail_page;
diff --git a/fs/hfsplus/btree.c b/fs/hfsplus/btree.c
index a9b9e872e29a..90ebab753d30 100644
--- a/fs/hfsplus/btree.c
+++ b/fs/hfsplus/btree.c
@@ -10,6 +10,7 @@
 #include <linux/slab.h>
 #include <linux/pagemap.h>
+#include <linux/log2.h>
 #include "hfsplus_fs.h"
 #include "hfsplus_raw.h"
@@ -69,7 +70,7 @@ struct hfs_btree *hfs_btree_open(struct super_block *sb, u32 id)
        }
        size = tree->node_size;
-        if (!size || size & (size - 1))
+        if (!is_power_of_2(size))
                goto fail_page;
        if (!tree->node_count)
                goto fail_page;
diff --git a/fs/hostfs/hostfs.h b/fs/hostfs/hostfs.h
index 70543b17e4c7..06e5930515fe 100644
--- a/fs/hostfs/hostfs.h
+++ b/fs/hostfs/hostfs.h
@@ -55,7 +55,7 @@ extern int stat_file(const char *path, unsigned long long *inode_out,
                     int *mode_out, int *nlink_out, int *uid_out, int *gid_out,
                     unsigned long long *size_out, struct timespec *atime_out,
                     struct timespec *mtime_out, struct timespec *ctime_out,
-                     int *blksize_out, unsigned long long *blocks_out);
+                     int *blksize_out, unsigned long long *blocks_out, int fd);
 extern int access_file(char *path, int r, int w, int x);
 extern int open_file(char *path, int r, int w, int append);
 extern int file_type(const char *path, int *maj, int *min);
@@ -71,7 +71,7 @@ extern int lseek_file(int fd, long long offset, int whence);
 extern int fsync_file(int fd, int datasync);
 extern int file_create(char *name, int ur, int uw, int ux, int gr,
                       int gw, int gx, int or, int ow, int ox);
-extern int set_attr(const char *file, struct hostfs_iattr *attrs);
+extern int set_attr(const char *file, struct hostfs_iattr *attrs, int fd);
 extern int make_symlink(const char *from, const char *to);
 extern int unlink_file(const char *file);
 extern int do_mkdir(const char *file, int mode);
@@ -87,14 +87,3 @@ extern int do_statfs(char *root, long *bsize_out, long long *blocks_out,
                     long *spare_out);
 #endif
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/fs/hostfs/hostfs_kern.c b/fs/hostfs/hostfs_kern.c
index fd301a910122..8286491dbf31 100644
--- a/fs/hostfs/hostfs_kern.c
+++ b/fs/hostfs/hostfs_kern.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 *
 * Ported the filesystem routines to 2.5.
@@ -31,14 +31,14 @@ struct hostfs_inode_info {
 static inline struct hostfs_inode_info *HOSTFS_I(struct inode *inode)
 {
-        return(list_entry(inode, struct hostfs_inode_info, vfs_inode));
+        return list_entry(inode, struct hostfs_inode_info, vfs_inode);
 }
 #define FILE_HOSTFS_I(file) HOSTFS_I((file)->f_path.dentry->d_inode)
 int hostfs_d_delete(struct dentry *dentry)
 {
-        return(1);
+        return 1;
 }
 struct dentry_operations hostfs_dentry_ops = {
@@ -79,7 +79,7 @@ static int __init hostfs_args(char *options, int *add)
                }
                options = ptr;
        }
-        return(0);
+        return 0;
 }
 __uml_setup("hostfs=", hostfs_args,
@@ -110,7 +110,8 @@ static char *dentry_name(struct dentry *dentry, int extra)
        root = HOSTFS_I(parent->d_inode)->host_filename;
        len += strlen(root);
        name = kmalloc(len + extra + 1, GFP_KERNEL);
-        if(name == NULL) return(NULL);
+        if(name == NULL)
+                return NULL;
        name[len] = '\0';
        parent = dentry;
@@ -122,7 +123,7 @@ static char *dentry_name(struct dentry *dentry, int extra)
                parent = parent->d_parent;
        }
        strncpy(name, root, strlen(root));
-        return(name);
+        return name;
 }
 static char *inode_name(struct inode *ino, int extra)
@@ -130,7 +131,7 @@ static char *inode_name(struct inode *ino, int extra)
        struct dentry *dentry;
        dentry = list_entry(ino->i_dentry.next, struct dentry, d_alias);
-        return(dentry_name(dentry, extra));
+        return dentry_name(dentry, extra);
 }
 static int read_name(struct inode *ino, char *name)
@@ -147,16 +148,16 @@ static int read_name(struct inode *ino, char *name)
        err = stat_file(name, &i_ino, &i_mode, &i_nlink, &ino->i_uid,
                        &ino->i_gid, &i_size, &ino->i_atime, &ino->i_mtime,
-                        &ino->i_ctime, &i_blksize, &i_blocks);
+                        &ino->i_ctime, &i_blksize, &i_blocks, -1);
        if(err)
-                return(err);
+                return err;
        ino->i_ino = i_ino;
        ino->i_mode = i_mode;
        ino->i_nlink = i_nlink;
        ino->i_size = i_size;
        ino->i_blocks = i_blocks;
-        return(0);
+        return 0;
 }
 static char *follow_link(char *link)
@@ -181,11 +182,11 @@ static char *follow_link(char *link)
                goto out_free;
        if(*name == '/')
-                return(name);
+                return name;
        end = strrchr(link, '/');
        if(end == NULL)
-                return(name);
+                return name;
        *(end + 1) = '\0';
        len = strlen(link) + strlen(name) + 1;
@@ -199,12 +200,12 @@ static char *follow_link(char *link)
        sprintf(resolved, "%s%s", link, name);
        kfree(name);
        kfree(link);
-        return(resolved);
+        return resolved;
 out_free:
        kfree(name);
 out:
-        return(ERR_PTR(n));
+        return ERR_PTR(n);
 }
 static int read_inode(struct inode *ino)
@@ -234,7 +235,7 @@ static int read_inode(struct inode *ino)
        err = read_name(ino, name);
        kfree(name);
 out:
-        return(err);
+        return err;
 }
 int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
@@ -254,14 +255,15 @@ int hostfs_statfs(struct dentry *dentry, struct kstatfs *sf)
                        &sf->f_bsize, &f_blocks, &f_bfree, &f_bavail, &f_files,
                        &f_ffree, &sf->f_fsid, sizeof(sf->f_fsid),
                        &sf->f_namelen, sf->f_spare);
-        if(err) return(err);
+        if(err)
+                return err;
        sf->f_blocks = f_blocks;
        sf->f_bfree = f_bfree;
        sf->f_bavail = f_bavail;
        sf->f_files = f_files;
        sf->f_ffree = f_ffree;
        sf->f_type = HOSTFS_SUPER_MAGIC;
-        return(0);
+        return 0;
 }
 static struct inode *hostfs_alloc_inode(struct super_block *sb)
@@ -270,13 +272,13 @@ static struct inode *hostfs_alloc_inode(struct super_block *sb)
        hi = kmalloc(sizeof(*hi), GFP_KERNEL);
        if(hi == NULL)
-                return(NULL);
+                return NULL;
        *hi = ((struct hostfs_inode_info) { .host_filename      = NULL,
                                            .fd                 = -1,
                                            .mode               = 0 });
        inode_init_once(&hi->vfs_inode);
-        return(&hi->vfs_inode);
+        return &hi->vfs_inode;
 }
 static void hostfs_delete_inode(struct inode *inode)
@@ -325,10 +327,12 @@ int hostfs_readdir(struct file *file, void *ent, filldir_t filldir)
        int error, len;
        name = dentry_name(file->f_path.dentry, 0);
-        if(name == NULL) return(-ENOMEM);
+        if(name == NULL)
+                return -ENOMEM;
        dir = open_dir(name, &error);
        kfree(name);
-        if(dir == NULL) return(-error);
+        if(dir == NULL)
+                return -error;
        next = file->f_pos;
        while((name = read_dir(dir, &next, &ino, &len)) != NULL){
                error = (*filldir)(ent, name, len, file->f_pos,
@@ -337,7 +341,7 @@ int hostfs_readdir(struct file *file, void *ent, filldir_t filldir)
                file->f_pos = next;
        }
        close_dir(dir);
-        return(0);
+        return 0;
 }
 int hostfs_file_open(struct inode *ino, struct file *file)
@@ -347,7 +351,7 @@ int hostfs_file_open(struct inode *ino, struct file *file)
        mode = file->f_mode & (FMODE_READ | FMODE_WRITE);
        if((mode & HOSTFS_I(ino)->mode) == mode)
-                return(0);
+                return 0;
        /* The file may already have been opened, but with the wrong access,
         * so this resets things and reopens the file with the new access.
@@ -367,14 +371,15 @@ int hostfs_file_open(struct inode *ino, struct file *file)
        name = dentry_name(file->f_path.dentry, 0);
        if(name == NULL)
-                return(-ENOMEM);
+                return -ENOMEM;
        fd = open_file(name, r, w, append);
        kfree(name);
-        if(fd < 0) return(fd);
+        if(fd < 0)
+                return fd;
        FILE_HOSTFS_I(file)->fd = fd;
-        return(0);
+        return 0;
 }
 int hostfs_fsync(struct file *file, struct dentry *dentry, int datasync)
@@ -458,7 +463,7 @@ int hostfs_readpage(struct file *file, struct page *page)
 out:
        kunmap(page);
        unlock_page(page);
-        return(err);
+        return err;
 }
 int hostfs_prepare_write(struct file *file, struct page *page,
@@ -485,7 +490,7 @@ int hostfs_prepare_write(struct file *file, struct page *page,
        err = 0;
 out:
        kunmap(page);
-        return(err);
+        return err;
 }
 int hostfs_commit_write(struct file *file, struct page *page, unsigned from,
@@ -511,7 +516,7 @@ int hostfs_commit_write(struct file *file, struct page *page, unsigned from,
                inode->i_size = start;
        kunmap(page);
-        return(err);
+        return err;
 }
 static const struct address_space_operations hostfs_aops = {
@@ -569,7 +574,7 @@ static int init_inode(struct inode *inode, struct dentry *dentry)
                break;
        }
 out:
-        return(err);
+        return err;
 }
 int hostfs_create(struct inode *dir, struct dentry *dentry, int mode,
@@ -607,16 +612,16 @@ int hostfs_create(struct inode *dir, struct dentry *dentry, int mode,
        HOSTFS_I(inode)->fd = fd;
        HOSTFS_I(inode)->mode = FMODE_READ | FMODE_WRITE;
        d_instantiate(dentry, inode);
-        return(0);
+        return 0;
 out_put:
        iput(inode);
 out:
-        return(error);
+        return error;
 }
 struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
-                            struct nameidata *nd)
+                             struct nameidata *nd)
 {
        struct inode *inode;
        char *name;
@@ -647,44 +652,45 @@ struct dentry *hostfs_lookup(struct inode *ino, struct dentry *dentry,
        d_add(dentry, inode);
        dentry->d_op = &hostfs_dentry_ops;
-        return(NULL);
+        return NULL;
 out_put:
        iput(inode);
 out:
-        return(ERR_PTR(err));
+        return ERR_PTR(err);
 }
 static char *inode_dentry_name(struct inode *ino, struct dentry *dentry)
 {
-        char *file;
+        char *file;
        int len;
        file = inode_name(ino, dentry->d_name.len + 1);
-        if(file == NULL) return(NULL);
+        if(file == NULL)
-        strcat(file, "/");
+                return NULL;
+        strcat(file, "/");
        len = strlen(file);
-        strncat(file, dentry->d_name.name, dentry->d_name.len);
+        strncat(file, dentry->d_name.name, dentry->d_name.len);
        file[len + dentry->d_name.len] = '\0';
-        return(file);
+        return file;
 }
 int hostfs_link(struct dentry *to, struct inode *ino, struct dentry *from)
 {
-        char *from_name, *to_name;
+        char *from_name, *to_name;
-        int err;
+        int err;
-        if((from_name = inode_dentry_name(ino, from)) == NULL)
+        if((from_name = inode_dentry_name(ino, from)) == NULL)
-                return(-ENOMEM);
+                return -ENOMEM;
-        to_name = dentry_name(to, 0);
+        to_name = dentry_name(to, 0);
        if(to_name == NULL){
                kfree(from_name);
-                return(-ENOMEM);
+                return -ENOMEM;
        }
-        err = link_file(to_name, from_name);
+        err = link_file(to_name, from_name);
-        kfree(from_name);
+        kfree(from_name);
-        kfree(to_name);
+        kfree(to_name);
-        return(err);
+        return err;
 }
 int hostfs_unlink(struct inode *ino, struct dentry *dentry)
@@ -692,13 +698,14 @@ int hostfs_unlink(struct inode *ino, struct dentry *dentry)
        char *file;
        int err;
-        if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
+        if((file = inode_dentry_name(ino, dentry)) == NULL)
+                return -ENOMEM;
        if(append)
-                return(-EPERM);
+                return -EPERM;
        err = unlink_file(file);
        kfree(file);
-        return(err);
+        return err;
 }
 int hostfs_symlink(struct inode *ino, struct dentry *dentry, const char *to)
@@ -706,10 +713,11 @@ int hostfs_symlink(struct inode *ino, struct dentry *dentry, const char *to)
        char *file;
        int err;
-        if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
+        if((file = inode_dentry_name(ino, dentry)) == NULL)
+                return -ENOMEM;
        err = make_symlink(file, to);
        kfree(file);
-        return(err);
+        return err;
 }
 int hostfs_mkdir(struct inode *ino, struct dentry *dentry, int mode)
@@ -717,10 +725,11 @@ int hostfs_mkdir(struct inode *ino, struct dentry *dentry, int mode)
        char *file;
        int err;
-        if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
+        if((file = inode_dentry_name(ino, dentry)) == NULL)
+                return -ENOMEM;
        err = do_mkdir(file, mode);
        kfree(file);
-        return(err);
+        return err;
 }
 int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
@@ -728,10 +737,11 @@ int hostfs_rmdir(struct inode *ino, struct dentry *dentry)
        char *file;
        int err;
-        if((file = inode_dentry_name(ino, dentry)) == NULL) return(-ENOMEM);
+        if((file = inode_dentry_name(ino, dentry)) == NULL)
+                return -ENOMEM;
        err = do_rmdir(file);
        kfree(file);
-        return(err);
+        return err;
 }
 int hostfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
@@ -764,14 +774,14 @@ int hostfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t dev)
                goto out_put;
        d_instantiate(dentry, inode);
-        return(0);
+        return 0;
 out_free:
        kfree(name);
 out_put:
        iput(inode);
 out:
-        return(err);
+        return err;
 }
 int hostfs_rename(struct inode *from_ino, struct dentry *from,
@@ -781,15 +791,15 @@ int hostfs_rename(struct inode *from_ino, struct dentry *from,
        int err;
        if((from_name = inode_dentry_name(from_ino, from)) == NULL)
-                return(-ENOMEM);
+                return -ENOMEM;
        if((to_name = inode_dentry_name(to_ino, to)) == NULL){
                kfree(from_name);
-                return(-ENOMEM);
+                return -ENOMEM;
        }
        err = rename_file(from_name, to_name);
        kfree(from_name);
        kfree(to_name);
-        return(err);
+        return err;
 }
 int hostfs_permission(struct inode *ino, int desired, struct nameidata *nd)
@@ -801,7 +811,8 @@ int hostfs_permission(struct inode *ino, int desired, struct nameidata *nd)
        if (desired & MAY_WRITE) w = 1;
        if (desired & MAY_EXEC) x = 1;
        name = inode_name(ino, 0);
-        if (name == NULL) return(-ENOMEM);
+        if (name == NULL)
+                return -ENOMEM;
        if (S_ISCHR(ino->i_mode) || S_ISBLK(ino->i_mode) ||
                        S_ISFIFO(ino->i_mode) || S_ISSOCK(ino->i_mode))
@@ -820,6 +831,8 @@ int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
        char *name;
        int err;
+        int fd = HOSTFS_I(dentry->d_inode)->fd;
        err = inode_change_ok(dentry->d_inode, attr);
        if (err)
                return err;
@@ -863,20 +876,21 @@ int hostfs_setattr(struct dentry *dentry, struct iattr *attr)
                attrs.ia_valid |= HOSTFS_ATTR_MTIME_SET;
        }
        name = dentry_name(dentry, 0);
-        if(name == NULL) return(-ENOMEM);
+        if(name == NULL)
-        err = set_attr(name, &attrs);
+                return -ENOMEM;
+        err = set_attr(name, &attrs, fd);
        kfree(name);
        if(err)
-                return(err);
+                return err;
-        return(inode_setattr(dentry->d_inode, attr));
+        return inode_setattr(dentry->d_inode, attr);
 }
 int hostfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
           struct kstat *stat)
 {
        generic_fillattr(dentry->d_inode, stat);
-        return(0);
+        return 0;
 }
 static const struct inode_operations hostfs_iops = {
@@ -915,7 +929,8 @@ int hostfs_link_readpage(struct file *file, struct page *page)
        buffer = kmap(page);
        name = inode_name(page->mapping->host, 0);
-        if(name == NULL) return(-ENOMEM);
+        if(name == NULL)
+                return -ENOMEM;
        err = do_readlink(name, buffer, PAGE_CACHE_SIZE);
        kfree(name);
        if(err == PAGE_CACHE_SIZE)
@@ -928,7 +943,7 @@ int hostfs_link_readpage(struct file *file, struct page *page)
        }
        kunmap(page);
        unlock_page(page);
-        return(err);
+        return err;
 }
 static const struct address_space_operations hostfs_link_aops = {
@@ -978,20 +993,20 @@ static int hostfs_fill_sb_common(struct super_block *sb, void *d, int silent)
        err = read_inode(root_inode);
        if(err){
-                /* No iput in this case because the dput does that for us */
+                /* No iput in this case because the dput does that for us */
-                dput(sb->s_root);
+                dput(sb->s_root);
-                sb->s_root = NULL;
+                sb->s_root = NULL;
                goto out;
-        }
+        }
-        return(0);
+        return 0;
- out_put:
+out_put:
-        iput(root_inode);
+        iput(root_inode);
- out_free:
+out_free:
        kfree(host_root_path);
- out:
+out:
-        return(err);
+        return err;
 }
 static int hostfs_read_sb(struct file_system_type *type,
@@ -1011,7 +1026,7 @@ static struct file_system_type hostfs_type = {
 static int __init init_hostfs(void)
 {
-        return(register_filesystem(&hostfs_type));
+        return register_filesystem(&hostfs_type);
 }
 static void __exit exit_hostfs(void)
@@ -1022,14 +1037,3 @@ static void __exit exit_hostfs(void)
 module_init(init_hostfs)
 module_exit(exit_hostfs)
 MODULE_LICENSE("GPL");
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/fs/hostfs/hostfs_user.c b/fs/hostfs/hostfs_user.c
index 1ed5ea389f15..5625e2481dd3 100644
--- a/fs/hostfs/hostfs_user.c
+++ b/fs/hostfs/hostfs_user.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2000 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 */
@@ -21,12 +21,16 @@ int stat_file(const char *path, unsigned long long *inode_out, int *mode_out,
              int *nlink_out, int *uid_out, int *gid_out,
              unsigned long long *size_out, struct timespec *atime_out,
              struct timespec *mtime_out, struct timespec *ctime_out,
-              int *blksize_out, unsigned long long *blocks_out)
+              int *blksize_out, unsigned long long *blocks_out, int fd)
 {
        struct stat64 buf;
-        if(lstat64(path, &buf) < 0)
+        if(fd >= 0) {
-                return(-errno);
+                if (fstat64(fd, &buf) < 0)
+                        return -errno;
+        } else if(lstat64(path, &buf) < 0) {
+                return -errno;
+        }
        if(inode_out != NULL) *inode_out = buf.st_ino;
        if(mode_out != NULL) *mode_out = buf.st_mode;
@@ -48,7 +52,7 @@ int stat_file(const char *path, unsigned long long *inode_out, int *mode_out,
        }
        if(blksize_out != NULL) *blksize_out = buf.st_blksize;
        if(blocks_out != NULL) *blocks_out = buf.st_blocks;
-        return(0);
+        return 0;
 }
 int file_type(const char *path, int *maj, int *min)
@@ -56,7 +60,7 @@ int file_type(const char *path, int *maj, int *min)
        struct stat64 buf;
        if(lstat64(path, &buf) < 0)
-                return(-errno);
+                return -errno;
        /*We cannot pass rdev as is because glibc and the kernel disagree
         *about its definition.*/
        if(maj != NULL)
@@ -64,13 +68,13 @@ int file_type(const char *path, int *maj, int *min)
        if(min != NULL)
                *min = minor(buf.st_rdev);
-        if(S_ISDIR(buf.st_mode)) return(OS_TYPE_DIR);
+        if(S_ISDIR(buf.st_mode)) return OS_TYPE_DIR;
-        else if(S_ISLNK(buf.st_mode)) return(OS_TYPE_SYMLINK);
+        else if(S_ISLNK(buf.st_mode)) return OS_TYPE_SYMLINK;
-        else if(S_ISCHR(buf.st_mode)) return(OS_TYPE_CHARDEV);
+        else if(S_ISCHR(buf.st_mode)) return OS_TYPE_CHARDEV;
-        else if(S_ISBLK(buf.st_mode)) return(OS_TYPE_BLOCKDEV);
+        else if(S_ISBLK(buf.st_mode)) return OS_TYPE_BLOCKDEV;
-        else if(S_ISFIFO(buf.st_mode))return(OS_TYPE_FIFO);
+        else if(S_ISFIFO(buf.st_mode))return OS_TYPE_FIFO;
-        else if(S_ISSOCK(buf.st_mode))return(OS_TYPE_SOCK);
+        else if(S_ISSOCK(buf.st_mode))return OS_TYPE_SOCK;
-        else return(OS_TYPE_FILE);
+        else return OS_TYPE_FILE;
 }
 int access_file(char *path, int r, int w, int x)
@@ -80,8 +84,9 @@ int access_file(char *path, int r, int w, int x)
        if(r) mode = R_OK;
        if(w) mode |= W_OK;
        if(x) mode |= X_OK;
-        if(access(path, mode) != 0) return(-errno);
+        if(access(path, mode) != 0)
-        else return(0);
+                return -errno;
+        else return 0;
 }
 int open_file(char *path, int r, int w, int append)
@@ -99,8 +104,9 @@ int open_file(char *path, int r, int w, int append)
        if(append)
                mode |= O_APPEND;
        fd = open64(path, mode);
-        if(fd < 0) return(-errno);
+        if(fd < 0)
-        else return(fd);
+                return -errno;
+        else return fd;
 }
 void *open_dir(char *path, int *err_out)
@@ -109,8 +115,9 @@ void *open_dir(char *path, int *err_out)
        dir = opendir(path);
        *err_out = errno;
-        if(dir == NULL) return(NULL);
+        if(dir == NULL)
-        return(dir);
+                return NULL;
+        return dir;
 }
 char *read_dir(void *stream, unsigned long long *pos,
@@ -121,11 +128,12 @@ char *read_dir(void *stream, unsigned long long *pos,
        seekdir(dir, *pos);
        ent = readdir(dir);
-        if(ent == NULL) return(NULL);
+        if(ent == NULL)
+                return NULL;
        *len_out = strlen(ent->d_name);
        *ino_out = ent->d_ino;
        *pos = telldir(dir);
-        return(ent->d_name);
+        return ent->d_name;
 }
 int read_file(int fd, unsigned long long *offset, char *buf, int len)
@@ -133,9 +141,10 @@ int read_file(int fd, unsigned long long *offset, char *buf, int len)
        int n;
        n = pread64(fd, buf, len, *offset);
-        if(n < 0) return(-errno);
+        if(n < 0)
+                return -errno;
        *offset += n;
-        return(n);
+        return n;
 }
 int write_file(int fd, unsigned long long *offset, const char *buf, int len)
@@ -143,9 +152,10 @@ int write_file(int fd, unsigned long long *offset, const char *buf, int len)
        int n;
        n = pwrite64(fd, buf, len, *offset);
-        if(n < 0) return(-errno);
+        if(n < 0)
+                return -errno;
        *offset += n;
-        return(n);
+        return n;
 }
 int lseek_file(int fd, long long offset, int whence)
@@ -154,8 +164,8 @@ int lseek_file(int fd, long long offset, int whence)
        ret = lseek64(fd, offset, whence);
        if(ret < 0)
-                return(-errno);
+                return -errno;
-        return(0);
+        return 0;
 }
 int fsync_file(int fd, int datasync)
@@ -198,65 +208,90 @@ int file_create(char *name, int ur, int uw, int ux, int gr,
        mode |= ox ? S_IXOTH : 0;
        fd = open64(name, O_CREAT | O_RDWR, mode);
        if(fd < 0)
-                return(-errno);
+                return -errno;
-        return(fd);
+        return fd;
 }
-int set_attr(const char *file, struct hostfs_iattr *attrs)
+int set_attr(const char *file, struct hostfs_iattr *attrs, int fd)
 {
-        struct utimbuf buf;
+        struct timeval times[2];
+        struct timespec atime_ts, mtime_ts;
        int err, ma;
-        if(attrs->ia_valid & HOSTFS_ATTR_MODE){
+        if (attrs->ia_valid & HOSTFS_ATTR_MODE) {
-                if(chmod(file, attrs->ia_mode) != 0) return(-errno);
+                if (fd >= 0) {
-        }
+                        if (fchmod(fd, attrs->ia_mode) != 0)
-        if(attrs->ia_valid & HOSTFS_ATTR_UID){
+                                return (-errno);
-                if(chown(file, attrs->ia_uid, -1)) return(-errno);
+                } else if (chmod(file, attrs->ia_mode) != 0) {
+                        return -errno;
+                }
        }
-        if(attrs->ia_valid & HOSTFS_ATTR_GID){
+        if (attrs->ia_valid & HOSTFS_ATTR_UID) {
-                if(chown(file, -1, attrs->ia_gid)) return(-errno);
+                if (fd >= 0) {
+                        if (fchown(fd, attrs->ia_uid, -1))
+                                return -errno;
+                } else if(chown(file, attrs->ia_uid, -1)) {
+                        return -errno;
+                }
        }
-        if(attrs->ia_valid & HOSTFS_ATTR_SIZE){
+        if (attrs->ia_valid & HOSTFS_ATTR_GID) {
-                if(truncate(file, attrs->ia_size)) return(-errno);
+                if (fd >= 0) {
+                        if (fchown(fd, -1, attrs->ia_gid))
+                                return -errno;
+                } else if (chown(file, -1, attrs->ia_gid)) {
+                        return -errno;
+                }
        }
-        ma = HOSTFS_ATTR_ATIME_SET | HOSTFS_ATTR_MTIME_SET;
+        if (attrs->ia_valid & HOSTFS_ATTR_SIZE) {
-        if((attrs->ia_valid & ma) == ma){
+                if (fd >= 0) {
-                buf.actime = attrs->ia_atime.tv_sec;
+                        if (ftruncate(fd, attrs->ia_size))
-                buf.modtime = attrs->ia_mtime.tv_sec;
+                                return -errno;
-                if(utime(file, &buf) != 0) return(-errno);
+                } else if (truncate(file, attrs->ia_size)) {
+                        return -errno;
+                }
        }
-        else {
-                struct timespec ts;
+        /* Update accessed and/or modified time, in two parts: first set
+         * times according to the changes to perform, and then call futimes()
-                if(attrs->ia_valid & HOSTFS_ATTR_ATIME_SET){
+         * or utimes() to apply them. */
-                        err = stat_file(file, NULL, NULL, NULL, NULL, NULL,
+        ma = (HOSTFS_ATTR_ATIME_SET | HOSTFS_ATTR_MTIME_SET);
-                                        NULL, NULL, &ts, NULL, NULL, NULL);
+        if (attrs->ia_valid & ma) {
-                        if(err != 0)
+                err = stat_file(file, NULL, NULL, NULL, NULL, NULL, NULL,
-                                return(err);
+                                &atime_ts, &mtime_ts, NULL, NULL, NULL, fd);
-                        buf.actime = attrs->ia_atime.tv_sec;
+                if (err != 0)
-                        buf.modtime = ts.tv_sec;
+                        return err;
-                        if(utime(file, &buf) != 0)
-                                return(-errno);
+                times[0].tv_sec = atime_ts.tv_sec;
+                times[0].tv_usec = atime_ts.tv_nsec * 1000;
+                times[1].tv_sec = mtime_ts.tv_sec;
+                times[1].tv_usec = mtime_ts.tv_nsec * 1000;
+                if (attrs->ia_valid & HOSTFS_ATTR_ATIME_SET) {
+                        times[0].tv_sec = attrs->ia_atime.tv_sec;
+                        times[0].tv_usec = attrs->ia_atime.tv_nsec * 1000;
+                }
+                if (attrs->ia_valid & HOSTFS_ATTR_MTIME_SET) {
+                        times[1].tv_sec = attrs->ia_mtime.tv_sec;
+                        times[1].tv_usec = attrs->ia_mtime.tv_nsec * 1000;
                }
-                if(attrs->ia_valid & HOSTFS_ATTR_MTIME_SET){
-                        err = stat_file(file, NULL, NULL, NULL, NULL, NULL,
+                if (fd >= 0) {
-                                        NULL, &ts, NULL, NULL, NULL, NULL);
+                        if (futimes(fd, times) != 0)
-                        if(err != 0)
+                                return -errno;
-                                return(err);
+                } else if (utimes(file, times) != 0) {
-                        buf.actime = ts.tv_sec;
+                        return -errno;
-                        buf.modtime = attrs->ia_mtime.tv_sec;
-                        if(utime(file, &buf) != 0)
-                                return(-errno);
                }
        }
        if(attrs->ia_valid & HOSTFS_ATTR_CTIME) ;
        if(attrs->ia_valid & (HOSTFS_ATTR_ATIME | HOSTFS_ATTR_MTIME)){
                err = stat_file(file, NULL, NULL, NULL, NULL, NULL, NULL,
                                &attrs->ia_atime, &attrs->ia_mtime, NULL,
-                                NULL, NULL);
+                                NULL, NULL, fd);
-                if(err != 0) return(err);
+                if(err != 0)
+                        return err;
        }
-        return(0);
+        return 0;
 }
 int make_symlink(const char *from, const char *to)
@@ -264,8 +299,9 @@ int make_symlink(const char *from, const char *to)
        int err;
        err = symlink(to, from);
-        if(err) return(-errno);
+        if(err)
-        return(0);
+                return -errno;
+        return 0;
 }
 int unlink_file(const char *file)
@@ -273,8 +309,9 @@ int unlink_file(const char *file)
        int err;
        err = unlink(file);
-        if(err) return(-errno);
+        if(err)
-        return(0);
+                return -errno;
+        return 0;
 }
 int do_mkdir(const char *file, int mode)
@@ -282,8 +319,9 @@ int do_mkdir(const char *file, int mode)
        int err;
        err = mkdir(file, mode);
-        if(err) return(-errno);
+        if(err)
-        return(0);
+                return -errno;
+        return 0;
 }
 int do_rmdir(const char *file)
@@ -291,8 +329,9 @@ int do_rmdir(const char *file)
        int err;
        err = rmdir(file);
-        if(err) return(-errno);
+        if(err)
-        return(0);
+                return -errno;
+        return 0;
 }
 int do_mknod(const char *file, int mode, unsigned int major, unsigned int minor)
@@ -300,8 +339,9 @@ int do_mknod(const char *file, int mode, unsigned int major, unsigned int minor)
        int err;
        err = mknod(file, mode, makedev(major, minor));
-        if(err) return(-errno);
+        if(err)
-        return(0);
+                return -errno;
+        return 0;
 }
 int link_file(const char *to, const char *from)
@@ -309,8 +349,9 @@ int link_file(const char *to, const char *from)
        int err;
        err = link(to, from);
-        if(err) return(-errno);
+        if(err)
-        return(0);
+                return -errno;
+        return 0;
 }
 int do_readlink(char *file, char *buf, int size)
@@ -319,10 +360,10 @@ int do_readlink(char *file, char *buf, int size)
        n = readlink(file, buf, size);
        if(n < 0)
-                return(-errno);
+                return -errno;
        if(n < size)
                buf[n] = '\0';
-        return(n);
+        return n;
 }
 int rename_file(char *from, char *to)
@@ -330,8 +371,9 @@ int rename_file(char *from, char *to)
        int err;
        err = rename(from, to);
-        if(err < 0) return(-errno);
+        if(err < 0)
-        return(0);
+                return -errno;
+        return 0;
 }
 int do_statfs(char *root, long *bsize_out, long long *blocks_out,
@@ -344,7 +386,9 @@ int do_statfs(char *root, long *bsize_out, long long *blocks_out,
        int err;
        err = statfs64(root, &buf);
-        if(err < 0) return(-errno);
+        if(err < 0)
+                return -errno;
        *bsize_out = buf.f_bsize;
        *blocks_out = buf.f_blocks;
        *bfree_out = buf.f_bfree;
@@ -360,16 +404,5 @@ int do_statfs(char *root, long *bsize_out, long long *blocks_out,
        spare_out[2] = buf.f_spare[2];
        spare_out[3] = buf.f_spare[3];
        spare_out[4] = buf.f_spare[4];
-        return(0);
+        return 0;
 }
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/fs/inode.c b/fs/inode.c
index b4296bf62739..df2ef15d03d2 100644
--- a/fs/inode.c
+++ b/fs/inode.c
@@ -250,7 +250,7 @@ void clear_inode(struct inode *inode)
        BUG_ON(inode->i_state & I_CLEAR);
        wait_on_inode(inode);
        DQUOT_DROP(inode);
-        if (inode->i_sb && inode->i_sb->s_op->clear_inode)
+        if (inode->i_sb->s_op->clear_inode)
                inode->i_sb->s_op->clear_inode(inode);
        if (S_ISBLK(inode->i_mode) && inode->i_bdev)
                bd_forget(inode);
@@ -275,7 +275,7 @@ static void dispose_list(struct list_head *head)
        while (!list_empty(head)) {
                struct inode *inode;
-                inode = list_entry(head->next, struct inode, i_list);
+                inode = list_first_entry(head, struct inode, i_list);
                list_del(&inode->i_list);
                if (inode->i_data.nrpages)
@@ -524,7 +524,12 @@ repeat:
 */
 struct inode *new_inode(struct super_block *sb)
 {
-        static unsigned long last_ino;
+        /*
+         * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
+         * error if st_ino won't fit in target struct field. Use 32bit counter
+         * here to attempt to avoid that.
+         */
+        static unsigned int last_ino;
        struct inode * inode;
        spin_lock_prefetch(&inode_lock);
@@ -683,27 +688,28 @@ static unsigned long hash(struct super_block *sb, unsigned long hashval)
 */
 ino_t iunique(struct super_block *sb, ino_t max_reserved)
 {
-        static ino_t counter;
+        /*
+         * On a 32bit, non LFS stat() call, glibc will generate an EOVERFLOW
+         * error if st_ino won't fit in target struct field. Use 32bit counter
+         * here to attempt to avoid that.
+         */
+        static unsigned int counter;
        struct inode *inode;
-        struct hlist_head * head;
+        struct hlist_head *head;
        ino_t res;
        spin_lock(&inode_lock);
-retry:
+        do {
-        if (counter > max_reserved) {
+                if (counter <= max_reserved)
-                head = inode_hashtable + hash(sb,counter);
+                        counter = max_reserved + 1;
                res = counter++;
+                head = inode_hashtable + hash(sb, res);
                inode = find_inode_fast(sb, head, res);
-                if (!inode) {
+        } while (inode != NULL);
-                        spin_unlock(&inode_lock);
+        spin_unlock(&inode_lock);
-                        return res;
-                }
-        } else {
-                counter = max_reserved + 1;
-        }
-        goto retry;
-        
-}
+        return res;
+}
 EXPORT_SYMBOL(iunique);
 struct inode *igrab(struct inode *inode)
@@ -1040,7 +1046,7 @@ static void generic_forget_inode(struct inode *inode)
                if (!(inode->i_state & (I_DIRTY|I_LOCK)))
                        list_move(&inode->i_list, &inode_unused);
                inodes_stat.nr_unused++;
-                if (!sb || (sb->s_flags & MS_ACTIVE)) {
+                if (sb->s_flags & MS_ACTIVE) {
                        spin_unlock(&inode_lock);
                        return;
                }
diff --git a/fs/inotify.c b/fs/inotify.c
index f5099d86fd91..7457501b9565 100644
--- a/fs/inotify.c
+++ b/fs/inotify.c
@@ -509,7 +509,7 @@ void inotify_destroy(struct inotify_handle *ih)
                        mutex_unlock(&ih->mutex);
                        break;
                }
-                watch = list_entry(watches->next, struct inotify_watch, h_list);
+                watch = list_first_entry(watches, struct inotify_watch, h_list);
                get_inotify_watch(watch);
                mutex_unlock(&ih->mutex);
diff --git a/fs/internal.h b/fs/internal.h
index ea00126c9a59..392e8ccd6fc4 100644
--- a/fs/internal.h
+++ b/fs/internal.h
@@ -9,8 +9,6 @@
 * 2 of the License, or (at your option) any later version.
 */
-#include <linux/ioctl32.h>
 struct super_block;
 /*
@@ -42,14 +40,6 @@ static inline int sb_is_blkdev_sb(struct super_block *sb)
 extern void __init chrdev_init(void);
 /*
- * compat_ioctl.c
- */
-#ifdef CONFIG_COMPAT
-extern struct ioctl_trans ioctl_start[];
-extern int ioctl_table_size;
-#endif
-/*
 * namespace.c
 */
 extern int copy_mount_options(const void __user *, unsigned long *);
diff --git a/fs/ioctl.c b/fs/ioctl.c
index ff61772ceedd..479c1038ed4a 100644
--- a/fs/ioctl.c
+++ b/fs/ioctl.c
@@ -67,8 +67,6 @@ static int file_ioctl(struct file *filp, unsigned int cmd,
                        return put_user(res, p);
                }
                case FIGETBSZ:
-                        if (inode->i_sb == NULL)
-                                return -EBADF;
                        return put_user(inode->i_sb->s_blocksize, p);
                case FIONREAD:
                        return put_user(i_size_read(inode) - filp->f_pos, p);
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index be4648bc7a2f..1facfaff97cb 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -20,7 +20,6 @@
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/pagemap.h>
-#include <linux/smp_lock.h>
 /*
 * Default IO end handler for temporary BJ_IO buffer_heads.
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index 10fff9443938..46fe7439fb91 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -28,7 +28,6 @@
 #include <linux/jbd.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/freezer.h>
@@ -211,10 +210,16 @@ end_loop:
        return 0;
 }
-static void journal_start_thread(journal_t *journal)
+static int journal_start_thread(journal_t *journal)
 {
-        kthread_run(kjournald, journal, "kjournald");
+        struct task_struct *t;
+        t = kthread_run(kjournald, journal, "kjournald");
+        if (IS_ERR(t))
+                return PTR_ERR(t);
        wait_event(journal->j_wait_done_commit, journal->j_task != 0);
+        return 0;
 }
 static void journal_kill_thread(journal_t *journal)
@@ -840,8 +845,7 @@ static int journal_reset(journal_t *journal)
        /* Add the dynamic fields and write it to disk. */
        journal_update_superblock(journal, 1);
-        journal_start_thread(journal);
+        return journal_start_thread(journal);
-        return 0;
 }
 /**
diff --git a/fs/jbd/revoke.c b/fs/jbd/revoke.c
index d204ab394f36..a68cbb605022 100644
--- a/fs/jbd/revoke.c
+++ b/fs/jbd/revoke.c
@@ -66,7 +66,6 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/list.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #endif
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index cceaf57e3778..f9822fc07851 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -23,7 +23,6 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/timer.h>
-#include <linux/smp_lock.h>
 #include <linux/mm.h>
 #include <linux/highmem.h>
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 6bd8005e3d34..2856e1100a5f 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -20,7 +20,6 @@
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/pagemap.h>
-#include <linux/smp_lock.h>
 /*
 * Default IO end handler for temporary BJ_IO buffer_heads.
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 44fc32bfd7f1..78d63b818f0b 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -28,7 +28,6 @@
 #include <linux/jbd2.h>
 #include <linux/errno.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/mm.h>
 #include <linux/freezer.h>
@@ -211,10 +210,16 @@ end_loop:
        return 0;
 }
-static void jbd2_journal_start_thread(journal_t *journal)
+static int jbd2_journal_start_thread(journal_t *journal)
 {
-        kthread_run(kjournald2, journal, "kjournald2");
+        struct task_struct *t;
+        t = kthread_run(kjournald2, journal, "kjournald2");
+        if (IS_ERR(t))
+                return PTR_ERR(t);
        wait_event(journal->j_wait_done_commit, journal->j_task != 0);
+        return 0;
 }
 static void journal_kill_thread(journal_t *journal)
@@ -840,8 +845,7 @@ static int journal_reset(journal_t *journal)
        /* Add the dynamic fields and write it to disk. */
        jbd2_journal_update_superblock(journal, 1);
-        jbd2_journal_start_thread(journal);
+        return jbd2_journal_start_thread(journal);
-        return 0;
 }
 /**
diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index f506646ad0ff..1e864dcc49ea 100644
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -66,7 +66,6 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/list.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #endif
diff --git a/fs/jbd2/transaction.c b/fs/jbd2/transaction.c
index 3a8700153cb0..e347d8c078bc 100644
--- a/fs/jbd2/transaction.c
+++ b/fs/jbd2/transaction.c
@@ -23,7 +23,6 @@
 #include <linux/errno.h>
 #include <linux/slab.h>
 #include <linux/timer.h>
-#include <linux/smp_lock.h>
 #include <linux/mm.h>
 #include <linux/highmem.h>
diff --git a/fs/jfs/inode.c b/fs/jfs/inode.c
index e285022f006c..3467dde27e5a 100644
--- a/fs/jfs/inode.c
+++ b/fs/jfs/inode.c
@@ -55,7 +55,6 @@ void jfs_read_inode(struct inode *inode)
                inode->i_op = &jfs_file_inode_operations;
                init_special_inode(inode, inode->i_mode, inode->i_rdev);
        }
-        jfs_set_inode_flags(inode);
 }
 /*
diff --git a/fs/jfs/ioctl.c b/fs/jfs/ioctl.c
index ed814b1ff4d9..fe063af6fd2f 100644
--- a/fs/jfs/ioctl.c
+++ b/fs/jfs/ioctl.c
@@ -59,6 +59,7 @@ int jfs_ioctl(struct inode * inode, struct file * filp, unsigned int cmd,
        switch (cmd) {
        case JFS_IOC_GETFLAGS:
+                jfs_get_inode_flags(jfs_inode);
                flags = jfs_inode->mode2 & JFS_FL_USER_VISIBLE;
                flags = jfs_map_ext2(flags, 0);
                return put_user(flags, (int __user *) arg);
@@ -78,6 +79,7 @@ int jfs_ioctl(struct inode * inode, struct file * filp, unsigned int cmd,
                if (!S_ISDIR(inode->i_mode))
                        flags &= ~JFS_DIRSYNC_FL;
+                jfs_get_inode_flags(jfs_inode);
                oldflags = jfs_inode->mode2;
                /*
diff --git a/fs/jfs/jfs_imap.c b/fs/jfs/jfs_imap.c
index aa5124b643b1..c465607be991 100644
--- a/fs/jfs/jfs_imap.c
+++ b/fs/jfs/jfs_imap.c
@@ -3078,6 +3078,7 @@ static int copy_from_dinode(struct dinode * dip, struct inode *ip)
        jfs_ip->fileset = le32_to_cpu(dip->di_fileset);
        jfs_ip->mode2 = le32_to_cpu(dip->di_mode);
+        jfs_set_inode_flags(ip);
        ip->i_mode = le32_to_cpu(dip->di_mode) & 0xffff;
        if (sbi->umask != -1) {
@@ -3174,6 +3175,7 @@ static void copy_to_dinode(struct dinode * dip, struct inode *ip)
                dip->di_gid = cpu_to_le32(ip->i_gid);
        else
                dip->di_gid = cpu_to_le32(jfs_ip->saved_gid);
+        jfs_get_inode_flags(jfs_ip);
        /*
         * mode2 is only needed for storing the higher order bits.
         * Trust i_mode for the lower order ones
diff --git a/fs/jfs/jfs_inode.c b/fs/jfs/jfs_inode.c
index 4c67ed97682b..ed6574bee51a 100644
--- a/fs/jfs/jfs_inode.c
+++ b/fs/jfs/jfs_inode.c
@@ -45,6 +45,24 @@ void jfs_set_inode_flags(struct inode *inode)
                inode->i_flags |= S_SYNC;
 }
+void jfs_get_inode_flags(struct jfs_inode_info *jfs_ip)
+{
+        unsigned int flags = jfs_ip->vfs_inode.i_flags;
+        jfs_ip->mode2 &= ~(JFS_IMMUTABLE_FL | JFS_APPEND_FL | JFS_NOATIME_FL |
+                           JFS_DIRSYNC_FL | JFS_SYNC_FL);
+        if (flags & S_IMMUTABLE)
+                jfs_ip->mode2 |= JFS_IMMUTABLE_FL;
+        if (flags & S_APPEND)
+                jfs_ip->mode2 |= JFS_APPEND_FL;
+        if (flags & S_NOATIME)
+                jfs_ip->mode2 |= JFS_NOATIME_FL;
+        if (flags & S_DIRSYNC)
+                jfs_ip->mode2 |= JFS_DIRSYNC_FL;
+        if (flags & S_SYNC)
+                jfs_ip->mode2 |= JFS_SYNC_FL;
+}
 /*
 * NAME:        ialloc()
 *
diff --git a/fs/jfs/jfs_inode.h b/fs/jfs/jfs_inode.h
index 6802837f757e..2374b595f2e1 100644
--- a/fs/jfs/jfs_inode.h
+++ b/fs/jfs/jfs_inode.h
@@ -31,6 +31,7 @@ extern void jfs_truncate(struct inode *);
 extern void jfs_truncate_nolock(struct inode *, loff_t);
 extern void jfs_free_zero_link(struct inode *);
 extern struct dentry *jfs_get_parent(struct dentry *dentry);
+extern void jfs_get_inode_flags(struct jfs_inode_info *);
 extern void jfs_set_inode_flags(struct inode *);
 extern int jfs_get_block(struct inode *, sector_t, struct buffer_head *, int);
diff --git a/fs/jfs/jfs_lock.h b/fs/jfs/jfs_lock.h
index df48ece4b7a3..ecf04882265e 100644
--- a/fs/jfs/jfs_lock.h
+++ b/fs/jfs/jfs_lock.h
@@ -45,7 +45,7 @@ do {							\
                io_schedule();                          \
                lock_cmd;                               \
        }                                               \
-        current->state = TASK_RUNNING;                  \
+        __set_current_state(TASK_RUNNING);                      \
        remove_wait_queue(&wq, &__wait);                \
 } while (0)
diff --git a/fs/jfs/jfs_logmgr.c b/fs/jfs/jfs_logmgr.c
index 5065baa530b6..6a3f00dc8c83 100644
--- a/fs/jfs/jfs_logmgr.c
+++ b/fs/jfs/jfs_logmgr.c
@@ -62,7 +62,6 @@
 #include <linux/fs.h>
 #include <linux/blkdev.h>
 #include <linux/interrupt.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/kthread.h>
 #include <linux/buffer_head.h>          /* for sync_blockdev() */
@@ -1590,7 +1589,7 @@ void jfs_flush_journal(struct jfs_log *log, int wait)
                set_current_state(TASK_UNINTERRUPTIBLE);
                LOGGC_UNLOCK(log);
                schedule();
-                current->state = TASK_RUNNING;
+                __set_current_state(TASK_RUNNING);
                LOGGC_LOCK(log);
                remove_wait_queue(&target->gcwait, &__wait);
        }
@@ -2354,14 +2353,15 @@ int jfsIOWait(void *arg)
                        lbmStartIO(bp);
                        spin_lock_irq(&log_redrive_lock);
                }
-                spin_unlock_irq(&log_redrive_lock);
                if (freezing(current)) {
+                        spin_unlock_irq(&log_redrive_lock);
                        refrigerator();
                } else {
                        set_current_state(TASK_INTERRUPTIBLE);
+                        spin_unlock_irq(&log_redrive_lock);
                        schedule();
-                        current->state = TASK_RUNNING;
+                        __set_current_state(TASK_RUNNING);
                }
        } while (!kthread_should_stop());
diff --git a/fs/jfs/jfs_txnmgr.c b/fs/jfs/jfs_txnmgr.c
index 03893acbfda4..25430d0b0d59 100644
--- a/fs/jfs/jfs_txnmgr.c
+++ b/fs/jfs/jfs_txnmgr.c
@@ -44,7 +44,6 @@
 #include <linux/fs.h>
 #include <linux/vmalloc.h>
-#include <linux/smp_lock.h>
 #include <linux/completion.h>
 #include <linux/freezer.h>
 #include <linux/module.h>
@@ -136,7 +135,7 @@ static inline void TXN_SLEEP_DROP_LOCK(wait_queue_head_t * event)
        set_current_state(TASK_UNINTERRUPTIBLE);
        TXN_UNLOCK();
        io_schedule();
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
        remove_wait_queue(event, &wait);
 }
@@ -2798,7 +2797,7 @@ int jfs_lazycommit(void *arg)
                        set_current_state(TASK_INTERRUPTIBLE);
                        LAZY_UNLOCK(flags);
                        schedule();
-                        current->state = TASK_RUNNING;
+                        __set_current_state(TASK_RUNNING);
                        remove_wait_queue(&jfs_commit_thread_wait, &wq);
                }
        } while (!kthread_should_stop());
@@ -2990,7 +2989,7 @@ int jfs_sync(void *arg)
                        set_current_state(TASK_INTERRUPTIBLE);
                        TXN_UNLOCK();
                        schedule();
-                        current->state = TASK_RUNNING;
+                        __set_current_state(TASK_RUNNING);
                }
        } while (!kthread_should_stop());
diff --git a/fs/libfs.c b/fs/libfs.c
index d93842d3c0a0..1247ee90253a 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -220,6 +220,12 @@ int get_sb_pseudo(struct file_system_type *fs_type, char *name,
        root = new_inode(s);
        if (!root)
                goto Enomem;
+        /*
+         * since this is the first inode, make it number 1. New inodes created
+         * after this must take care not to collide with it (by passing
+         * max_reserved of 1 to iunique).
+         */
+        root->i_ino = 1;
        root->i_mode = S_IFDIR | S_IRUSR | S_IWUSR;
        root->i_uid = root->i_gid = 0;
        root->i_atime = root->i_mtime = root->i_ctime = CURRENT_TIME;
@@ -360,6 +366,11 @@ int simple_commit_write(struct file *file, struct page *page,
        return 0;
 }
+/*
+ * the inodes created here are not hashed. If you use iunique to generate
+ * unique inode values later for this filesystem, then you must take care
+ * to pass it an appropriate max_reserved value to avoid collisions.
+ */
 int simple_fill_super(struct super_block *s, int magic, struct tree_descr *files)
 {
        struct inode *inode;
@@ -376,6 +387,11 @@ int simple_fill_super(struct super_block *s, int magic, struct tree_descr *files
        inode = new_inode(s);
        if (!inode)
                return -ENOMEM;
+        /*
+         * because the root inode is 1, the files array must not contain an
+         * entry at index 1
+         */
+        inode->i_ino = 1;
        inode->i_mode = S_IFDIR | 0755;
        inode->i_uid = inode->i_gid = 0;
        inode->i_blocks = 0;
@@ -391,6 +407,13 @@ int simple_fill_super(struct super_block *s, int magic, struct tree_descr *files
        for (i = 0; !files->name || files->name[0]; i++, files++) {
                if (!files->name)
                        continue;
+                /* warn if it tries to conflict with the root inode */
+                if (unlikely(i == 1))
+                        printk(KERN_WARNING "%s: %s passed in a files array"
+                                "with an index of 1!\n", __func__,
+                                s->s_type->name);
                dentry = d_alloc_name(root, files->name);
                if (!dentry)
                        goto out;
diff --git a/fs/lockd/clntproc.c b/fs/lockd/clntproc.c
index a5c019e1a447..a10343bed160 100644
--- a/fs/lockd/clntproc.c
+++ b/fs/lockd/clntproc.c
@@ -12,7 +12,6 @@
 #include <linux/fs.h>
 #include <linux/nfs_fs.h>
 #include <linux/utsname.h>
-#include <linux/smp_lock.h>
 #include <linux/freezer.h>
 #include <linux/sunrpc/clnt.h>
 #include <linux/sunrpc/svc.h>
diff --git a/fs/mpage.c b/fs/mpage.c
index 692a3e578fc8..fa2441f57b41 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -663,12 +663,7 @@ confused:
        /*
         * The caller has a ref on the inode, so *mapping is stable
         */
-        if (*ret) {
+        mapping_set_error(mapping, *ret);
-                if (*ret == -ENOSPC)
-                        set_bit(AS_ENOSPC, &mapping->flags);
-                else
-                        set_bit(AS_EIO, &mapping->flags);
-        }
 out:
        return bio;
 }
@@ -776,14 +771,7 @@ retry:
                        if (writepage) {
                                ret = (*writepage)(page, wbc);
-                                if (ret) {
+                                mapping_set_error(mapping, ret);
-                                        if (ret == -ENOSPC)
-                                                set_bit(AS_ENOSPC,
-                                                        &mapping->flags);
-                                        else
-                                                set_bit(AS_EIO,
-                                                        &mapping->flags);
-                                }
                        } else {
                                bio = __mpage_writepage(bio, page, get_block,
                                                &last_block_in_bio, &ret, wbc,
diff --git a/fs/namei.c b/fs/namei.c
index 94b2f60aec22..856b2f5da51d 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -22,7 +22,6 @@
 #include <linux/quotaops.h>
 #include <linux/pagemap.h>
 #include <linux/fsnotify.h>
-#include <linux/smp_lock.h>
 #include <linux/personality.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
@@ -1350,17 +1349,6 @@ struct dentry *lookup_one_len_kern(const char *name, struct dentry *base, int le
        return __lookup_hash_kern(&this, base, NULL);
 }
-/*
- *      namei()
- *
- * is used by most simple commands to get the inode of a specified name.
- * Open, link etc use their own routines, but this is enough for things
- * like 'chmod' etc.
- *
- * namei exists in two versions: namei/lnamei. The only difference is
- * that namei follows links, while lnamei does not.
- * SMP-safe
- */
 int fastcall __user_walk_fd(int dfd, const char __user *name, unsigned flags,
                            struct nameidata *nd)
 {
diff --git a/fs/namespace.c b/fs/namespace.c
index fd999cab7b57..b696e3a0d18f 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -377,6 +377,10 @@ static int show_vfsmnt(struct seq_file *m, void *v)
        seq_path(m, mnt, mnt->mnt_root, " \t\n\\");
        seq_putc(m, ' ');
        mangle(m, mnt->mnt_sb->s_type->name);
+        if (mnt->mnt_sb->s_subtype && mnt->mnt_sb->s_subtype[0]) {
+                seq_putc(m, '.');
+                mangle(m, mnt->mnt_sb->s_subtype);
+        }
        seq_puts(m, mnt->mnt_sb->s_flags & MS_RDONLY ? " ro" : " rw");
        for (fs_infop = fs_info; fs_infop->flag; fs_infop++) {
                if (mnt->mnt_sb->s_flags & fs_infop->flag)
@@ -495,7 +499,7 @@ void release_mounts(struct list_head *head)
 {
        struct vfsmount *mnt;
        while (!list_empty(head)) {
-                mnt = list_entry(head->next, struct vfsmount, mnt_hash);
+                mnt = list_first_entry(head, struct vfsmount, mnt_hash);
                list_del_init(&mnt->mnt_hash);
                if (mnt->mnt_parent != mnt) {
                        struct dentry *dentry;
@@ -882,6 +886,9 @@ static int do_change_type(struct nameidata *nd, int flag)
        int recurse = flag & MS_REC;
        int type = flag & ~MS_REC;
+        if (!capable(CAP_SYS_ADMIN))
+                return -EPERM;
        if (nd->dentry != nd->mnt->mnt_root)
                return -EINVAL;
@@ -1173,7 +1180,7 @@ static void expire_mount_list(struct list_head *graveyard, struct list_head *mou
        while (!list_empty(graveyard)) {
                LIST_HEAD(umounts);
-                mnt = list_entry(graveyard->next, struct vfsmount, mnt_expire);
+                mnt = list_first_entry(graveyard, struct vfsmount, mnt_expire);
                list_del_init(&mnt->mnt_expire);
                /* don't do anything if the namespace is dead - all the
@@ -1441,10 +1448,9 @@ dput_out:
 * Allocate a new namespace structure and populate it with contents
 * copied from the namespace of the passed in task structure.
 */
-struct mnt_namespace *dup_mnt_ns(struct task_struct *tsk,
+static struct mnt_namespace *dup_mnt_ns(struct mnt_namespace *mnt_ns,
                struct fs_struct *fs)
 {
-        struct mnt_namespace *mnt_ns = tsk->nsproxy->mnt_ns;
        struct mnt_namespace *new_ns;
        struct vfsmount *rootmnt = NULL, *pwdmnt = NULL, *altrootmnt = NULL;
        struct vfsmount *p, *q;
@@ -1509,36 +1515,21 @@ struct mnt_namespace *dup_mnt_ns(struct task_struct *tsk,
        return new_ns;
 }
-int copy_mnt_ns(int flags, struct task_struct *tsk)
+struct mnt_namespace *copy_mnt_ns(int flags, struct mnt_namespace *ns,
+                struct fs_struct *new_fs)
 {
-        struct mnt_namespace *ns = tsk->nsproxy->mnt_ns;
        struct mnt_namespace *new_ns;
-        int err = 0;
-        if (!ns)
-                return 0;
+        BUG_ON(!ns);
        get_mnt_ns(ns);
        if (!(flags & CLONE_NEWNS))
-                return 0;
+                return ns;
-        if (!capable(CAP_SYS_ADMIN)) {
+        new_ns = dup_mnt_ns(ns, new_fs);
-                err = -EPERM;
-                goto out;
-        }
-        new_ns = dup_mnt_ns(tsk, tsk->fs);
-        if (!new_ns) {
-                err = -ENOMEM;
-                goto out;
-        }
-        tsk->nsproxy->mnt_ns = new_ns;
-out:
        put_mnt_ns(ns);
-        return err;
+        return new_ns;
 }
 asmlinkage long sys_mount(char __user * dev_name, char __user * dir_name,
diff --git a/fs/ncpfs/file.c b/fs/ncpfs/file.c
index 6b1f6d27099a..addfd3147ea7 100644
--- a/fs/ncpfs/file.c
+++ b/fs/ncpfs/file.c
@@ -17,7 +17,6 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/vmalloc.h>
-#include <linux/smp_lock.h>
 #include <linux/ncp_fs.h>
 #include "ncplib_kernel.h"
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 5bd03b97002e..50c6821bad26 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -27,7 +27,6 @@
 #include <linux/nfs_mount.h>
 #include <linux/nfs4_mount.h>
 #include <linux/lockd/bind.h>
-#include <linux/smp_lock.h>
 #include <linux/seq_file.h>
 #include <linux/mount.h>
 #include <linux/nfs_idmap.h>
diff --git a/fs/nfs/direct.c b/fs/nfs/direct.c
index 889de60f8a84..345aa5c0f382 100644
--- a/fs/nfs/direct.c
+++ b/fs/nfs/direct.c
@@ -41,7 +41,6 @@
 #include <linux/errno.h>
 #include <linux/sched.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include <linux/file.h>
 #include <linux/pagemap.h>
 #include <linux/kref.h>
diff --git a/fs/nfs/getroot.c b/fs/nfs/getroot.c
index 6ef268f7c300..234778576f09 100644
--- a/fs/nfs/getroot.c
+++ b/fs/nfs/getroot.c
@@ -25,7 +25,6 @@
 #include <linux/nfs_mount.h>
 #include <linux/nfs4_mount.h>
 #include <linux/lockd/bind.h>
-#include <linux/smp_lock.h>
 #include <linux/seq_file.h>
 #include <linux/mount.h>
 #include <linux/nfs_idmap.h>
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 7d0371e2bad5..45268d6def2e 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -16,7 +16,6 @@
 #include <linux/nfs_fs.h>
 #include <linux/nfs_page.h>
 #include <linux/lockd/bind.h>
-#include <linux/smp_lock.h>
 #include <linux/nfs_mount.h>
 #include "iostat.h"
diff --git a/fs/nfs/nfs4renewd.c b/fs/nfs/nfs4renewd.c
index f5f4430fb2a4..0505ca124034 100644
--- a/fs/nfs/nfs4renewd.c
+++ b/fs/nfs/nfs4renewd.c
@@ -43,7 +43,6 @@
 * child task framework of the RPC layer?
 */
-#include <linux/smp_lock.h>
 #include <linux/mm.h>
 #include <linux/pagemap.h>
 #include <linux/sunrpc/sched.h>
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 1dcf56de9482..7be0ee2782cb 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -43,7 +43,6 @@
 #include <linux/nfs_fs.h>
 #include <linux/nfs_page.h>
 #include <linux/lockd/bind.h>
-#include <linux/smp_lock.h>
 #include "internal.h"
 #define NFSDBG_FACILITY         NFSDBG_PROC
diff --git a/fs/nfs/symlink.c b/fs/nfs/symlink.c
index bc2821331c29..83e865a16ad1 100644
--- a/fs/nfs/symlink.c
+++ b/fs/nfs/symlink.c
@@ -22,7 +22,6 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/namei.h>
 /* Symlink caching in the page cache is even more simplistic
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 5d44b8bd1070..de92b9509d94 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -21,7 +21,6 @@
 #include <linux/backing-dev.h>
 #include <asm/uaccess.h>
-#include <linux/smp_lock.h>
 #include "delegation.h"
 #include "internal.h"
@@ -225,7 +224,7 @@ static int nfs_set_page_writeback(struct page *page)
                struct inode *inode = page->mapping->host;
                struct nfs_server *nfss = NFS_SERVER(inode);
-                if (atomic_inc_return(&nfss->writeback) >
+                if (atomic_long_inc_return(&nfss->writeback) >
                                NFS_CONGESTION_ON_THRESH)
                        set_bdi_congested(&nfss->backing_dev_info, WRITE);
        }
@@ -238,7 +237,7 @@ static void nfs_end_page_writeback(struct page *page)
        struct nfs_server *nfss = NFS_SERVER(inode);
        end_page_writeback(page);
-        if (atomic_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH) {
+        if (atomic_long_dec_return(&nfss->writeback) < NFS_CONGESTION_OFF_THRESH) {
                clear_bdi_congested(&nfss->backing_dev_info, WRITE);
                congestion_end(WRITE);
        }
diff --git a/fs/nfsd/nfs4idmap.c b/fs/nfsd/nfs4idmap.c
index e4a83d727afd..45aa21ce6784 100644
--- a/fs/nfsd/nfs4idmap.c
+++ b/fs/nfsd/nfs4idmap.c
@@ -46,7 +46,6 @@
 #include <linux/nfs4.h>
 #include <linux/nfs_fs.h>
 #include <linux/nfs_page.h>
-#include <linux/smp_lock.h>
 #include <linux/sunrpc/cache.h>
 #include <linux/nfsd_idmap.h>
 #include <linux/list.h>
diff --git a/fs/nfsd/nfs4xdr.c b/fs/nfsd/nfs4xdr.c
index 5d090f11f2be..15809dfd88a5 100644
--- a/fs/nfsd/nfs4xdr.c
+++ b/fs/nfsd/nfs4xdr.c
@@ -44,7 +44,6 @@
 #include <linux/param.h>
 #include <linux/smp.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 #include <linux/namei.h>
 #include <linux/vfs.h>
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 8d995bcef806..739dd3c5c3b2 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -10,7 +10,6 @@
 */
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 #include <linux/unistd.h>
 #include <linux/string.h>
diff --git a/fs/ntfs/dir.c b/fs/ntfs/dir.c
index 74f99a6a369b..34314b33dbd4 100644
--- a/fs/ntfs/dir.c
+++ b/fs/ntfs/dir.c
@@ -20,7 +20,6 @@
 * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
-#include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 #include "dir.h"
diff --git a/fs/ntfs/file.c b/fs/ntfs/file.c
index dbbac5593106..621de369e6f8 100644
--- a/fs/ntfs/file.c
+++ b/fs/ntfs/file.c
@@ -2129,28 +2129,13 @@ static ssize_t ntfs_file_aio_write_nolock(struct kiocb *iocb,
        struct address_space *mapping = file->f_mapping;
        struct inode *inode = mapping->host;
        loff_t pos;
-        unsigned long seg;
        size_t count;           /* after file limit checks */
        ssize_t written, err;
        count = 0;
-        for (seg = 0; seg < nr_segs; seg++) {
+        err = generic_segment_checks(iov, &nr_segs, &count, VERIFY_READ);
-                const struct iovec *iv = &iov[seg];
+        if (err)
-                /*
+                return err;
-                 * If any segment has a negative length, or the cumulative
-                 * length ever wraps negative then return -EINVAL.
-                 */
-                count += iv->iov_len;
-                if (unlikely((ssize_t)(count|iv->iov_len) < 0))
-                        return -EINVAL;
-                if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
-                        continue;
-                if (!seg)
-                        return -EFAULT;
-                nr_segs = seg;
-                count -= iv->iov_len;   /* This segment is no good */
-                break;
-        }
        pos = *ppos;
        vfs_check_frozen(inode->i_sb, SB_FREEZE_WRITE);
        /* We can write back this queue in page reclaim. */
diff --git a/fs/ntfs/inode.c b/fs/ntfs/inode.c
index f8bf8da67ee8..074791ce4ab2 100644
--- a/fs/ntfs/inode.c
+++ b/fs/ntfs/inode.c
@@ -27,7 +27,6 @@
 #include <linux/pagemap.h>
 #include <linux/quotaops.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include "aops.h"
 #include "attrib.h"
diff --git a/fs/ocfs2/dlm/dlmfs.c b/fs/ocfs2/dlm/dlmfs.c
index d4e46d067edd..5671cf9d6383 100644
--- a/fs/ocfs2/dlm/dlmfs.c
+++ b/fs/ocfs2/dlm/dlmfs.c
@@ -42,7 +42,6 @@
 #include <linux/highmem.h>
 #include <linux/init.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/backing-dev.h>
 #include <asm/uaccess.h>
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 024777abc8e3..d1bd305ef0d7 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -27,7 +27,6 @@
 #include <linux/slab.h>
 #include <linux/highmem.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/crc32.h>
 #include <linux/kthread.h>
 #include <linux/pagemap.h>
diff --git a/fs/ocfs2/inode.c b/fs/ocfs2/inode.c
index bc844bfe607c..c53a6763bbbe 100644
--- a/fs/ocfs2/inode.c
+++ b/fs/ocfs2/inode.c
@@ -28,7 +28,6 @@
 #include <linux/slab.h>
 #include <linux/highmem.h>
 #include <linux/pagemap.h>
-#include <linux/smp_lock.h>
 #include <asm/byteorder.h>
diff --git a/fs/ocfs2/slot_map.c b/fs/ocfs2/slot_map.c
index d921a28329dc..d8b79067dc14 100644
--- a/fs/ocfs2/slot_map.c
+++ b/fs/ocfs2/slot_map.c
@@ -26,7 +26,6 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/highmem.h>
-#include <linux/smp_lock.h>
 #define MLOG_MASK_PREFIX ML_SUPER
 #include <cluster/masklog.h>
diff --git a/fs/ocfs2/vote.c b/fs/ocfs2/vote.c
index 4f82a2f0efef..66a13ee63d4c 100644
--- a/fs/ocfs2/vote.c
+++ b/fs/ocfs2/vote.c
@@ -26,7 +26,6 @@
 #include <linux/types.h>
 #include <linux/slab.h>
 #include <linux/highmem.h>
-#include <linux/smp_lock.h>
 #include <linux/kthread.h>
 #include <cluster/heartbeat.h>
diff --git a/fs/open.c b/fs/open.c
index c989fb4cf7b9..ca9981c4a658 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -7,7 +7,6 @@
 #include <linux/string.h>
 #include <linux/mm.h>
 #include <linux/file.h>
-#include <linux/smp_lock.h>
 #include <linux/quotaops.h>
 #include <linux/fsnotify.h>
 #include <linux/module.h>
diff --git a/fs/partitions/Kconfig b/fs/partitions/Kconfig
index 6e8bb66fe619..01207042048b 100644
--- a/fs/partitions/Kconfig
+++ b/fs/partitions/Kconfig
@@ -236,3 +236,12 @@ config EFI_PARTITION
        help
          Say Y here if you would like to use hard disks under Linux which
          were partitioned using EFI GPT.
+config SYSV68_PARTITION
+        bool "SYSV68 partition table support" if PARTITION_ADVANCED
+        default y if M68K
+        help
+          Say Y here if you would like to be able to read the hard disk
+          partition table format used by Motorola Delta machines (using
+          sysv68).
+          Otherwise, say N.
diff --git a/fs/partitions/Makefile b/fs/partitions/Makefile
index 67e665fdb7fc..03af8eac51da 100644
--- a/fs/partitions/Makefile
+++ b/fs/partitions/Makefile
@@ -17,3 +17,4 @@ obj-$(CONFIG_ULTRIX_PARTITION) += ultrix.o
 obj-$(CONFIG_IBM_PARTITION) += ibm.o
 obj-$(CONFIG_EFI_PARTITION) += efi.o
 obj-$(CONFIG_KARMA_PARTITION) += karma.o
+obj-$(CONFIG_SYSV68_PARTITION) += sysv68.o
diff --git a/fs/partitions/check.c b/fs/partitions/check.c
index 6b9dae3f0e6c..9a3a058f3553 100644
--- a/fs/partitions/check.c
+++ b/fs/partitions/check.c
@@ -34,6 +34,7 @@
 #include "ultrix.h"
 #include "efi.h"
 #include "karma.h"
+#include "sysv68.h"
 #ifdef CONFIG_BLK_DEV_MD
 extern void md_autodetect_dev(dev_t dev);
@@ -105,6 +106,9 @@ static int (*check_part[])(struct parsed_partitions *, struct block_device *) =
 #ifdef CONFIG_KARMA_PARTITION
        karma_partition,
 #endif
+#ifdef CONFIG_SYSV68_PARTITION
+        sysv68_partition,
+#endif
        NULL
 };
 
diff --git a/fs/partitions/sysv68.c b/fs/partitions/sysv68.c
new file mode 100644
index 000000000000..4eba27b78643
--- /dev/null
+++ b/fs/partitions/sysv68.c
@@ -0,0 +1,92 @@
+/*
+ *  fs/partitions/sysv68.c
+ *
+ *  Copyright (C) 2007 Philippe De Muyter <phdm@macqel.be>
+ */
+#include "check.h"
+#include "sysv68.h"
+/*
+ *      Volume ID structure: on first 256-bytes sector of disk
+ */
+struct volumeid {
+        u8      vid_unused[248];
+        u8      vid_mac[8];     /* ASCII string "MOTOROLA" */
+};
+/*
+ *      config block: second 256-bytes sector on disk
+ */
+struct dkconfig {
+        u8      ios_unused0[128];
+        __be32  ios_slcblk;     /* Slice table block number */
+        __be16  ios_slccnt;     /* Number of entries in slice table */
+        u8      ios_unused1[122];
+};
+/*
+ *      combined volumeid and dkconfig block
+ */
+struct dkblk0 {
+        struct volumeid dk_vid;
+        struct dkconfig dk_ios;
+};
+/*
+ *      Slice Table Structure
+ */
+struct slice {
+        __be32  nblocks;                /* slice size (in blocks) */
+        __be32  blkoff;                 /* block offset of slice */
+};
+int sysv68_partition(struct parsed_partitions *state, struct block_device *bdev)
+{
+        int i, slices;
+        int slot = 1;
+        Sector sect;
+        unsigned char *data;
+        struct dkblk0 *b;
+        struct slice *slice;
+        data = read_dev_sector(bdev, 0, &sect);
+        if (!data)
+                return -1;
+        b = (struct dkblk0 *)data;
+        if (memcmp(b->dk_vid.vid_mac, "MOTOROLA", sizeof(b->dk_vid.vid_mac))) {
+                put_dev_sector(sect);
+                return 0;
+        }
+        slices = be16_to_cpu(b->dk_ios.ios_slccnt);
+        i = be32_to_cpu(b->dk_ios.ios_slcblk);
+        put_dev_sector(sect);
+        data = read_dev_sector(bdev, i, &sect);
+        if (!data)
+                return -1;
+        slices -= 1; /* last slice is the whole disk */
+        printk("sysV68: %s(s%u)", state->name, slices);
+        slice = (struct slice *)data;
+        for (i = 0; i < slices; i++, slice++) {
+                if (slot == state->limit)
+                        break;
+                if (be32_to_cpu(slice->nblocks)) {
+                        put_partition(state, slot,
+                                be32_to_cpu(slice->blkoff),
+                                be32_to_cpu(slice->nblocks));
+                        printk("(s%u)", i);
+                }
+                slot++;
+        }
+        printk("\n");
+        put_dev_sector(sect);
+        return 1;
+}
diff --git a/fs/partitions/sysv68.h b/fs/partitions/sysv68.h
new file mode 100644
index 000000000000..fa733f68431b
--- /dev/null
+++ b/fs/partitions/sysv68.h
@@ -0,0 +1 @@
+extern int sysv68_partition(struct parsed_partitions *state, struct block_device *bdev);
diff --git a/fs/pipe.c b/fs/pipe.c
index ebafde7d6aba..3a89592bdf57 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -841,8 +841,18 @@ static int pipefs_delete_dentry(struct dentry *dentry)
        return 0;
 }
+/*
+ * pipefs_dname() is called from d_path().
+ */
+static char *pipefs_dname(struct dentry *dentry, char *buffer, int buflen)
+{
+        return dynamic_dname(dentry, buffer, buflen, "pipe:[%lu]",
+                                dentry->d_inode->i_ino);
+}
 static struct dentry_operations pipefs_dentry_operations = {
        .d_delete       = pipefs_delete_dentry,
+        .d_dname        = pipefs_dname,
 };
 static struct inode * get_pipe_inode(void)
@@ -888,8 +898,7 @@ struct file *create_write_pipe(void)
        struct inode *inode;
        struct file *f;
        struct dentry *dentry;
-        char name[32];
+        struct qstr name = { .name = "" };
-        struct qstr this;
        f = get_empty_filp();
        if (!f)
@@ -899,11 +908,8 @@ struct file *create_write_pipe(void)
        if (!inode)
                goto err_file;
-        this.len = sprintf(name, "[%lu]", inode->i_ino);
-        this.name = name;
-        this.hash = 0;
        err = -ENOMEM;
-        dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &this);
+        dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &name);
        if (!dentry)
                goto err_inode;
diff --git a/fs/pnode.c b/fs/pnode.c
index 56aacead8362..89940f243fc2 100644
--- a/fs/pnode.c
+++ b/fs/pnode.c
@@ -59,7 +59,7 @@ static int do_make_slave(struct vfsmount *mnt)
        } else {
                struct list_head *p = &mnt->mnt_slave_list;
                while (!list_empty(p)) {
-                        slave_mnt = list_entry(p->next,
+                        slave_mnt = list_first_entry(p,
                                        struct vfsmount, mnt_slave);
                        list_del_init(&slave_mnt->mnt_slave);
                        slave_mnt->mnt_master = NULL;
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 07c9cdbcdcac..74f30e0c0381 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -410,9 +410,9 @@ 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 %lu %lu \
+        res = sprintf(buffer,"%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 %lu %lu %llu\n",
+%lu %lu %lu %lu %lu %lu %lu %lu %d %d %u %u %llu\n",
                task->pid,
                tcomm,
                state,
diff --git a/fs/proc/base.c b/fs/proc/base.c
index ec158dd02b3a..3c41149dea88 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -61,9 +61,9 @@
 #include <linux/namei.h>
 #include <linux/mnt_namespace.h>
 #include <linux/mm.h>
-#include <linux/smp_lock.h>
 #include <linux/rcupdate.h>
 #include <linux/kallsyms.h>
+#include <linux/module.h>
 #include <linux/mount.h>
 #include <linux/security.h>
 #include <linux/ptrace.h>
@@ -90,8 +90,8 @@
 #define PROC_NUMBUF 13
 struct pid_entry {
-        int len;
        char *name;
+        int len;
        mode_t mode;
        const struct inode_operations *iop;
        const struct file_operations *fop;
@@ -99,8 +99,8 @@ struct pid_entry {
 };
 #define NOD(NAME, MODE, IOP, FOP, OP) {                 \
-        .len  = sizeof(NAME) - 1,                       \
        .name = (NAME),                                 \
+        .len  = sizeof(NAME) - 1,                       \
        .mode = MODE,                                   \
        .iop  = IOP,                                    \
        .fop  = FOP,                                    \
@@ -123,6 +123,9 @@ struct pid_entry {
                NULL, &proc_info_file_operations,       \
                { .proc_read = &proc_##OTYPE } )
+int maps_protect;
+EXPORT_SYMBOL(maps_protect);
 static struct fs_struct *get_fs_struct(struct task_struct *task)
 {
        struct fs_struct *fs;
@@ -275,17 +278,15 @@ static int proc_pid_auxv(struct task_struct *task, char *buffer)
 */
 static int proc_pid_wchan(struct task_struct *task, char *buffer)
 {
-        char *modname;
+        unsigned long wchan;
-        const char *sym_name;
+        char symname[KSYM_NAME_LEN+1];
-        unsigned long wchan, size, offset;
-        char namebuf[KSYM_NAME_LEN+1];
        wchan = get_wchan(task);
-        sym_name = kallsyms_lookup(wchan, &size, &offset, &modname, namebuf);
+        if (lookup_symbol_name(wchan, symname) < 0)
-        if (sym_name)
+                return sprintf(buffer, "%lu", wchan);
-                return sprintf(buffer, "%s", sym_name);
+        else
-        return sprintf(buffer, "%lu", wchan);
+                return sprintf(buffer, "%s", symname);
 }
 #endif /* CONFIG_KALLSYMS */
@@ -310,7 +311,9 @@ static int proc_oom_score(struct task_struct *task, char *buffer)
        struct timespec uptime;
        do_posix_clock_monotonic_gettime(&uptime);
+        read_lock(&tasklist_lock);
        points = badness(task, uptime.tv_sec);
+        read_unlock(&tasklist_lock);
        return sprintf(buffer, "%lu\n", points);
 }
@@ -344,11 +347,8 @@ static int proc_setattr(struct dentry *dentry, struct iattr *attr)
                return -EPERM;
        error = inode_change_ok(inode, attr);
-        if (!error) {
+        if (!error)
-                error = security_inode_setattr(dentry, attr);
+                error = inode_setattr(inode, attr);
-                if (!error)
-                        error = inode_setattr(inode, attr);
-        }
        return error;
 }
@@ -660,7 +660,6 @@ static ssize_t oom_adjust_read(struct file *file, char __user *buf,
        char buffer[PROC_NUMBUF];
        size_t len;
        int oom_adjust;
-        loff_t __ppos = *ppos;
        if (!task)
                return -ESRCH;
@@ -668,14 +667,8 @@ static ssize_t oom_adjust_read(struct file *file, char __user *buf,
        put_task_struct(task);
        len = snprintf(buffer, sizeof(buffer), "%i\n", oom_adjust);
-        if (__ppos >= len)
-                return 0;
+        return simple_read_from_buffer(buf, count, ppos, buffer, len);
-        if (count > len-__ppos)
-                count = len-__ppos;
-        if (copy_to_user(buf, buffer + __ppos, count))
-                return -EFAULT;
-        *ppos = __ppos + count;
-        return count;
 }
 static ssize_t oom_adjust_write(struct file *file, const char __user *buf,
@@ -823,7 +816,6 @@ static ssize_t seccomp_read(struct file *file, char __user *buf,
 {
        struct task_struct *tsk = get_proc_task(file->f_dentry->d_inode);
        char __buf[20];
-        loff_t __ppos = *ppos;
        size_t len;
        if (!tsk)
@@ -831,14 +823,8 @@ static ssize_t seccomp_read(struct file *file, char __user *buf,
        /* no need to print the trailing zero, so use only len */
        len = sprintf(__buf, "%u\n", tsk->seccomp.mode);
        put_task_struct(tsk);
-        if (__ppos >= len)
-                return 0;
+        return simple_read_from_buffer(buf, count, ppos, __buf, len);
-        if (count > len - __ppos)
-                count = len - __ppos;
-        if (copy_to_user(buf, __buf + __ppos, count))
-                return -EFAULT;
-        *ppos = __ppos + count;
-        return count;
 }
 static ssize_t seccomp_write(struct file *file, const char __user *buf,
@@ -897,7 +883,6 @@ static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
        char buffer[PROC_NUMBUF];
        size_t len;
        int make_it_fail;
-        loff_t __ppos = *ppos;
        if (!task)
                return -ESRCH;
@@ -905,14 +890,8 @@ static ssize_t proc_fault_inject_read(struct file * file, char __user * buf,
        put_task_struct(task);
        len = snprintf(buffer, sizeof(buffer), "%i\n", make_it_fail);
-        if (__ppos >= len)
-                return 0;
+        return simple_read_from_buffer(buf, count, ppos, buffer, len);
-        if (count > len-__ppos)
-                count = len-__ppos;
-        if (copy_to_user(buf, buffer + __ppos, count))
-                return -EFAULT;
-        *ppos = __ppos + count;
-        return count;
 }
 static ssize_t proc_fault_inject_write(struct file * file,
@@ -975,7 +954,7 @@ static int do_proc_readlink(struct dentry *dentry, struct vfsmount *mnt,
        if (!tmp)
                return -ENOMEM;
-                
        inode = dentry->d_inode;
        path = d_path(dentry, mnt, tmp, PAGE_SIZE);
        len = PTR_ERR(path);
@@ -1155,7 +1134,8 @@ static struct dentry_operations pid_dentry_operations =
 /* Lookups */
-typedef struct dentry *instantiate_t(struct inode *, struct dentry *, struct task_struct *, void *);
+typedef struct dentry *instantiate_t(struct inode *, struct dentry *,
+                                struct task_struct *, const void *);
 /*
 * Fill a directory entry.
@@ -1171,7 +1151,7 @@ typedef struct dentry *instantiate_t(struct inode *, struct dentry *, struct tas
 */
 static int proc_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
        char *name, int len,
-        instantiate_t instantiate, struct task_struct *task, void *ptr)
+        instantiate_t instantiate, struct task_struct *task, const void *ptr)
 {
        struct dentry *child, *dir = filp->f_path.dentry;
        struct inode *inode;
@@ -1233,7 +1213,10 @@ out:
        return ~0U;
 }
-static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsmount **mnt)
+#define PROC_FDINFO_MAX 64
+static int proc_fd_info(struct inode *inode, struct dentry **dentry,
+                        struct vfsmount **mnt, char *info)
 {
        struct task_struct *task = get_proc_task(inode);
        struct files_struct *files = NULL;
@@ -1252,8 +1235,16 @@ static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsm
                spin_lock(&files->file_lock);
                file = fcheck_files(files, fd);
                if (file) {
-                        *mnt = mntget(file->f_path.mnt);
+                        if (mnt)
-                        *dentry = dget(file->f_path.dentry);
+                                *mnt = mntget(file->f_path.mnt);
+                        if (dentry)
+                                *dentry = dget(file->f_path.dentry);
+                        if (info)
+                                snprintf(info, PROC_FDINFO_MAX,
+                                         "pos:\t%lli\n"
+                                         "flags:\t0%o\n",
+                                         (long long) file->f_pos,
+                                         file->f_flags);
                        spin_unlock(&files->file_lock);
                        put_files_struct(files);
                        return 0;
@@ -1264,6 +1255,12 @@ static int proc_fd_link(struct inode *inode, struct dentry **dentry, struct vfsm
        return -ENOENT;
 }
+static int proc_fd_link(struct inode *inode, struct dentry **dentry,
+                        struct vfsmount **mnt)
+{
+        return proc_fd_info(inode, dentry, mnt, NULL);
+}
 static int tid_fd_revalidate(struct dentry *dentry, struct nameidata *nd)
 {
        struct inode *inode = dentry->d_inode;
@@ -1306,9 +1303,9 @@ static struct dentry_operations tid_fd_dentry_operations =
 };
 static struct dentry *proc_fd_instantiate(struct inode *dir,
-        struct dentry *dentry, struct task_struct *task, void *ptr)
+        struct dentry *dentry, struct task_struct *task, const void *ptr)
 {
-        unsigned fd = *(unsigned *)ptr;
+        unsigned fd = *(const unsigned *)ptr;
        struct file *file;
        struct files_struct *files;
        struct inode *inode;
@@ -1359,7 +1356,9 @@ out_iput:
        goto out;
 }
-static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry, struct nameidata *nd)
+static struct dentry *proc_lookupfd_common(struct inode *dir,
+                                           struct dentry *dentry,
+                                           instantiate_t instantiate)
 {
        struct task_struct *task = get_proc_task(dir);
        unsigned fd = name_to_int(dentry);
@@ -1370,23 +1369,15 @@ static struct dentry *proc_lookupfd(struct inode * dir, struct dentry * dentry,
        if (fd == ~0U)
                goto out;
-        result = proc_fd_instantiate(dir, dentry, task, &fd);
+        result = instantiate(dir, dentry, task, &fd);
 out:
        put_task_struct(task);
 out_no_task:
        return result;
 }
-static int proc_fd_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
+static int proc_readfd_common(struct file * filp, void * dirent,
-        struct task_struct *task, int fd)
+                              filldir_t filldir, instantiate_t instantiate)
-{
-        char name[PROC_NUMBUF];
-        int len = snprintf(name, sizeof(name), "%d", fd);
-        return proc_fill_cache(filp, dirent, filldir, name, len,
-                                proc_fd_instantiate, task, &fd);
-}
-static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
 {
        struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
@@ -1422,12 +1413,17 @@ static int proc_readfd(struct file * filp, void * dirent, filldir_t filldir)
                        for (fd = filp->f_pos-2;
                             fd < fdt->max_fds;
                             fd++, filp->f_pos++) {
+                                char name[PROC_NUMBUF];
+                                int len;
                                if (!fcheck_files(files, fd))
                                        continue;
                                rcu_read_unlock();
-                                if (proc_fd_fill_cache(filp, dirent, filldir, p, fd) < 0) {
+                                len = snprintf(name, sizeof(name), "%d", fd);
+                                if (proc_fill_cache(filp, dirent, filldir,
+                                                    name, len, instantiate,
+                                                    p, &fd) < 0) {
                                        rcu_read_lock();
                                        break;
                                }
@@ -1442,23 +1438,119 @@ out_no_task:
        return retval;
 }
+static struct dentry *proc_lookupfd(struct inode *dir, struct dentry *dentry,
+                                    struct nameidata *nd)
+{
+        return proc_lookupfd_common(dir, dentry, proc_fd_instantiate);
+}
+static int proc_readfd(struct file *filp, void *dirent, filldir_t filldir)
+{
+        return proc_readfd_common(filp, dirent, filldir, proc_fd_instantiate);
+}
+static ssize_t proc_fdinfo_read(struct file *file, char __user *buf,
+                                      size_t len, loff_t *ppos)
+{
+        char tmp[PROC_FDINFO_MAX];
+        int err = proc_fd_info(file->f_path.dentry->d_inode, NULL, NULL, tmp);
+        if (!err)
+                err = simple_read_from_buffer(buf, len, ppos, tmp, strlen(tmp));
+        return err;
+}
+static const struct file_operations proc_fdinfo_file_operations = {
+        .open           = nonseekable_open,
+        .read           = proc_fdinfo_read,
+};
 static const struct file_operations proc_fd_operations = {
        .read           = generic_read_dir,
        .readdir        = proc_readfd,
 };
 /*
+ * /proc/pid/fd needs a special permission handler so that a process can still
+ * access /proc/self/fd after it has executed a setuid().
+ */
+static int proc_fd_permission(struct inode *inode, int mask,
+                                struct nameidata *nd)
+{
+        int rv;
+        rv = generic_permission(inode, mask, NULL);
+        if (rv == 0)
+                return 0;
+        if (task_pid(current) == proc_pid(inode))
+                rv = 0;
+        return rv;
+}
+/*
 * proc directories can do almost nothing..
 */
 static const struct inode_operations proc_fd_inode_operations = {
        .lookup         = proc_lookupfd,
+        .permission     = proc_fd_permission,
        .setattr        = proc_setattr,
 };
+static struct dentry *proc_fdinfo_instantiate(struct inode *dir,
+        struct dentry *dentry, struct task_struct *task, const void *ptr)
+{
+        unsigned fd = *(unsigned *)ptr;
+        struct inode *inode;
+        struct proc_inode *ei;
+        struct dentry *error = ERR_PTR(-ENOENT);
+        inode = proc_pid_make_inode(dir->i_sb, task);
+        if (!inode)
+                goto out;
+        ei = PROC_I(inode);
+        ei->fd = fd;
+        inode->i_mode = S_IFREG | S_IRUSR;
+        inode->i_fop = &proc_fdinfo_file_operations;
+        dentry->d_op = &tid_fd_dentry_operations;
+        d_add(dentry, inode);
+        /* Close the race of the process dying before we return the dentry */
+        if (tid_fd_revalidate(dentry, NULL))
+                error = NULL;
+ out:
+        return error;
+}
+static struct dentry *proc_lookupfdinfo(struct inode *dir,
+                                        struct dentry *dentry,
+                                        struct nameidata *nd)
+{
+        return proc_lookupfd_common(dir, dentry, proc_fdinfo_instantiate);
+}
+static int proc_readfdinfo(struct file *filp, void *dirent, filldir_t filldir)
+{
+        return proc_readfd_common(filp, dirent, filldir,
+                                  proc_fdinfo_instantiate);
+}
+static const struct file_operations proc_fdinfo_operations = {
+        .read           = generic_read_dir,
+        .readdir        = proc_readfdinfo,
+};
+/*
+ * proc directories can do almost nothing..
+ */
+static const struct inode_operations proc_fdinfo_inode_operations = {
+        .lookup         = proc_lookupfdinfo,
+        .setattr        = proc_setattr,
+};
 static struct dentry *proc_pident_instantiate(struct inode *dir,
-        struct dentry *dentry, struct task_struct *task, void *ptr)
+        struct dentry *dentry, struct task_struct *task, const void *ptr)
 {
-        struct pid_entry *p = ptr;
+        const struct pid_entry *p = ptr;
        struct inode *inode;
        struct proc_inode *ei;
        struct dentry *error = ERR_PTR(-EINVAL);
@@ -1487,13 +1579,13 @@ out:
 static struct dentry *proc_pident_lookup(struct inode *dir, 
                                         struct dentry *dentry,
-                                         struct pid_entry *ents,
+                                         const struct pid_entry *ents,
                                         unsigned int nents)
 {
        struct inode *inode;
        struct dentry *error;
        struct task_struct *task = get_proc_task(dir);
-        struct pid_entry *p, *last;
+        const struct pid_entry *p, *last;
        error = ERR_PTR(-ENOENT);
        inode = NULL;
@@ -1522,8 +1614,8 @@ out_no_task:
        return error;
 }
-static int proc_pident_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
+static int proc_pident_fill_cache(struct file *filp, void *dirent,
-        struct task_struct *task, struct pid_entry *p)
+        filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
 {
        return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
                                proc_pident_instantiate, task, p);
@@ -1531,14 +1623,14 @@ static int proc_pident_fill_cache(struct file *filp, void *dirent, filldir_t fil
 static int proc_pident_readdir(struct file *filp,
                void *dirent, filldir_t filldir,
-                struct pid_entry *ents, unsigned int nents)
+                const struct pid_entry *ents, unsigned int nents)
 {
        int i;
        int pid;
        struct dentry *dentry = filp->f_path.dentry;
        struct inode *inode = dentry->d_inode;
        struct task_struct *task = get_proc_task(inode);
-        struct pid_entry *p, *last;
+        const struct pid_entry *p, *last;
        ino_t ino;
        int ret;
@@ -1653,7 +1745,7 @@ static const struct file_operations proc_pid_attr_operations = {
        .write          = proc_pid_attr_write,
 };
-static struct pid_entry attr_dir_stuff[] = {
+static const struct pid_entry attr_dir_stuff[] = {
        REG("current",    S_IRUGO|S_IWUGO, pid_attr),
        REG("prev",       S_IRUGO,         pid_attr),
        REG("exec",       S_IRUGO|S_IWUGO, pid_attr),
@@ -1719,7 +1811,7 @@ static const struct inode_operations proc_self_inode_operations = {
 * that properly belong to the /proc filesystem, as they describe
 * describe something that is process related.
 */
-static struct pid_entry proc_base_stuff[] = {
+static const struct pid_entry proc_base_stuff[] = {
        NOD("self", S_IFLNK|S_IRWXUGO,
                &proc_self_inode_operations, NULL, {}),
 };
@@ -1748,9 +1840,9 @@ static struct dentry_operations proc_base_dentry_operations =
 };
 static struct dentry *proc_base_instantiate(struct inode *dir,
-        struct dentry *dentry, struct task_struct *task, void *ptr)
+        struct dentry *dentry, struct task_struct *task, const void *ptr)
 {
-        struct pid_entry *p = ptr;
+        const struct pid_entry *p = ptr;
        struct inode *inode;
        struct proc_inode *ei;
        struct dentry *error = ERR_PTR(-EINVAL);
@@ -1798,7 +1890,7 @@ static struct dentry *proc_base_lookup(struct inode *dir, struct dentry *dentry)
 {
        struct dentry *error;
        struct task_struct *task = get_proc_task(dir);
-        struct pid_entry *p, *last;
+        const struct pid_entry *p, *last;
        error = ERR_PTR(-ENOENT);
@@ -1824,8 +1916,8 @@ out_no_task:
        return error;
 }
-static int proc_base_fill_cache(struct file *filp, void *dirent, filldir_t filldir,
+static int proc_base_fill_cache(struct file *filp, void *dirent,
-        struct task_struct *task, struct pid_entry *p)
+        filldir_t filldir, struct task_struct *task, const struct pid_entry *p)
 {
        return proc_fill_cache(filp, dirent, filldir, p->name, p->len,
                                proc_base_instantiate, task, p);
@@ -1862,9 +1954,10 @@ static int proc_pid_io_accounting(struct task_struct *task, char *buffer)
 static const struct file_operations proc_task_operations;
 static const struct inode_operations proc_task_inode_operations;
-static struct pid_entry tgid_base_stuff[] = {
+static const struct pid_entry tgid_base_stuff[] = {
        DIR("task",       S_IRUGO|S_IXUGO, task),
        DIR("fd",         S_IRUSR|S_IXUSR, fd),
+        DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
        INF("environ",    S_IRUSR, pid_environ),
        INF("auxv",       S_IRUSR, pid_auxv),
        INF("status",     S_IRUGO, pid_status),
@@ -2005,7 +2098,7 @@ out:
 static struct dentry *proc_pid_instantiate(struct inode *dir,
                                           struct dentry * dentry,
-                                           struct task_struct *task, void *ptr)
+                                           struct task_struct *task, const void *ptr)
 {
        struct dentry *error = ERR_PTR(-ENOENT);
        struct inode *inode;
@@ -2018,7 +2111,7 @@ static struct dentry *proc_pid_instantiate(struct inode *dir,
        inode->i_op = &proc_tgid_base_inode_operations;
        inode->i_fop = &proc_tgid_base_operations;
        inode->i_flags|=S_IMMUTABLE;
-        inode->i_nlink = 4;
+        inode->i_nlink = 5;
 #ifdef CONFIG_SECURITY
        inode->i_nlink += 1;
 #endif
@@ -2120,7 +2213,7 @@ int proc_pid_readdir(struct file * filp, void * dirent, filldir_t filldir)
                goto out_no_task;
        for (; nr < ARRAY_SIZE(proc_base_stuff); filp->f_pos++, nr++) {
-                struct pid_entry *p = &proc_base_stuff[nr];
+                const struct pid_entry *p = &proc_base_stuff[nr];
                if (proc_base_fill_cache(filp, dirent, filldir, reaper, p) < 0)
                        goto out;
        }
@@ -2146,8 +2239,9 @@ out_no_task:
 /*
 * Tasks
 */
-static struct pid_entry tid_base_stuff[] = {
+static const struct pid_entry tid_base_stuff[] = {
        DIR("fd",        S_IRUSR|S_IXUSR, fd),
+        DIR("fdinfo",    S_IRUSR|S_IXUSR, fdinfo),
        INF("environ",   S_IRUSR, pid_environ),
        INF("auxv",      S_IRUSR, pid_auxv),
        INF("status",    S_IRUGO, pid_status),
@@ -2216,7 +2310,7 @@ static const struct inode_operations proc_tid_base_inode_operations = {
 };
 static struct dentry *proc_task_instantiate(struct inode *dir,
-        struct dentry *dentry, struct task_struct *task, void *ptr)
+        struct dentry *dentry, struct task_struct *task, const void *ptr)
 {
        struct dentry *error = ERR_PTR(-ENOENT);
        struct inode *inode;
@@ -2228,7 +2322,7 @@ static struct dentry *proc_task_instantiate(struct inode *dir,
        inode->i_op = &proc_tid_base_inode_operations;
        inode->i_fop = &proc_tid_base_operations;
        inode->i_flags|=S_IMMUTABLE;
-        inode->i_nlink = 3;
+        inode->i_nlink = 4;
 #ifdef CONFIG_SECURITY
        inode->i_nlink += 1;
 #endif
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 775fb21294d8..8a40e15f5ecb 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -398,6 +398,7 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
                        if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
                                unsigned int ino = de->low_ino;
+                                de_get(de);
                                spin_unlock(&proc_subdir_lock);
                                error = -EINVAL;
                                inode = proc_get_inode(dir->i_sb, ino, de);
@@ -414,6 +415,7 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
                d_add(dentry, inode);
                return NULL;
        }
+        de_put(de);
        return ERR_PTR(error);
 }
@@ -476,14 +478,21 @@ int proc_readdir(struct file * filp,
                        }
                        do {
+                                struct proc_dir_entry *next;
                                /* filldir passes info to user space */
+                                de_get(de);
                                spin_unlock(&proc_subdir_lock);
                                if (filldir(dirent, de->name, de->namelen, filp->f_pos,
-                                            de->low_ino, de->mode >> 12) < 0)
+                                            de->low_ino, de->mode >> 12) < 0) {
+                                        de_put(de);
                                        goto out;
+                                }
                                spin_lock(&proc_subdir_lock);
                                filp->f_pos++;
-                                de = de->next;
+                                next = de->next;
+                                de_put(de);
+                                de = next;
                        } while (de);
                        spin_unlock(&proc_subdir_lock);
        }
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 22b1158389ae..b8171907c83b 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -21,7 +21,7 @@
 #include "internal.h"
-static inline struct proc_dir_entry * de_get(struct proc_dir_entry *de)
+struct proc_dir_entry *de_get(struct proc_dir_entry *de)
 {
        if (de)
                atomic_inc(&de->count);
@@ -31,7 +31,7 @@ static inline struct proc_dir_entry * de_get(struct proc_dir_entry *de)
 /*
 * Decrements the use count and checks for deferred deletion.
 */
-static void de_put(struct proc_dir_entry *de)
+void de_put(struct proc_dir_entry *de)
 {
        if (de) {       
                lock_kernel();          
@@ -146,13 +146,6 @@ struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
 {
        struct inode * inode;
-        /*
-         * Increment the use count so the dir entry can't disappear.
-         */
-        de_get(de);
-        WARN_ON(de && de->deleted);
        if (de != NULL && !try_module_get(de->owner))
                goto out_mod;
@@ -184,7 +177,6 @@ out_ino:
        if (de != NULL)
                module_put(de->owner);
 out_mod:
-        de_put(de);
        return NULL;
 }                       
@@ -199,6 +191,7 @@ int proc_fill_super(struct super_block *s, void *data, int silent)
        s->s_op = &proc_sops;
        s->s_time_gran = 1;
        
+        de_get(&proc_root);
        root_inode = proc_get_inode(s, PROC_ROOT_INO, &proc_root);
        if (!root_inode)
                goto out_no_root;
@@ -212,6 +205,7 @@ int proc_fill_super(struct super_block *s, void *data, int silent)
 out_no_root:
        printk("proc_read_super: get root inode failed\n");
        iput(root_inode);
+        de_put(&proc_root);
        return -ENOMEM;
 }
 MODULE_LICENSE("GPL");
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index f771889183c3..b215c3524fa6 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -37,6 +37,8 @@ do {						\
 extern int nommu_vma_show(struct seq_file *, struct vm_area_struct *);
 #endif
+extern int maps_protect;
 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 *);
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 75ec6523d29a..5fd49e47f83a 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -35,7 +35,6 @@
 #include <linux/signal.h>
 #include <linux/module.h>
 #include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/seq_file.h>
 #include <linux/times.h>
 #include <linux/profile.h>
@@ -429,18 +428,11 @@ static int slabstats_open(struct inode *inode, struct file *file)
        return ret;
 }
-static int slabstats_release(struct inode *inode, struct file *file)
-{
-        struct seq_file *m = file->private_data;
-        kfree(m->private);
-        return seq_release(inode, file);
-}
 static const struct file_operations proc_slabstats_operations = {
        .open           = slabstats_open,
        .read           = seq_read,
        .llseek         = seq_lseek,
-        .release        = slabstats_release,
+        .release        = seq_release_private,
 };
 #endif
 #endif
diff --git a/fs/proc/proc_sysctl.c b/fs/proc/proc_sysctl.c
index 20e8cbb34364..680c429bfa22 100644
--- a/fs/proc/proc_sysctl.c
+++ b/fs/proc/proc_sysctl.c
@@ -429,11 +429,8 @@ static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
                return -EPERM;
        error = inode_change_ok(inode, attr);
-        if (!error) {
+        if (!error)
-                error = security_inode_setattr(dentry, attr);
+                error = inode_setattr(inode, attr);
-                if (!error)
-                        error = inode_setattr(inode, attr);
-        }
        return error;
 }
diff --git a/fs/proc/proc_tty.c b/fs/proc/proc_tty.c
index c1bbfbeb035e..b3a473b0a191 100644
--- a/fs/proc/proc_tty.c
+++ b/fs/proc/proc_tty.c
@@ -108,6 +108,8 @@ static void *t_start(struct seq_file *m, loff_t *pos)
 {
        struct list_head *p;
        loff_t l = *pos;
+        mutex_lock(&tty_mutex);
        list_for_each(p, &tty_drivers)
                if (!l--)
                        return list_entry(p, struct tty_driver, tty_drivers);
@@ -124,6 +126,7 @@ static void *t_next(struct seq_file *m, void *v, loff_t *pos)
 static void t_stop(struct seq_file *m, void *v)
 {
+        mutex_unlock(&tty_mutex);
 }
 static struct seq_operations tty_drivers_op = {
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 4008c060f7ef..c24d81a5a040 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -3,6 +3,7 @@
 #include <linux/mount.h>
 #include <linux/seq_file.h>
 #include <linux/highmem.h>
+#include <linux/ptrace.h>
 #include <linux/pagemap.h>
 #include <linux/mempolicy.h>
@@ -142,6 +143,9 @@ static int show_map_internal(struct seq_file *m, void *v, struct mem_size_stats
        dev_t dev = 0;
        int len;
+        if (maps_protect && !ptrace_may_attach(task))
+                return -EACCES;
        if (file) {
                struct inode *inode = vma->vm_file->f_path.dentry->d_inode;
                dev = inode->i_sb->s_dev;
@@ -512,11 +516,22 @@ const struct file_operations proc_maps_operations = {
 #ifdef CONFIG_NUMA
 extern int show_numa_map(struct seq_file *m, void *v);
+static int show_numa_map_checked(struct seq_file *m, void *v)
+{
+        struct proc_maps_private *priv = m->private;
+        struct task_struct *task = priv->task;
+        if (maps_protect && !ptrace_may_attach(task))
+                return -EACCES;
+        return show_numa_map(m, v);
+}
 static struct seq_operations proc_pid_numa_maps_op = {
        .start  = m_start,
        .next   = m_next,
        .stop   = m_stop,
-        .show   = show_numa_map
+        .show   = show_numa_map_checked
 };
 static int numa_maps_open(struct inode *inode, struct file *file)
diff --git a/fs/proc/task_nommu.c b/fs/proc/task_nommu.c
index 7cddf6b8635a..d8b8c7183c24 100644
--- a/fs/proc/task_nommu.c
+++ b/fs/proc/task_nommu.c
@@ -2,6 +2,7 @@
 #include <linux/mm.h>
 #include <linux/file.h>
 #include <linux/mount.h>
+#include <linux/ptrace.h>
 #include <linux/seq_file.h>
 #include "internal.h"
@@ -143,6 +144,12 @@ out:
 static int show_map(struct seq_file *m, void *_vml)
 {
        struct vm_list_struct *vml = _vml;
+        struct proc_maps_private *priv = m->private;
+        struct task_struct *task = priv->task;
+        if (maps_protect && !ptrace_may_attach(task))
+                return -EACCES;
        return nommu_vma_show(m, vml->vma);
 }
diff --git a/fs/quota.c b/fs/quota.c
index b9dae76a0b6e..e9d88fd0eca8 100644
--- a/fs/quota.c
+++ b/fs/quota.c
@@ -11,7 +11,6 @@
 #include <asm/current.h>
 #include <asm/uaccess.h>
 #include <linux/kernel.h>
-#include <linux/smp_lock.h>
 #include <linux/security.h>
 #include <linux/syscalls.h>
 #include <linux/buffer_head.h>
diff --git a/fs/ramfs/file-nommu.c b/fs/ramfs/file-nommu.c
index d3fd7c6732d2..3b481d557edb 100644
--- a/fs/ramfs/file-nommu.c
+++ b/fs/ramfs/file-nommu.c
@@ -16,7 +16,6 @@
 #include <linux/highmem.h>
 #include <linux/init.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/backing-dev.h>
 #include <linux/ramfs.h>
 #include <linux/quotaops.h>
diff --git a/fs/ramfs/inode.c b/fs/ramfs/inode.c
index ff1f7639707b..4ace5d72eae1 100644
--- a/fs/ramfs/inode.c
+++ b/fs/ramfs/inode.c
@@ -30,7 +30,6 @@
 #include <linux/time.h>
 #include <linux/init.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/backing-dev.h>
 #include <linux/ramfs.h>
diff --git a/fs/read_write.c b/fs/read_write.c
index 1f8dc373ede7..4d03008f015b 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -37,10 +37,10 @@ loff_t generic_file_llseek(struct file *file, loff_t offset, int origin)
        mutex_lock(&inode->i_mutex);
        switch (origin) {
-                case 2:
+                case SEEK_END:
                        offset += inode->i_size;
                        break;
-                case 1:
+                case SEEK_CUR:
                        offset += file->f_pos;
        }
        retval = -EINVAL;
@@ -63,10 +63,10 @@ loff_t remote_llseek(struct file *file, loff_t offset, int origin)
        lock_kernel();
        switch (origin) {
-                case 2:
+                case SEEK_END:
                        offset += i_size_read(file->f_path.dentry->d_inode);
                        break;
-                case 1:
+                case SEEK_CUR:
                        offset += file->f_pos;
        }
        retval = -EINVAL;
@@ -94,10 +94,10 @@ loff_t default_llseek(struct file *file, loff_t offset, int origin)
        lock_kernel();
        switch (origin) {
-                case 2:
+                case SEEK_END:
                        offset += i_size_read(file->f_path.dentry->d_inode);
                        break;
-                case 1:
+                case SEEK_CUR:
                        offset += file->f_pos;
        }
        retval = -EINVAL;
@@ -139,7 +139,7 @@ asmlinkage off_t sys_lseek(unsigned int fd, off_t offset, unsigned int origin)
                goto bad;
        retval = -EINVAL;
-        if (origin <= 2) {
+        if (origin <= SEEK_MAX) {
                loff_t res = vfs_llseek(file, offset, origin);
                retval = res;
                if (res != (loff_t)retval)
@@ -166,7 +166,7 @@ asmlinkage long sys_llseek(unsigned int fd, unsigned long offset_high,
                goto bad;
        retval = -EINVAL;
-        if (origin > 2)
+        if (origin > SEEK_MAX)
                goto out_putf;
        offset = vfs_llseek(file, ((loff_t) offset_high << 32) | offset_low,
diff --git a/fs/readdir.c b/fs/readdir.c
index f39f5b313252..efe52e676577 100644
--- a/fs/readdir.c
+++ b/fs/readdir.c
@@ -4,13 +4,13 @@
 *  Copyright (C) 1995  Linus Torvalds
 */
+#include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/errno.h>
 #include <linux/stat.h>
 #include <linux/file.h>
-#include <linux/smp_lock.h>
 #include <linux/fs.h>
 #include <linux/dirent.h>
 #include <linux/security.h>
@@ -52,7 +52,6 @@ EXPORT_SYMBOL(vfs_readdir);
 * case (the low-level handlers don't need to care about this).
 */
 #define NAME_OFFSET(de) ((int) ((de)->d_name - (char __user *) (de)))
-#define ROUND_UP(x) (((x)+sizeof(long)-1) & ~(sizeof(long)-1))
 #ifdef __ARCH_WANT_OLD_READDIR
@@ -147,7 +146,7 @@ static int filldir(void * __buf, const char * name, int namlen, loff_t offset,
        struct linux_dirent __user * dirent;
        struct getdents_callback * buf = (struct getdents_callback *) __buf;
        unsigned long d_ino;
-        int reclen = ROUND_UP(NAME_OFFSET(dirent) + namlen + 2);
+        int reclen = ALIGN(NAME_OFFSET(dirent) + namlen + 2, sizeof(long));
        buf->error = -EINVAL;   /* only used if we fail.. */
        if (reclen > buf->count)
@@ -220,8 +219,6 @@ out:
        return error;
 }
-#define ROUND_UP64(x) (((x)+sizeof(u64)-1) & ~(sizeof(u64)-1))
 struct getdents_callback64 {
        struct linux_dirent64 __user * current_dir;
        struct linux_dirent64 __user * previous;
@@ -234,7 +231,7 @@ static int filldir64(void * __buf, const char * name, int namlen, loff_t offset,
 {
        struct linux_dirent64 __user *dirent;
        struct getdents_callback64 * buf = (struct getdents_callback64 *) __buf;
-        int reclen = ROUND_UP64(NAME_OFFSET(dirent) + namlen + 1);
+        int reclen = ALIGN(NAME_OFFSET(dirent) + namlen + 1, sizeof(u64));
        buf->error = -EINVAL;   /* only used if we fail.. */
        if (reclen > buf->count)
diff --git a/fs/reiserfs/dir.c b/fs/reiserfs/dir.c
index 96a2f8889da3..9c23fee3bae9 100644
--- a/fs/reiserfs/dir.c
+++ b/fs/reiserfs/dir.c
@@ -7,7 +7,6 @@
 #include <linux/fs.h>
 #include <linux/reiserfs_fs.h>
 #include <linux/stat.h>
-#include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 #include <asm/uaccess.h>
diff --git a/fs/reiserfs/file.c b/fs/reiserfs/file.c
index abfada2f52db..ab45db529c80 100644
--- a/fs/reiserfs/file.c
+++ b/fs/reiserfs/file.c
@@ -6,7 +6,6 @@
 #include <linux/reiserfs_fs.h>
 #include <linux/reiserfs_acl.h>
 #include <linux/reiserfs_xattr.h>
-#include <linux/smp_lock.h>
 #include <asm/uaccess.h>
 #include <linux/pagemap.h>
 #include <linux/swap.h>
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 7280a23ef344..e073fd86cf60 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -2918,7 +2918,7 @@ static void queue_log_writer(struct super_block *s)
        set_current_state(TASK_UNINTERRUPTIBLE);
        if (test_bit(J_WRITERS_QUEUED, &journal->j_state))
                schedule();
-        current->state = TASK_RUNNING;
+        __set_current_state(TASK_RUNNING);
        remove_wait_queue(&journal->j_join_wait, &wait);
 }
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index a2161840bc7c..b378eea332ca 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -16,7 +16,6 @@
 #include <linux/reiserfs_fs.h>
 #include <linux/reiserfs_acl.h>
 #include <linux/reiserfs_xattr.h>
-#include <linux/smp_lock.h>
 #include <linux/quotaops.h>
 #define INC_DIR_INODE_NLINK(i) if (i->i_nlink != 1) { inc_nlink(i); if (i->i_nlink >= REISERFS_LINK_MAX) i->i_nlink=1; }
diff --git a/fs/reiserfs/procfs.c b/fs/reiserfs/procfs.c
index ecc9943202fc..9aa7a06e093f 100644
--- a/fs/reiserfs/procfs.c
+++ b/fs/reiserfs/procfs.c
@@ -16,11 +16,10 @@
 #include <asm/uaccess.h>
 #include <linux/reiserfs_fs.h>
 #include <linux/reiserfs_fs_sb.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/proc_fs.h>
-#if defined( REISERFS_PROC_INFO )
+#ifdef CONFIG_REISERFS_PROC_INFO
 /*
 * LOCKING:
diff --git a/fs/reiserfs/resize.c b/fs/reiserfs/resize.c
index 315684793d1d..976cc7887a0d 100644
--- a/fs/reiserfs/resize.c
+++ b/fs/reiserfs/resize.c
@@ -131,6 +131,10 @@ int reiserfs_resize(struct super_block *s, unsigned long block_count_new)
                        /* don't use read_bitmap_block since it will cache
                         * the uninitialized bitmap */
                        bh = sb_bread(s, i * s->s_blocksize * 8);
+                        if (!bh) {
+                                vfree(bitmap);
+                                return -EIO;
+                        }
                        memset(bh->b_data, 0, sb_blocksize(sb));
                        reiserfs_test_and_set_le_bit(0, bh->b_data);
                        reiserfs_cache_bitmap_metadata(s, bh, bitmap + i);
diff --git a/fs/reiserfs/stree.c b/fs/reiserfs/stree.c
index afb21ea45302..b6f12593c39d 100644
--- a/fs/reiserfs/stree.c
+++ b/fs/reiserfs/stree.c
@@ -53,7 +53,6 @@
 #include <linux/string.h>
 #include <linux/pagemap.h>
 #include <linux/reiserfs_fs.h>
-#include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 #include <linux/quotaops.h>
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 7054aaef0493..c7762140c425 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -18,7 +18,6 @@
 #include <linux/reiserfs_fs.h>
 #include <linux/reiserfs_acl.h>
 #include <linux/reiserfs_xattr.h>
-#include <linux/smp_lock.h>
 #include <linux/init.h>
 #include <linux/blkdev.h>
 #include <linux/buffer_head.h>
@@ -433,12 +432,13 @@ int remove_save_link(struct inode *inode, int truncate)
 static void reiserfs_kill_sb(struct super_block *s)
 {
        if (REISERFS_SB(s)) {
+#ifdef CONFIG_REISERFS_FS_XATTR
                if (REISERFS_SB(s)->xattr_root) {
                        d_invalidate(REISERFS_SB(s)->xattr_root);
                        dput(REISERFS_SB(s)->xattr_root);
                        REISERFS_SB(s)->xattr_root = NULL;
                }
+#endif
                if (REISERFS_SB(s)->priv_root) {
                        d_invalidate(REISERFS_SB(s)->priv_root);
                        dput(REISERFS_SB(s)->priv_root);
@@ -1562,9 +1562,10 @@ static int reiserfs_fill_super(struct super_block *s, void *data, int silent)
        REISERFS_SB(s)->s_alloc_options.preallocmin = 0;
        /* Preallocate by 16 blocks (17-1) at once */
        REISERFS_SB(s)->s_alloc_options.preallocsize = 17;
+#ifdef CONFIG_REISERFS_FS_XATTR
        /* Initialize the rwsem for xattr dir */
        init_rwsem(&REISERFS_SB(s)->xattr_dir_sem);
+#endif
        /* setup default block allocator options */
        reiserfs_init_alloc_options(s);
diff --git a/fs/select.c b/fs/select.c
index fe0893afd931..d86224154dec 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -14,10 +14,10 @@
 *     of fds to overcome nfds < 16390 descriptors limit (Tigran Aivazian).
 */
+#include <linux/kernel.h>
 #include <linux/syscalls.h>
 #include <linux/module.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/poll.h>
 #include <linux/personality.h> /* for STICKY_TIMEOUTS */
 #include <linux/file.h>
@@ -26,7 +26,6 @@
 #include <asm/uaccess.h>
-#define ROUND_UP(x,y) (((x)+(y)-1)/(y))
 #define DEFAULT_POLLMASK (POLLIN | POLLOUT | POLLRDNORM | POLLWRNORM)
 struct poll_table_page {
@@ -399,7 +398,7 @@ asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
                if ((u64)tv.tv_sec >= (u64)MAX_INT64_SECONDS)
                        timeout = -1;   /* infinite */
                else {
-                        timeout = ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);
+                        timeout = DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC/HZ);
                        timeout += tv.tv_sec * HZ;
                }
        }
@@ -454,7 +453,7 @@ asmlinkage long sys_pselect7(int n, fd_set __user *inp, fd_set __user *outp,
                if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
                        timeout = -1;   /* infinite */
                else {
-                        timeout = ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
+                        timeout = DIV_ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
                        timeout += ts.tv_sec * HZ;
                }
        }
@@ -776,7 +775,7 @@ asmlinkage long sys_ppoll(struct pollfd __user *ufds, unsigned int nfds,
                if ((u64)ts.tv_sec >= (u64)MAX_INT64_SECONDS)
                        timeout = -1;   /* infinite */
                else {
-                        timeout = ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
+                        timeout = DIV_ROUND_UP(ts.tv_nsec, NSEC_PER_SEC/HZ);
                        timeout += ts.tv_sec * HZ;
                }
        }
diff --git a/fs/smbfs/request.c b/fs/smbfs/request.c
index 723f7c667661..c288fbe7953d 100644
--- a/fs/smbfs/request.c
+++ b/fs/smbfs/request.c
@@ -6,6 +6,7 @@
 *  Please add a note about your changes to smbfs in the ChangeLog file.
 */
+#include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/fs.h>
 #include <linux/slab.h>
@@ -22,8 +23,6 @@
 /* #define SMB_SLAB_DEBUG       (SLAB_RED_ZONE | SLAB_POISON) */
 #define SMB_SLAB_DEBUG  0
-#define ROUND_UP(x) (((x)+3) & ~3)
 /* cache for request structures */
 static struct kmem_cache *req_cachep;
@@ -200,8 +199,8 @@ static int smb_setup_trans2request(struct smb_request *req)
        const int smb_parameters = 15;
        const int header = SMB_HEADER_LEN + 2 * smb_parameters + 2;
-        const int oparam = ROUND_UP(header + 3);
+        const int oparam = ALIGN(header + 3, sizeof(u32));
-        const int odata  = ROUND_UP(oparam + req->rq_lparm);
+        const int odata  = ALIGN(oparam + req->rq_lparm, sizeof(u32));
        const int bcc = (req->rq_data ? odata + req->rq_ldata :
                                        oparam + req->rq_lparm) - header;
diff --git a/fs/smbfs/smbiod.c b/fs/smbfs/smbiod.c
index 89eaf31f1d46..67176af8515f 100644
--- a/fs/smbfs/smbiod.c
+++ b/fs/smbfs/smbiod.c
@@ -16,7 +16,6 @@
 #include <linux/init.h>
 #include <linux/file.h>
 #include <linux/dcache.h>
-#include <linux/smp_lock.h>
 #include <linux/module.h>
 #include <linux/net.h>
 #include <linux/kthread.h>
@@ -299,8 +298,6 @@ out:
 */
 static int smbiod(void *unused)
 {
-        allow_signal(SIGKILL);
        VERBOSE("SMB Kernel thread starting (%d) ...\n", current->pid);
        for (;;) {
diff --git a/fs/smbfs/sock.c b/fs/smbfs/sock.c
index 92ea6b2367d7..e48bd8235a8e 100644
--- a/fs/smbfs/sock.c
+++ b/fs/smbfs/sock.c
@@ -17,7 +17,6 @@
 #include <linux/net.h>
 #include <linux/mm.h>
 #include <linux/netdevice.h>
-#include <linux/smp_lock.h>
 #include <linux/workqueue.h>
 #include <net/scm.h>
 #include <net/tcp_states.h>
diff --git a/fs/smbfs/symlink.c b/fs/smbfs/symlink.c
index fea20ceb8a5f..00b2909bd469 100644
--- a/fs/smbfs/symlink.c
+++ b/fs/smbfs/symlink.c
@@ -13,7 +13,6 @@
 #include <linux/mm.h>
 #include <linux/slab.h>
 #include <linux/pagemap.h>
-#include <linux/smp_lock.h>
 #include <linux/net.h>
 #include <linux/namei.h>
diff --git a/fs/stat.c b/fs/stat.c
index 38a8cb2a28de..68510068a641 100644
--- a/fs/stat.c
+++ b/fs/stat.c
@@ -8,7 +8,6 @@
 #include <linux/mm.h>
 #include <linux/errno.h>
 #include <linux/file.h>
-#include <linux/smp_lock.h>
 #include <linux/highuid.h>
 #include <linux/fs.h>
 #include <linux/namei.h>
diff --git a/fs/super.c b/fs/super.c
index 8341e4e1d738..5260d620c555 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -107,6 +107,7 @@ out:
 static inline void destroy_super(struct super_block *s)
 {
        security_sb_free(s);
+        kfree(s->s_subtype);
        kfree(s);
 }
@@ -907,6 +908,29 @@ out:
 EXPORT_SYMBOL_GPL(vfs_kern_mount);
+static struct vfsmount *fs_set_subtype(struct vfsmount *mnt, const char *fstype)
+{
+        int err;
+        const char *subtype = strchr(fstype, '.');
+        if (subtype) {
+                subtype++;
+                err = -EINVAL;
+                if (!subtype[0])
+                        goto err;
+        } else
+                subtype = "";
+        mnt->mnt_sb->s_subtype = kstrdup(subtype, GFP_KERNEL);
+        err = -ENOMEM;
+        if (!mnt->mnt_sb->s_subtype)
+                goto err;
+        return mnt;
+ err:
+        mntput(mnt);
+        return ERR_PTR(err);
+}
 struct vfsmount *
 do_kern_mount(const char *fstype, int flags, const char *name, void *data)
 {
@@ -915,6 +939,9 @@ do_kern_mount(const char *fstype, int flags, const char *name, void *data)
        if (!type)
                return ERR_PTR(-ENODEV);
        mnt = vfs_kern_mount(type, flags, name, data);
+        if (!IS_ERR(mnt) && (type->fs_flags & FS_HAS_SUBTYPE) &&
+            !mnt->mnt_sb->s_subtype)
+                mnt = fs_set_subtype(mnt, fstype);
        put_filesystem(type);
        return mnt;
 }
diff --git a/fs/sync.c b/fs/sync.c
index 5cb9e7e43383..2f97576355b8 100644
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -229,7 +229,7 @@ asmlinkage long sys_sync_file_range(int fd, loff_t offset, loff_t nbytes,
                        !S_ISLNK(i_mode))
                goto out_put;
-        ret = do_sync_file_range(file, offset, endbyte, flags);
+        ret = do_sync_mapping_range(file->f_mapping, offset, endbyte, flags);
 out_put:
        fput_light(file, fput_needed);
 out:
diff --git a/fs/sysv/namei.c b/fs/sysv/namei.c
index 4e48abbd2b5d..6bd850b7641a 100644
--- a/fs/sysv/namei.c
+++ b/fs/sysv/namei.c
@@ -13,7 +13,6 @@
 */
 #include <linux/pagemap.h>
-#include <linux/smp_lock.h>
 #include "sysv.h"
 static int add_nondir(struct dentry *dentry, struct inode *inode)
diff --git a/fs/udf/balloc.c b/fs/udf/balloc.c
index ea521f846d97..4cec91015681 100644
--- a/fs/udf/balloc.c
+++ b/fs/udf/balloc.c
@@ -427,9 +427,9 @@ static void udf_table_free_blocks(struct super_block * sb,
 {
        struct udf_sb_info *sbi = UDF_SB(sb);
        uint32_t start, end;
-        uint32_t nextoffset, oextoffset, elen;
+        uint32_t elen;
-        kernel_lb_addr nbloc, obloc, eloc;
+        kernel_lb_addr eloc;
-        struct buffer_head *obh, *nbh;
+        struct extent_position oepos, epos;
        int8_t etype;
        int i;
@@ -457,14 +457,13 @@ static void udf_table_free_blocks(struct super_block * sb,
        start = bloc.logicalBlockNum + offset;
        end = bloc.logicalBlockNum + offset + count - 1;
-        oextoffset = nextoffset = sizeof(struct unallocSpaceEntry);
+        epos.offset = oepos.offset = sizeof(struct unallocSpaceEntry);
        elen = 0;
-        obloc = nbloc = UDF_I_LOCATION(table);
+        epos.block = oepos.block = UDF_I_LOCATION(table);
+        epos.bh = oepos.bh = NULL;
-        obh = nbh = NULL;
        while (count && (etype =
-                udf_next_aext(table, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1)
+                udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
        {
                if (((eloc.logicalBlockNum + (elen >> sb->s_blocksize_bits)) ==
                        start))
@@ -482,7 +481,7 @@ static void udf_table_free_blocks(struct super_block * sb,
                                start += count;
                                count = 0;
                        }
-                        udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);
+                        udf_write_aext(table, &oepos, eloc, elen, 1);
                }
                else if (eloc.logicalBlockNum == (end + 1))
                {
@@ -502,20 +501,20 @@ static void udf_table_free_blocks(struct super_block * sb,
                                end -= count;
                                count = 0;
                        }
-                        udf_write_aext(table, obloc, &oextoffset, eloc, elen, obh, 1);
+                        udf_write_aext(table, &oepos, eloc, elen, 1);
                }
-                if (nbh != obh)
+                if (epos.bh != oepos.bh)
                {
                        i = -1;
-                        obloc = nbloc;
+                        oepos.block = epos.block;
-                        udf_release_data(obh);
+                        brelse(oepos.bh);
-                        atomic_inc(&nbh->b_count);
+                        get_bh(epos.bh);
-                        obh = nbh;
+                        oepos.bh = epos.bh;
-                        oextoffset = 0;
+                        oepos.offset = 0;
                }
                else
-                        oextoffset = nextoffset;
+                        oepos.offset = epos.offset;
        }
        if (count)
@@ -547,55 +546,53 @@ static void udf_table_free_blocks(struct super_block * sb,
                        adsize = sizeof(long_ad);
                else
                {
-                        udf_release_data(obh);
+                        brelse(oepos.bh);
-                        udf_release_data(nbh);
+                        brelse(epos.bh);
                        goto error_return;
                }
-                if (nextoffset + (2 * adsize) > sb->s_blocksize)
+                if (epos.offset + (2 * adsize) > sb->s_blocksize)
                {
                        char *sptr, *dptr;
                        int loffset;
        
-                        udf_release_data(obh);
+                        brelse(oepos.bh);
-                        obh = nbh;
+                        oepos = epos;
-                        obloc = nbloc;
-                        oextoffset = nextoffset;
                        /* Steal a block from the extent being free'd */
-                        nbloc.logicalBlockNum = eloc.logicalBlockNum;
+                        epos.block.logicalBlockNum = eloc.logicalBlockNum;
                        eloc.logicalBlockNum ++;
                        elen -= sb->s_blocksize;
-                        if (!(nbh = udf_tread(sb,
+                        if (!(epos.bh = udf_tread(sb,
-                                udf_get_lb_pblock(sb, nbloc, 0))))
+                                udf_get_lb_pblock(sb, epos.block, 0))))
                        {
-                                udf_release_data(obh);
+                                brelse(oepos.bh);
                                goto error_return;
                        }
-                        aed = (struct allocExtDesc *)(nbh->b_data);
+                        aed = (struct allocExtDesc *)(epos.bh->b_data);
-                        aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
+                        aed->previousAllocExtLocation = cpu_to_le32(oepos.block.logicalBlockNum);
-                        if (nextoffset + adsize > sb->s_blocksize)
+                        if (epos.offset + adsize > sb->s_blocksize)
                        {
-                                loffset = nextoffset;
+                                loffset = epos.offset;
                                aed->lengthAllocDescs = cpu_to_le32(adsize);
-                                sptr = UDF_I_DATA(inode) + nextoffset -
+                                sptr = UDF_I_DATA(inode) + epos.offset -
                                        udf_file_entry_alloc_offset(inode) +
                                        UDF_I_LENEATTR(inode) - adsize;
-                                dptr = nbh->b_data + sizeof(struct allocExtDesc);
+                                dptr = epos.bh->b_data + sizeof(struct allocExtDesc);
                                memcpy(dptr, sptr, adsize);
-                                nextoffset = sizeof(struct allocExtDesc) + adsize;
+                                epos.offset = sizeof(struct allocExtDesc) + adsize;
                        }
                        else
                        {
-                                loffset = nextoffset + adsize;
+                                loffset = epos.offset + adsize;
                                aed->lengthAllocDescs = cpu_to_le32(0);
-                                sptr = (obh)->b_data + nextoffset;
+                                sptr = oepos.bh->b_data + epos.offset;
-                                nextoffset = sizeof(struct allocExtDesc);
+                                epos.offset = sizeof(struct allocExtDesc);
-                                if (obh)
+                                if (oepos.bh)
                                {
-                                        aed = (struct allocExtDesc *)(obh)->b_data;
+                                        aed = (struct allocExtDesc *)oepos.bh->b_data;
                                        aed->lengthAllocDescs =
                                                cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
                                }
@@ -606,11 +603,11 @@ static void udf_table_free_blocks(struct super_block * sb,
                                }
                        }
                        if (UDF_SB_UDFREV(sb) >= 0x0200)
-                                udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 3, 1,
-                                        nbloc.logicalBlockNum, sizeof(tag));
+                                        epos.block.logicalBlockNum, sizeof(tag));
                        else
-                                udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
+                                udf_new_tag(epos.bh->b_data, TAG_IDENT_AED, 2, 1,
-                                        nbloc.logicalBlockNum, sizeof(tag));
+                                        epos.block.logicalBlockNum, sizeof(tag));
                        switch (UDF_I_ALLOCTYPE(table))
                        {
                                case ICBTAG_FLAG_AD_SHORT:
@@ -619,7 +616,7 @@ static void udf_table_free_blocks(struct super_block * sb,
                                        sad->extLength = cpu_to_le32(
                                                EXT_NEXT_EXTENT_ALLOCDECS |
                                                sb->s_blocksize);
-                                        sad->extPosition = cpu_to_le32(nbloc.logicalBlockNum);
+                                        sad->extPosition = cpu_to_le32(epos.block.logicalBlockNum);
                                        break;
                                }
                                case ICBTAG_FLAG_AD_LONG:
@@ -628,14 +625,14 @@ static void udf_table_free_blocks(struct super_block * sb,
                                        lad->extLength = cpu_to_le32(
                                                EXT_NEXT_EXTENT_ALLOCDECS |
                                                sb->s_blocksize);
-                                        lad->extLocation = cpu_to_lelb(nbloc);
+                                        lad->extLocation = cpu_to_lelb(epos.block);
                                        break;
                                }
                        }
-                        if (obh)
+                        if (oepos.bh)
                        {
-                                udf_update_tag(obh->b_data, loffset);
+                                udf_update_tag(oepos.bh->b_data, loffset);
-                                mark_buffer_dirty(obh);
+                                mark_buffer_dirty(oepos.bh);
                        }
                        else
                                mark_inode_dirty(table);
@@ -643,26 +640,26 @@ static void udf_table_free_blocks(struct super_block * sb,
                if (elen) /* It's possible that stealing the block emptied the extent */
                {
-                        udf_write_aext(table, nbloc, &nextoffset, eloc, elen, nbh, 1);
+                        udf_write_aext(table, &epos, eloc, elen, 1);
-                        if (!nbh)
+                        if (!epos.bh)
                        {
                                UDF_I_LENALLOC(table) += adsize;
                                mark_inode_dirty(table);
                        }
                        else
                        {
-                                aed = (struct allocExtDesc *)nbh->b_data;
+                                aed = (struct allocExtDesc *)epos.bh->b_data;
                                aed->lengthAllocDescs =
                                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
-                                udf_update_tag(nbh->b_data, nextoffset);
+                                udf_update_tag(epos.bh->b_data, epos.offset);
-                                mark_buffer_dirty(nbh);
+                                mark_buffer_dirty(epos.bh);
                        }
                }
        }
-        udf_release_data(nbh);
+        brelse(epos.bh);
-        udf_release_data(obh);
+        brelse(oepos.bh);
 error_return:
        sb->s_dirt = 1;
@@ -677,9 +674,9 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
 {
        struct udf_sb_info *sbi = UDF_SB(sb);
        int alloc_count = 0;
-        uint32_t extoffset, elen, adsize;
+        uint32_t elen, adsize;
-        kernel_lb_addr bloc, eloc;
+        kernel_lb_addr eloc;
-        struct buffer_head *bh;
+        struct extent_position epos;
        int8_t etype = -1;
        if (first_block < 0 || first_block >= UDF_SB_PARTLEN(sb, partition))
@@ -693,14 +690,13 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
                return 0;
        mutex_lock(&sbi->s_alloc_mutex);
-        extoffset = sizeof(struct unallocSpaceEntry);
+        epos.offset = sizeof(struct unallocSpaceEntry);
-        bloc = UDF_I_LOCATION(table);
+        epos.block = UDF_I_LOCATION(table);
+        epos.bh = NULL;
-        bh = NULL;
        eloc.logicalBlockNum = 0xFFFFFFFF;
        while (first_block != eloc.logicalBlockNum && (etype =
-                udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
+                udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
        {
                udf_debug("eloc=%d, elen=%d, first_block=%d\n",
                        eloc.logicalBlockNum, elen, first_block);
@@ -709,7 +705,7 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
        if (first_block == eloc.logicalBlockNum)
        {
-                extoffset -= adsize;
+                epos.offset -= adsize;
                alloc_count = (elen >> sb->s_blocksize_bits);
                if (inode && DQUOT_PREALLOC_BLOCK(inode, alloc_count > block_count ? block_count : alloc_count))
@@ -719,15 +715,15 @@ static int udf_table_prealloc_blocks(struct super_block * sb,
                        alloc_count = block_count;
                        eloc.logicalBlockNum += alloc_count;
                        elen -= (alloc_count << sb->s_blocksize_bits);
-                        udf_write_aext(table, bloc, &extoffset, eloc, (etype << 30) | elen, bh, 1);
+                        udf_write_aext(table, &epos, eloc, (etype << 30) | elen, 1);
                }
                else
-                        udf_delete_aext(table, bloc, extoffset, eloc, (etype << 30) | elen, bh);
+                        udf_delete_aext(table, epos, eloc, (etype << 30) | elen);
        }
        else
                alloc_count = 0;
-        udf_release_data(bh);
+        brelse(epos.bh);
        if (alloc_count && UDF_SB_LVIDBH(sb))
        {
@@ -747,9 +743,9 @@ static int udf_table_new_block(struct super_block * sb,
        struct udf_sb_info *sbi = UDF_SB(sb);
        uint32_t spread = 0xFFFFFFFF, nspread = 0xFFFFFFFF;
        uint32_t newblock = 0, adsize;
-        uint32_t extoffset, goal_extoffset, elen, goal_elen = 0;
+        uint32_t elen, goal_elen = 0;
-        kernel_lb_addr bloc, goal_bloc, eloc, goal_eloc;
+        kernel_lb_addr eloc, goal_eloc;
-        struct buffer_head *bh, *goal_bh;
+        struct extent_position epos, goal_epos;
        int8_t etype;
        *err = -ENOSPC;
@@ -770,14 +766,12 @@ static int udf_table_new_block(struct super_block * sb,
           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);
-        extoffset = sizeof(struct unallocSpaceEntry);
+        epos.block = UDF_I_LOCATION(table);
-        bloc = UDF_I_LOCATION(table);
+        epos.bh = goal_epos.bh = NULL;
-        goal_bh = bh = NULL;
        while (spread && (etype =
-                udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
+                udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
        {
                if (goal >= eloc.logicalBlockNum)
                {
@@ -793,24 +787,24 @@ static int udf_table_new_block(struct super_block * sb,
                if (nspread < spread)
                {
                        spread = nspread;
-                        if (goal_bh != bh)
+                        if (goal_epos.bh != epos.bh)
                        {
-                                udf_release_data(goal_bh);
+                                brelse(goal_epos.bh);
-                                goal_bh = bh;
+                                goal_epos.bh = epos.bh;
-                                atomic_inc(&goal_bh->b_count);
+                                get_bh(goal_epos.bh);
                        }
-                        goal_bloc = bloc;
+                        goal_epos.block = epos.block;
-                        goal_extoffset = extoffset - adsize;
+                        goal_epos.offset = epos.offset - adsize;
                        goal_eloc = eloc;
                        goal_elen = (etype << 30) | elen;
                }
        }
-        udf_release_data(bh);
+        brelse(epos.bh);
        if (spread == 0xFFFFFFFF)
        {
-                udf_release_data(goal_bh);
+                brelse(goal_epos.bh);
                mutex_unlock(&sbi->s_alloc_mutex);
                return 0;
        }
@@ -826,17 +820,17 @@ static int udf_table_new_block(struct super_block * sb,
        if (inode && DQUOT_ALLOC_BLOCK(inode, 1))
        {
-                udf_release_data(goal_bh);
+                brelse(goal_epos.bh);
                mutex_unlock(&sbi->s_alloc_mutex);
                *err = -EDQUOT;
                return 0;
        }
        if (goal_elen)
-                udf_write_aext(table, goal_bloc, &goal_extoffset, goal_eloc, goal_elen, goal_bh, 1);
+                udf_write_aext(table, &goal_epos, goal_eloc, goal_elen, 1);
        else
-                udf_delete_aext(table, goal_bloc, goal_extoffset, goal_eloc, goal_elen, goal_bh);
+                udf_delete_aext(table, goal_epos, goal_eloc, goal_elen);
-        udf_release_data(goal_bh);
+        brelse(goal_epos.bh);
        if (UDF_SB_LVIDBH(sb))
        {
@@ -921,11 +915,14 @@ inline int udf_new_block(struct super_block * sb,
        struct inode * inode,
        uint16_t partition, uint32_t goal, int *err)
 {
+        int ret;
        if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_BITMAP)
        {
-                return udf_bitmap_new_block(sb, inode,
+                ret = udf_bitmap_new_block(sb, inode,
                        UDF_SB_PARTMAPS(sb)[partition].s_uspace.s_bitmap,
                        partition, goal, err);
+                return ret;
        }
        else if (UDF_SB_PARTFLAGS(sb, partition) & UDF_PART_FLAG_UNALLOC_TABLE)
        {
diff --git a/fs/udf/dir.c b/fs/udf/dir.c
index 2391c9150c49..e45f86b5e7b0 100644
--- a/fs/udf/dir.c
+++ b/fs/udf/dir.c
@@ -111,11 +111,13 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
        uint16_t liu;
        uint8_t lfi;
        loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
-        struct buffer_head * bh = NULL, * tmp, * bha[16];
+        struct buffer_head *tmp, *bha[16];
-        kernel_lb_addr bloc, eloc;
+        kernel_lb_addr eloc;
-        uint32_t extoffset, elen, offset;
+        uint32_t elen;
+        sector_t offset;
        int i, num;
        unsigned int dt_type;
+        struct extent_position epos = { NULL, 0, {0, 0}};
        if (nf_pos >= size)
                return 0;
@@ -127,23 +129,22 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
                fibh.sbh = fibh.ebh = NULL;
        else if (inode_bmap(dir, nf_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
+                &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
        {
-                offset >>= dir->i_sb->s_blocksize_bits;
                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)
-                                extoffset -= sizeof(short_ad);
+                                epos.offset -= sizeof(short_ad);
                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
-                                extoffset -= sizeof(long_ad);
+                                epos.offset -= sizeof(long_ad);
                }
                else
                        offset = 0;
                if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))
                {
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        return -EIO;
                }
        
@@ -171,7 +172,7 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
        }
        else
        {
-                udf_release_data(bh);
+                brelse(epos.bh);
                return -ENOENT;
        }
@@ -179,14 +180,14 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
        {
                filp->f_pos = nf_pos + 1;
-                fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
+                fi = udf_fileident_read(dir, &nf_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);
                if (!fi)
                {
                        if (fibh.sbh != fibh.ebh)
-                                udf_release_data(fibh.ebh);
+                                brelse(fibh.ebh);
-                        udf_release_data(fibh.sbh);
+                        brelse(fibh.sbh);
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        return 0;
                }
@@ -244,9 +245,9 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
                        if (filldir(dirent, fname, flen, filp->f_pos, iblock, dt_type) < 0)
                        {
                                if (fibh.sbh != fibh.ebh)
-                                        udf_release_data(fibh.ebh);
+                                        brelse(fibh.ebh);
-                                udf_release_data(fibh.sbh);
+                                brelse(fibh.sbh);
-                                udf_release_data(bh);
+                                brelse(epos.bh);
                                return 0;
                        }
                }
@@ -255,9 +256,9 @@ do_udf_readdir(struct inode * dir, struct file *filp, filldir_t filldir, void *d
        filp->f_pos = nf_pos + 1;
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
-        udf_release_data(bh);
+        brelse(epos.bh);
        return 0;
 }
diff --git a/fs/udf/directory.c b/fs/udf/directory.c
index fe751a2a0e47..198caa33027a 100644
--- a/fs/udf/directory.c
+++ b/fs/udf/directory.c
@@ -36,14 +36,14 @@ udf_filead_read(struct inode *dir, uint8_t *tmpad, uint8_t ad_size,
        if (!ad)
        {
-                udf_release_data(*bh);
+                brelse(*bh);
                *error = 1;
                return NULL;
        }
        if (*offset == dir->i_sb->s_blocksize)
        {
-                udf_release_data(*bh);
+                brelse(*bh);
                block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
                if (!block)
                        return NULL;
@@ -57,7 +57,7 @@ udf_filead_read(struct inode *dir, uint8_t *tmpad, uint8_t ad_size,
                remainder = dir->i_sb->s_blocksize - loffset;
                memcpy((uint8_t *)ad, (*bh)->b_data + loffset, remainder);
-                udf_release_data(*bh);
+                brelse(*bh);
                block = udf_get_lb_pblock(dir->i_sb, fe_loc, ++*pos);
                if (!block)
                        return NULL;
@@ -75,9 +75,9 @@ struct fileIdentDesc *
 udf_fileident_read(struct inode *dir, loff_t *nf_pos,
        struct udf_fileident_bh *fibh,
        struct fileIdentDesc *cfi,
-        kernel_lb_addr *bloc, uint32_t *extoffset, 
+        struct extent_position *epos,
        kernel_lb_addr *eloc, uint32_t *elen,
-        uint32_t *offset, struct buffer_head **bh)
+        sector_t *offset)
 {
        struct fileIdentDesc *fi;
        int i, num, block;
@@ -105,13 +105,11 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
        if (fibh->eoffset == dir->i_sb->s_blocksize)
        {
-                int lextoffset = *extoffset;
+                int lextoffset = epos->offset;
-                if (udf_next_aext(dir, bloc, extoffset, eloc, elen, bh, 1) !=
+                if (udf_next_aext(dir, epos, eloc, elen, 1) !=
                        (EXT_RECORDED_ALLOCATED >> 30))
-                {
                        return NULL;
-                }
                block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);
@@ -120,9 +118,9 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
                if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
                        *offset = 0;
                else
-                        *extoffset = lextoffset;
+                        epos->offset = lextoffset;
-                udf_release_data(fibh->sbh);
+                brelse(fibh->sbh);
                if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
                        return NULL;
                fibh->soffset = fibh->eoffset = 0;
@@ -151,7 +149,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
        }
        else if (fibh->sbh != fibh->ebh)
        {
-                udf_release_data(fibh->sbh);
+                brelse(fibh->sbh);
                fibh->sbh = fibh->ebh;
        }
@@ -169,13 +167,11 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
        }
        else if (fibh->eoffset > dir->i_sb->s_blocksize)
        {
-                int lextoffset = *extoffset;
+                int lextoffset = epos->offset;
-                if (udf_next_aext(dir, bloc, extoffset, eloc, elen, bh, 1) !=
+                if (udf_next_aext(dir, epos, eloc, elen, 1) !=
                        (EXT_RECORDED_ALLOCATED >> 30))
-                {
                        return NULL;
-                }
                block = udf_get_lb_pblock(dir->i_sb, *eloc, *offset);
@@ -184,7 +180,7 @@ udf_fileident_read(struct inode *dir, loff_t *nf_pos,
                if ((*offset << dir->i_sb->s_blocksize_bits) >= *elen)
                        *offset = 0;
                else
-                        *extoffset = lextoffset;
+                        epos->offset = lextoffset;
                fibh->soffset -= dir->i_sb->s_blocksize;
                fibh->eoffset -= dir->i_sb->s_blocksize;
diff --git a/fs/udf/fsync.c b/fs/udf/fsync.c
index 5887d78cde43..6ded93e7c44f 100644
--- a/fs/udf/fsync.c
+++ b/fs/udf/fsync.c
@@ -21,7 +21,6 @@
 #include "udfdecl.h"
 #include <linux/fs.h>
-#include <linux/smp_lock.h>
 static int udf_fsync_inode(struct inode *, int);
diff --git a/fs/udf/inode.c b/fs/udf/inode.c
index ae21a0e59e95..c8461551e108 100644
--- a/fs/udf/inode.c
+++ b/fs/udf/inode.c
@@ -49,10 +49,10 @@ MODULE_LICENSE("GPL");
 static mode_t udf_convert_permissions(struct fileEntry *);
 static int udf_update_inode(struct inode *, int);
 static void udf_fill_inode(struct inode *, struct buffer_head *);
-static struct buffer_head *inode_getblk(struct inode *, long, int *,
+static struct buffer_head *inode_getblk(struct inode *, sector_t, int *,
        long *, int *);
-static int8_t udf_insert_aext(struct inode *, kernel_lb_addr, int,
+static int8_t udf_insert_aext(struct inode *, struct extent_position,
-        kernel_lb_addr, uint32_t, struct buffer_head *);
+        kernel_lb_addr, uint32_t);
 static void udf_split_extents(struct inode *, int *, int, int,
        kernel_long_ad [EXTENT_MERGE_SIZE], int *);
 static void udf_prealloc_extents(struct inode *, int, int,
@@ -61,7 +61,7 @@ static void udf_merge_extents(struct inode *,
         kernel_long_ad [EXTENT_MERGE_SIZE], int *);
 static void udf_update_extents(struct inode *,
        kernel_long_ad [EXTENT_MERGE_SIZE], int, int,
-        kernel_lb_addr, uint32_t, struct buffer_head **);
+        struct extent_position *);
 static int udf_get_block(struct inode *, sector_t, struct buffer_head *, int);
 /*
@@ -194,10 +194,11 @@ void udf_expand_file_adinicb(struct inode * inode, int newsize, int * err)
 struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int *err)
 {
        int newblock;
-        struct buffer_head *sbh = NULL, *dbh = NULL;
+        struct buffer_head *dbh = NULL;
-        kernel_lb_addr bloc, eloc;
+        kernel_lb_addr eloc;
-        uint32_t elen, extoffset;
+        uint32_t elen;
        uint8_t alloctype;
+        struct extent_position epos;
        struct udf_fileident_bh sfibh, dfibh;
        loff_t f_pos = udf_ext0_offset(inode) >> 2;
@@ -237,16 +238,16 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
        mark_buffer_dirty_inode(dbh, inode);
        sfibh.soffset = sfibh.eoffset = (f_pos & ((inode->i_sb->s_blocksize - 1) >> 2)) << 2;
-        sbh = sfibh.sbh = sfibh.ebh = NULL;
+        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, NULL, NULL);
+                sfi = udf_fileident_read(inode, &f_pos, &sfibh, &cfi, NULL, NULL, NULL, NULL);
                if (!sfi)
                {
-                        udf_release_data(dbh);
+                        brelse(dbh);
                        return NULL;
                }
                UDF_I_ALLOCTYPE(inode) = alloctype;
@@ -258,7 +259,7 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
                        sfi->fileIdent + le16_to_cpu(sfi->lengthOfImpUse)))
                {
                        UDF_I_ALLOCTYPE(inode) = ICBTAG_FLAG_AD_IN_ICB;
-                        udf_release_data(dbh);
+                        brelse(dbh);
                        return NULL;
                }
        }
@@ -266,16 +267,17 @@ struct buffer_head * udf_expand_dir_adinicb(struct inode *inode, int *block, int
        memset(UDF_I_DATA(inode) + UDF_I_LENEATTR(inode), 0, UDF_I_LENALLOC(inode));
        UDF_I_LENALLOC(inode) = 0;
-        bloc = UDF_I_LOCATION(inode);
        eloc.logicalBlockNum = *block;
        eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
        elen = inode->i_size;
        UDF_I_LENEXTENTS(inode) = elen;
-        extoffset = udf_file_entry_alloc_offset(inode);
+        epos.bh = NULL;
-        udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &sbh, 0);
+        epos.block = UDF_I_LOCATION(inode);
+        epos.offset = udf_file_entry_alloc_offset(inode);
+        udf_add_aext(inode, &epos, eloc, elen, 0);
        /* UniqueID stuff */
-        udf_release_data(sbh);
+        brelse(epos.bh);
        mark_inode_dirty(inode);
        return dbh;
 }
@@ -354,53 +356,153 @@ udf_getblk(struct inode *inode, long block, int create, int *err)
        return NULL;
 }
-static struct buffer_head * inode_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)
+{
+        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 = {0, 0};
+        int prealloc_len = 0;
+        /* The previous extent is fake and we should not extend by anything
+         * - there's nothing to do... */
+        if (!blocks && fake)
+                return 0;
+        /* 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) &
+                                ~(sb->s_blocksize - 1);
+        }
+        /* Last extent are just preallocated blocks? */
+        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;
+                /* Mark the extent as a hole */
+                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;
+        }
+        /* 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 (add > blocks)
+                        add = blocks;
+                blocks -= add;
+                last_ext->extLength += add << sb->s_blocksize_bits;
+        }
+        if (fake) {
+                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);
+        /* Managed to do everything necessary? */
+        if (!blocks)
+                goto out;
+        /* All further extents will be NOT_RECORDED_NOT_ALLOCATED */
+        last_ext->extLocation.logicalBlockNum = 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);
+        /* Create enough extents to cover the whole hole */
+        while (blocks > add) {
+                blocks -= add;
+                if (udf_add_aext(inode, last_pos, last_ext->extLocation,
+                        last_ext->extLength, 1) == -1)
+                        return -1;
+                count++;
+        }
+        if (blocks) {
+                last_ext->extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
+                        (blocks << sb->s_blocksize_bits);
+                if (udf_add_aext(inode, last_pos, last_ext->extLocation,
+                        last_ext->extLength, 1) == -1)
+                        return -1;
+                count++;
+        }
+out:
+        /* Do we have some preallocated blocks saved? */
+        if (prealloc_len) {
+                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;
+                count++;
+        }
+        /* last_pos should point to the last written extent... */
+        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
+                last_pos->offset -= sizeof(short_ad);
+        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
+                last_pos->offset -= sizeof(long_ad);
+        else
+                return -1;
+        return count;
+}
+static struct buffer_head * inode_getblk(struct inode * inode, sector_t block,
        int *err, long *phys, int *new)
 {
-        struct buffer_head *pbh = NULL, *cbh = NULL, *nbh = NULL, *result = NULL;
+        static sector_t last_block;
+        struct buffer_head *result = NULL;
        kernel_long_ad laarr[EXTENT_MERGE_SIZE];
-        uint32_t pextoffset = 0, cextoffset = 0, nextoffset = 0;
+        struct extent_position prev_epos, cur_epos, next_epos;
        int count = 0, startnum = 0, endnum = 0;
        uint32_t elen = 0;
-        kernel_lb_addr eloc, pbloc, cbloc, nbloc;
+        kernel_lb_addr eloc;
        int c = 1;
-        uint64_t lbcount = 0, b_off = 0;
+        loff_t lbcount = 0, b_off = 0;
-        uint32_t newblocknum, newblock, offset = 0;
+        uint32_t newblocknum, newblock;
+        sector_t offset = 0;
        int8_t etype;
        int goal = 0, pgoal = UDF_I_LOCATION(inode).logicalBlockNum;
-        char lastblock = 0;
+        int lastblock = 0;
-        pextoffset = cextoffset = nextoffset = udf_file_entry_alloc_offset(inode);
+        prev_epos.offset = udf_file_entry_alloc_offset(inode);
-        b_off = (uint64_t)block << inode->i_sb->s_blocksize_bits;
+        prev_epos.block = UDF_I_LOCATION(inode);
-        pbloc = cbloc = nbloc = UDF_I_LOCATION(inode);
+        prev_epos.bh = NULL;
+        cur_epos = next_epos = prev_epos;
+        b_off = (loff_t)block << inode->i_sb->s_blocksize_bits;
        /* find the extent which contains the block we are looking for.
       alternate between laarr[0] and laarr[1] for locations of the
       current extent, and the previous extent */
        do
        {
-                if (pbh != cbh)
+                if (prev_epos.bh != cur_epos.bh)
                {
-                        udf_release_data(pbh);
+                        brelse(prev_epos.bh);
-                        atomic_inc(&cbh->b_count);
+                        get_bh(cur_epos.bh);
-                        pbh = cbh;
+                        prev_epos.bh = cur_epos.bh;
                }
-                if (cbh != nbh)
+                if (cur_epos.bh != next_epos.bh)
                {
-                        udf_release_data(cbh);
+                        brelse(cur_epos.bh);
-                        atomic_inc(&nbh->b_count);
+                        get_bh(next_epos.bh);
-                        cbh = nbh;
+                        cur_epos.bh = next_epos.bh;
                }
                lbcount += elen;
-                pbloc = cbloc;
+                prev_epos.block = cur_epos.block;
-                cbloc = nbloc;
+                cur_epos.block = next_epos.block;
-                pextoffset = cextoffset;
+                prev_epos.offset = cur_epos.offset;
-                cextoffset = nextoffset;
+                cur_epos.offset = next_epos.offset;
-                if ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) == -1)
+                if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 1)) == -1)
                        break;
                c = !c;
@@ -418,6 +520,8 @@ static struct buffer_head * inode_getblk(struct inode * inode, long block,
        b_off -= lbcount;
        offset = b_off >> inode->i_sb->s_blocksize_bits;
+        /* Move into indirect extent if we are at a pointer to it */
+        udf_next_aext(inode, &prev_epos, &eloc, &elen, 0);
        /* if the extent is allocated and recorded, return the block
       if the extent is not a multiple of the blocksize, round up */
@@ -429,54 +533,77 @@ static struct buffer_head * inode_getblk(struct inode * inode, long block,
                        elen = EXT_RECORDED_ALLOCATED |
                                ((elen + inode->i_sb->s_blocksize - 1) &
                                ~(inode->i_sb->s_blocksize - 1));
-                        etype = udf_write_aext(inode, nbloc, &cextoffset, eloc, elen, nbh, 1);
+                        etype = udf_write_aext(inode, &cur_epos, eloc, elen, 1);
                }
-                udf_release_data(pbh);
+                brelse(prev_epos.bh);
-                udf_release_data(cbh);
+                brelse(cur_epos.bh);
-                udf_release_data(nbh);
+                brelse(next_epos.bh);
                newblock = udf_get_lb_pblock(inode->i_sb, eloc, offset);
                *phys = newblock;
                return NULL;
        }
+        last_block = block;
+        /* Are we beyond EOF? */
        if (etype == -1)
        {
-                endnum = startnum = ((count > 1) ? 1 : count);
+                int ret;
-                if (laarr[c].extLength & (inode->i_sb->s_blocksize - 1))
-                {
+                if (count) {
-                        laarr[c].extLength =
+                        if (c)
-                                (laarr[c].extLength & UDF_EXTENT_FLAG_MASK) |
+                                laarr[0] = laarr[1];
-                                (((laarr[c].extLength & UDF_EXTENT_LENGTH_MASK) +
+                        startnum = 1;
-                                        inode->i_sb->s_blocksize - 1) &
+                }
-                                ~(inode->i_sb->s_blocksize - 1));
+                else {
-                        UDF_I_LENEXTENTS(inode) =
+                        /* Create a fake extent when there's not one */
-                                (UDF_I_LENEXTENTS(inode) + inode->i_sb->s_blocksize - 1) &
+                        memset(&laarr[0].extLocation, 0x00, sizeof(kernel_lb_addr));
-                                        ~(inode->i_sb->s_blocksize - 1);
+                        laarr[0].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
+                        /* Will udf_extend_file() create real extent from a fake one? */
+                        startnum = (offset > 0);
+                }
+                /* Create extents for the hole between EOF and offset */
+                ret = udf_extend_file(inode, &prev_epos, laarr, offset);
+                if (ret == -1) {
+                        brelse(prev_epos.bh);
+                        brelse(cur_epos.bh);
+                        brelse(next_epos.bh);
+                        /* We don't really know the error here so we just make
+                         * something up */
+                        *err = -ENOSPC;
+                        return NULL;
                }
-                c = !c;
+                c = 0;
-                laarr[c].extLength = EXT_NOT_RECORDED_NOT_ALLOCATED |
+                offset = 0;
-                        ((offset + 1) << inode->i_sb->s_blocksize_bits);
+                count += ret;
-                memset(&laarr[c].extLocation, 0x00, sizeof(kernel_lb_addr));
+                /* We are not covered by a preallocated extent? */
-                count ++;
+                if ((laarr[0].extLength & UDF_EXTENT_FLAG_MASK) != EXT_NOT_RECORDED_ALLOCATED) {
-                endnum ++;
+                        /* 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));
+                        count ++;
+                        endnum ++;
+                }
+                endnum = c+1;
                lastblock = 1;
        }
-        else
+        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)
+                if (!c && count != 1)
-        {
+                {
-                laarr[2] = laarr[0];
+                        laarr[2] = laarr[0];
-                laarr[0] = laarr[1];
+                        laarr[0] = laarr[1];
-                laarr[1] = laarr[2];
+                        laarr[1] = laarr[2];
-                c = 1;
+                        c = 1;
-        }
+                }
-        /* if the current block is located in a extent, read the next extent */
+                /* if the current block is located in an extent, read the next extent */
-        if (etype != -1)
+                if ((etype = udf_next_aext(inode, &next_epos, &eloc, &elen, 0)) != -1)
-        {
-                if ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 0)) != -1)
                {
                        laarr[c+1].extLength = (etype << 30) | elen;
                        laarr[c+1].extLocation = eloc;
@@ -484,11 +611,10 @@ static struct buffer_head * inode_getblk(struct inode * inode, long block,
                        startnum ++;
                        endnum ++;
                }
-                else
+                else {
                        lastblock = 1;
+                }
        }
-        udf_release_data(cbh);
-        udf_release_data(nbh);
        /* if the current extent is not recorded but allocated, get the
                block in the extent corresponding to the requested block */
@@ -508,7 +634,7 @@ static struct buffer_head * inode_getblk(struct inode * inode, long block,
                if (!(newblocknum = udf_new_block(inode->i_sb, inode,
                        UDF_I_LOCATION(inode).partitionReferenceNum, goal, err)))
                {
-                        udf_release_data(pbh);
+                        brelse(prev_epos.bh);
                        *err = -ENOSPC;
                        return NULL;
                }
@@ -529,11 +655,11 @@ static struct buffer_head * inode_getblk(struct inode * inode, long block,
        udf_merge_extents(inode, laarr, &endnum);
        /* write back the new extents, inserting new extents if the new number
-       of extents is greater than the old number, and deleting extents if
+        of extents is greater than the old number, and deleting extents if
-       the new number of extents is less than the old number */
+        the new number of extents is less than the old number */
-        udf_update_extents(inode, laarr, startnum, endnum, pbloc, pextoffset, &pbh);
+        udf_update_extents(inode, laarr, startnum, endnum, &prev_epos);
-        udf_release_data(pbh);
+        brelse(prev_epos.bh);
        if (!(newblock = udf_get_pblock(inode->i_sb, newblocknum,
                UDF_I_LOCATION(inode).partitionReferenceNum, 0)))
@@ -795,7 +921,7 @@ static void udf_merge_extents(struct inode *inode,
 static void udf_update_extents(struct inode *inode,
        kernel_long_ad laarr[EXTENT_MERGE_SIZE], int startnum, int endnum,
-        kernel_lb_addr pbloc, uint32_t pextoffset, struct buffer_head **pbh)
+        struct extent_position *epos)
 {
        int start = 0, i;
        kernel_lb_addr tmploc;
@@ -804,28 +930,26 @@ static void udf_update_extents(struct inode *inode,
        if (startnum > endnum)
        {
                for (i=0; i<(startnum-endnum); i++)
-                {
+                        udf_delete_aext(inode, *epos, laarr[i].extLocation,
-                        udf_delete_aext(inode, pbloc, pextoffset, laarr[i].extLocation,
+                                laarr[i].extLength);
-                                laarr[i].extLength, *pbh);
-                }
        }
        else if (startnum < endnum)
        {
                for (i=0; i<(endnum-startnum); i++)
                {
-                        udf_insert_aext(inode, pbloc, pextoffset, laarr[i].extLocation,
+                        udf_insert_aext(inode, *epos, laarr[i].extLocation,
-                                laarr[i].extLength, *pbh);
+                                laarr[i].extLength);
-                        udf_next_aext(inode, &pbloc, &pextoffset, &laarr[i].extLocation,
+                        udf_next_aext(inode, epos, &laarr[i].extLocation,
-                                &laarr[i].extLength, pbh, 1);
+                                &laarr[i].extLength, 1);
                        start ++;
                }
        }
        for (i=start; i<endnum; i++)
        {
-                udf_next_aext(inode, &pbloc, &pextoffset, &tmploc, &tmplen, pbh, 0);
+                udf_next_aext(inode, epos, &tmploc, &tmplen, 0);
-                udf_write_aext(inode, pbloc, &pextoffset, laarr[i].extLocation,
+                udf_write_aext(inode, epos, laarr[i].extLocation,
-                        laarr[i].extLength, *pbh, 1);
+                        laarr[i].extLength, 1);
        }
 }
@@ -931,7 +1055,7 @@ __udf_read_inode(struct inode *inode)
        {
                printk(KERN_ERR "udf: udf_read_inode(ino %ld) failed ident=%d\n",
                        inode->i_ino, ident);
-                udf_release_data(bh);
+                brelse(bh);
                make_bad_inode(inode);
                return;
        }
@@ -960,35 +1084,36 @@ __udf_read_inode(struct inode *inode)
                                                ident == TAG_IDENT_EFE)
                                        {
                                                memcpy(&UDF_I_LOCATION(inode), &loc, sizeof(kernel_lb_addr));
-                                                udf_release_data(bh);
+                                                brelse(bh);
-                                                udf_release_data(ibh);
+                                                brelse(ibh);
-                                                udf_release_data(nbh);
+                                                brelse(nbh);
                                                __udf_read_inode(inode);
                                                return;
                                        }
                                        else
                                        {
-                                                udf_release_data(nbh);
+                                                brelse(nbh);
-                                                udf_release_data(ibh);
+                                                brelse(ibh);
                                        }
                                }
                                else
-                                        udf_release_data(ibh);
+                                        brelse(ibh);
                        }
                }
                else
-                        udf_release_data(ibh);
+                        brelse(ibh);
        }
        else if (le16_to_cpu(fe->icbTag.strategyType) != 4)
        {
                printk(KERN_ERR "udf: unsupported strategy type: %d\n",
                        le16_to_cpu(fe->icbTag.strategyType));
-                udf_release_data(bh);
+                brelse(bh);
                make_bad_inode(inode);
                return;
        }
        udf_fill_inode(inode, bh);
-        udf_release_data(bh);
+        brelse(bh);
 }
 static void udf_fill_inode(struct inode *inode, struct buffer_head *bh)
@@ -1331,7 +1456,7 @@ udf_update_inode(struct inode *inode, int do_sync)
                                use->descTag.tagChecksum += ((uint8_t *)&(use->descTag))[i];
                mark_buffer_dirty(bh);
-                udf_release_data(bh);
+                brelse(bh);
                return err;
        }
@@ -1520,7 +1645,7 @@ udf_update_inode(struct inode *inode, int do_sync)
                        err = -EIO;
                }
        }
-        udf_release_data(bh);
+        brelse(bh);
        return err;
 }
@@ -1556,8 +1681,8 @@ udf_iget(struct super_block *sb, kernel_lb_addr ino)
        return NULL;
 }
-int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
+int8_t udf_add_aext(struct inode *inode, struct extent_position *epos,
-        kernel_lb_addr eloc, uint32_t elen, struct buffer_head **bh, int inc)
+        kernel_lb_addr eloc, uint32_t elen, int inc)
 {
        int adsize;
        short_ad *sad = NULL;
@@ -1566,10 +1691,10 @@ int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
        int8_t etype;
        uint8_t *ptr;
-        if (!*bh)
+        if (!epos->bh)
-                ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
+                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
        else
-                ptr = (*bh)->b_data + *extoffset;
+                ptr = epos->bh->b_data + epos->offset;
        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
                adsize = sizeof(short_ad);
@@ -1578,20 +1703,20 @@ int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
        else
                return -1;
-        if (*extoffset + (2 * adsize) > inode->i_sb->s_blocksize)
+        if (epos->offset + (2 * adsize) > inode->i_sb->s_blocksize)
        {
                char *sptr, *dptr;
                struct buffer_head *nbh;
                int err, loffset;
-                kernel_lb_addr obloc = *bloc;
+                kernel_lb_addr obloc = epos->block;
-                if (!(bloc->logicalBlockNum = udf_new_block(inode->i_sb, NULL,
+                if (!(epos->block.logicalBlockNum = udf_new_block(inode->i_sb, NULL,
                        obloc.partitionReferenceNum, obloc.logicalBlockNum, &err)))
                {
                        return -1;
                }
                if (!(nbh = udf_tgetblk(inode->i_sb, udf_get_lb_pblock(inode->i_sb,
-                        *bloc, 0))))
+                        epos->block, 0))))
                {
                        return -1;
                }
@@ -1604,25 +1729,25 @@ int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
                aed = (struct allocExtDesc *)(nbh->b_data);
                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT))
                        aed->previousAllocExtLocation = cpu_to_le32(obloc.logicalBlockNum);
-                if (*extoffset + adsize > inode->i_sb->s_blocksize)
+                if (epos->offset + adsize > inode->i_sb->s_blocksize)
                {
-                        loffset = *extoffset;
+                        loffset = epos->offset;
                        aed->lengthAllocDescs = cpu_to_le32(adsize);
                        sptr = ptr - adsize;
                        dptr = nbh->b_data + sizeof(struct allocExtDesc);
                        memcpy(dptr, sptr, adsize);
-                        *extoffset = sizeof(struct allocExtDesc) + adsize;
+                        epos->offset = sizeof(struct allocExtDesc) + adsize;
                }
                else
                {
-                        loffset = *extoffset + adsize;
+                        loffset = epos->offset + adsize;
                        aed->lengthAllocDescs = cpu_to_le32(0);
                        sptr = ptr;
-                        *extoffset = sizeof(struct allocExtDesc);
+                        epos->offset = sizeof(struct allocExtDesc);
-                        if (*bh)
+                        if (epos->bh)
                        {
-                                aed = (struct allocExtDesc *)(*bh)->b_data;
+                                aed = (struct allocExtDesc *)epos->bh->b_data;
                                aed->lengthAllocDescs =
                                        cpu_to_le32(le32_to_cpu(aed->lengthAllocDescs) + adsize);
                        }
@@ -1634,10 +1759,10 @@ int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
                }
                if (UDF_SB_UDFREV(inode->i_sb) >= 0x0200)
                        udf_new_tag(nbh->b_data, TAG_IDENT_AED, 3, 1,
-                                bloc->logicalBlockNum, sizeof(tag));
+                                epos->block.logicalBlockNum, sizeof(tag));
                else
                        udf_new_tag(nbh->b_data, TAG_IDENT_AED, 2, 1,
-                                bloc->logicalBlockNum, sizeof(tag));
+                                epos->block.logicalBlockNum, sizeof(tag));
                switch (UDF_I_ALLOCTYPE(inode))
                {
                        case ICBTAG_FLAG_AD_SHORT:
@@ -1646,7 +1771,7 @@ int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
                                sad->extLength = cpu_to_le32(
                                        EXT_NEXT_EXTENT_ALLOCDECS |
                                        inode->i_sb->s_blocksize);
-                                sad->extPosition = cpu_to_le32(bloc->logicalBlockNum);
+                                sad->extPosition = cpu_to_le32(epos->block.logicalBlockNum);
                                break;
                        }
                        case ICBTAG_FLAG_AD_LONG:
@@ -1655,60 +1780,57 @@ int8_t udf_add_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
                                lad->extLength = cpu_to_le32(
                                        EXT_NEXT_EXTENT_ALLOCDECS |
                                        inode->i_sb->s_blocksize);
-                                lad->extLocation = cpu_to_lelb(*bloc);
+                                lad->extLocation = cpu_to_lelb(epos->block);
                                memset(lad->impUse, 0x00, sizeof(lad->impUse));
                                break;
                        }
                }
-                if (*bh)
+                if (epos->bh)
                {
                        if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
-                                udf_update_tag((*bh)->b_data, loffset);
+                                udf_update_tag(epos->bh->b_data, loffset);
                        else
-                                udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc));
+                                udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
-                        mark_buffer_dirty_inode(*bh, inode);
+                        mark_buffer_dirty_inode(epos->bh, inode);
-                        udf_release_data(*bh);
+                        brelse(epos->bh);
                }
                else
                        mark_inode_dirty(inode);
-                *bh = nbh;
+                epos->bh = nbh;
        }
-        etype = udf_write_aext(inode, *bloc, extoffset, eloc, elen, *bh, inc);
+        etype = udf_write_aext(inode, epos, eloc, elen, inc);
-        if (!*bh)
+        if (!epos->bh)
        {
                UDF_I_LENALLOC(inode) += adsize;
                mark_inode_dirty(inode);
        }
        else
        {
-                aed = (struct allocExtDesc *)(*bh)->b_data;
+                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((*bh)->b_data, *extoffset + (inc ? 0 : adsize));
+                        udf_update_tag(epos->bh->b_data, epos->offset + (inc ? 0 : adsize));
                else
-                        udf_update_tag((*bh)->b_data, sizeof(struct allocExtDesc));
+                        udf_update_tag(epos->bh->b_data, sizeof(struct allocExtDesc));
-                mark_buffer_dirty_inode(*bh, inode);
+                mark_buffer_dirty_inode(epos->bh, inode);
        }
        return etype;
 }
-int8_t udf_write_aext(struct inode *inode, kernel_lb_addr bloc, int *extoffset,
+int8_t udf_write_aext(struct inode *inode, struct extent_position *epos,
-    kernel_lb_addr eloc, uint32_t elen, struct buffer_head *bh, int inc)
+    kernel_lb_addr eloc, uint32_t elen, int inc)
 {
        int adsize;
        uint8_t *ptr;
-        if (!bh)
+        if (!epos->bh)
-                ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
+                ptr = UDF_I_DATA(inode) + epos->offset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(inode);
        else
-        {
+                ptr = epos->bh->b_data + epos->offset;
-                ptr = bh->b_data + *extoffset;
-                atomic_inc(&bh->b_count);
-        }
        switch (UDF_I_ALLOCTYPE(inode))
        {
@@ -1733,40 +1855,39 @@ int8_t udf_write_aext(struct inode *inode, kernel_lb_addr bloc, int *extoffset,
                        return -1;
        }
-        if (bh)
+        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 *)(bh)->b_data;
+                        struct allocExtDesc *aed = (struct allocExtDesc *)epos->bh->b_data;
-                        udf_update_tag((bh)->b_data,
+                        udf_update_tag(epos->bh->b_data,
                                le32_to_cpu(aed->lengthAllocDescs) + sizeof(struct allocExtDesc));
                }
-                mark_buffer_dirty_inode(bh, inode);
+                mark_buffer_dirty_inode(epos->bh, inode);
-                udf_release_data(bh);
        }
        else
                mark_inode_dirty(inode);
        if (inc)
-                *extoffset += adsize;
+                epos->offset += adsize;
        return (elen >> 30);
 }
-int8_t udf_next_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
+int8_t udf_next_aext(struct inode *inode, struct extent_position *epos,
-        kernel_lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc)
+        kernel_lb_addr *eloc, uint32_t *elen, int inc)
 {
        int8_t etype;
-        while ((etype = udf_current_aext(inode, bloc, extoffset, eloc, elen, bh, inc)) ==
+        while ((etype = udf_current_aext(inode, epos, eloc, elen, inc)) ==
                (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
        {
-                *bloc = *eloc;
+                epos->block = *eloc;
-                *extoffset = sizeof(struct allocExtDesc);
+                epos->offset = sizeof(struct allocExtDesc);
-                udf_release_data(*bh);
+                brelse(epos->bh);
-                if (!(*bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, *bloc, 0))))
+                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, *bloc, 0));
+                                udf_get_lb_pblock(inode->i_sb, epos->block, 0));
                        return -1;
                }
        }
@@ -1774,26 +1895,26 @@ int8_t udf_next_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
        return etype;
 }
-int8_t udf_current_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffset,
+int8_t udf_current_aext(struct inode *inode, struct extent_position *epos,
-        kernel_lb_addr *eloc, uint32_t *elen, struct buffer_head **bh, int inc)
+        kernel_lb_addr *eloc, uint32_t *elen, int inc)
 {
        int alen;
        int8_t etype;
        uint8_t *ptr;
-        if (!*bh)
+        if (!epos->bh)
        {
-                if (!(*extoffset))
+                if (!epos->offset)
-                        *extoffset = udf_file_entry_alloc_offset(inode);
+                        epos->offset = udf_file_entry_alloc_offset(inode);
-                ptr = UDF_I_DATA(inode) + *extoffset - udf_file_entry_alloc_offset(inode) + UDF_I_LENEATTR(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);
        }
        else
        {
-                if (!(*extoffset))
+                if (!epos->offset)
-                        *extoffset = sizeof(struct allocExtDesc);
+                        epos->offset = sizeof(struct allocExtDesc);
-                ptr = (*bh)->b_data + *extoffset;
+                ptr = epos->bh->b_data + epos->offset;
-                alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)(*bh)->b_data)->lengthAllocDescs);
+                alen = sizeof(struct allocExtDesc) + le32_to_cpu(((struct allocExtDesc *)epos->bh->b_data)->lengthAllocDescs);
        }
        switch (UDF_I_ALLOCTYPE(inode))
@@ -1802,7 +1923,7 @@ int8_t udf_current_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffse
                {
                        short_ad *sad;
-                        if (!(sad = udf_get_fileshortad(ptr, alen, extoffset, inc)))
+                        if (!(sad = udf_get_fileshortad(ptr, alen, &epos->offset, inc)))
                                return -1;
                        etype = le32_to_cpu(sad->extLength) >> 30;
@@ -1815,7 +1936,7 @@ int8_t udf_current_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffse
                {
                        long_ad *lad;
-                        if (!(lad = udf_get_filelongad(ptr, alen, extoffset, inc)))
+                        if (!(lad = udf_get_filelongad(ptr, alen, &epos->offset, inc)))
                                return -1;
                        etype = le32_to_cpu(lad->extLength) >> 30;
@@ -1834,41 +1955,40 @@ int8_t udf_current_aext(struct inode *inode, kernel_lb_addr *bloc, int *extoffse
 }
 static int8_t
-udf_insert_aext(struct inode *inode, kernel_lb_addr bloc, int extoffset,
+udf_insert_aext(struct inode *inode, struct extent_position epos,
-                kernel_lb_addr neloc, uint32_t nelen, struct buffer_head *bh)
+                kernel_lb_addr neloc, uint32_t nelen)
 {
        kernel_lb_addr oeloc;
        uint32_t oelen;
        int8_t etype;
-        if (bh)
+        if (epos.bh)
-                atomic_inc(&bh->b_count);
+                get_bh(epos.bh);
-        while ((etype = udf_next_aext(inode, &bloc, &extoffset, &oeloc, &oelen, &bh, 0)) != -1)
+        while ((etype = udf_next_aext(inode, &epos, &oeloc, &oelen, 0)) != -1)
        {
-                udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 1);
+                udf_write_aext(inode, &epos, neloc, nelen, 1);
                neloc = oeloc;
                nelen = (etype << 30) | oelen;
        }
-        udf_add_aext(inode, &bloc, &extoffset, neloc, nelen, &bh, 1);
+        udf_add_aext(inode, &epos, neloc, nelen, 1);
-        udf_release_data(bh);
+        brelse(epos.bh);
        return (nelen >> 30);
 }
-int8_t udf_delete_aext(struct inode *inode, kernel_lb_addr nbloc, int nextoffset,
+int8_t udf_delete_aext(struct inode *inode, struct extent_position epos,
-        kernel_lb_addr eloc, uint32_t elen, struct buffer_head *nbh)
+        kernel_lb_addr eloc, uint32_t elen)
 {
-        struct buffer_head *obh;
+        struct extent_position oepos;
-        kernel_lb_addr obloc;
+        int adsize;
-        int oextoffset, adsize;
        int8_t etype;
        struct allocExtDesc *aed;
-        if (nbh)
+        if (epos.bh)
        {
-                atomic_inc(&nbh->b_count);
+                get_bh(epos.bh);
-                atomic_inc(&nbh->b_count);
+                get_bh(epos.bh);
        }
        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
@@ -1878,80 +1998,77 @@ int8_t udf_delete_aext(struct inode *inode, kernel_lb_addr nbloc, int nextoffset
        else
                adsize = 0;
-        obh = nbh;
+        oepos = epos;
-        obloc = nbloc;
+        if (udf_next_aext(inode, &epos, &eloc, &elen, 1) == -1)
-        oextoffset = nextoffset;
-        if (udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1) == -1)
                return -1;
-        while ((etype = udf_next_aext(inode, &nbloc, &nextoffset, &eloc, &elen, &nbh, 1)) != -1)
+        while ((etype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1)
        {
-                udf_write_aext(inode, obloc, &oextoffset, eloc, (etype << 30) | elen, obh, 1);
+                udf_write_aext(inode, &oepos, eloc, (etype << 30) | elen, 1);
-                if (obh != nbh)
+                if (oepos.bh != epos.bh)
                {
-                        obloc = nbloc;
+                        oepos.block = epos.block;
-                        udf_release_data(obh);
+                        brelse(oepos.bh);
-                        atomic_inc(&nbh->b_count);
+                        get_bh(epos.bh);
-                        obh = nbh;
+                        oepos.bh = epos.bh;
-                        oextoffset = nextoffset - adsize;
+                        oepos.offset = epos.offset - adsize;
                }
        }
        memset(&eloc, 0x00, sizeof(kernel_lb_addr));
        elen = 0;
-        if (nbh != obh)
+        if (epos.bh != oepos.bh)
        {
-                udf_free_blocks(inode->i_sb, inode, nbloc, 0, 1);
+                udf_free_blocks(inode->i_sb, inode, epos.block, 0, 1);
-                udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
+                udf_write_aext(inode, &oepos, eloc, elen, 1);
-                udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
+                udf_write_aext(inode, &oepos, eloc, elen, 1);
-                if (!obh)
+                if (!oepos.bh)
                {
                        UDF_I_LENALLOC(inode) -= (adsize * 2);
                        mark_inode_dirty(inode);
                }
                else
                {
-                        aed = (struct allocExtDesc *)(obh)->b_data;
+                        aed = (struct allocExtDesc *)oepos.bh->b_data;
                        aed->lengthAllocDescs =
                                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((obh)->b_data, oextoffset - (2*adsize));
+                                udf_update_tag(oepos.bh->b_data, oepos.offset - (2*adsize));
                        else
-                                udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc));
+                                udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
-                        mark_buffer_dirty_inode(obh, inode);
+                        mark_buffer_dirty_inode(oepos.bh, inode);
                }
        }
        else
        {
-                udf_write_aext(inode, obloc, &oextoffset, eloc, elen, obh, 1);
+                udf_write_aext(inode, &oepos, eloc, elen, 1);
-                if (!obh)
+                if (!oepos.bh)
                {
                        UDF_I_LENALLOC(inode) -= adsize;
                        mark_inode_dirty(inode);
                }
                else
                {
-                        aed = (struct allocExtDesc *)(obh)->b_data;
+                        aed = (struct allocExtDesc *)oepos.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((obh)->b_data, oextoffset - adsize);
+                                udf_update_tag(oepos.bh->b_data, epos.offset - adsize);
                        else
-                                udf_update_tag((obh)->b_data, sizeof(struct allocExtDesc));
+                                udf_update_tag(oepos.bh->b_data, sizeof(struct allocExtDesc));
-                        mark_buffer_dirty_inode(obh, inode);
+                        mark_buffer_dirty_inode(oepos.bh, inode);
                }
        }
        
-        udf_release_data(nbh);
+        brelse(epos.bh);
-        udf_release_data(obh);
+        brelse(oepos.bh);
        return (elen >> 30);
 }
-int8_t inode_bmap(struct inode *inode, int block, kernel_lb_addr *bloc, uint32_t *extoffset,
+int8_t inode_bmap(struct inode *inode, sector_t block, struct extent_position *pos,
-        kernel_lb_addr *eloc, uint32_t *elen, uint32_t *offset, struct buffer_head **bh)
+        kernel_lb_addr *eloc, uint32_t *elen, sector_t *offset)
 {
-        uint64_t lbcount = 0, bcount = (uint64_t)block << inode->i_sb->s_blocksize_bits;
+        loff_t lbcount = 0, bcount = (loff_t)block << inode->i_sb->s_blocksize_bits;
        int8_t etype;
        if (block < 0)
@@ -1960,42 +2077,44 @@ int8_t inode_bmap(struct inode *inode, int block, kernel_lb_addr *bloc, uint32_t
                return -1;
        }
-        *extoffset = 0;
+        pos->offset = 0;
+        pos->block = UDF_I_LOCATION(inode);
+        pos->bh = NULL;
        *elen = 0;
-        *bloc = UDF_I_LOCATION(inode);
        do
        {
-                if ((etype = udf_next_aext(inode, bloc, extoffset, eloc, elen, bh, 1)) == -1)
+                if ((etype = udf_next_aext(inode, pos, eloc, elen, 1)) == -1)
                {
-                        *offset = bcount - lbcount;
+                        *offset = (bcount - lbcount) >> inode->i_sb->s_blocksize_bits;
                        UDF_I_LENEXTENTS(inode) = lbcount;
                        return -1;
                }
                lbcount += *elen;
        } while (lbcount <= bcount);
-        *offset = bcount + *elen - lbcount;
+        *offset = (bcount + *elen - lbcount) >> inode->i_sb->s_blocksize_bits;
        return etype;
 }
-long udf_block_map(struct inode *inode, long block)
+long udf_block_map(struct inode *inode, sector_t block)
 {
-        kernel_lb_addr eloc, bloc;
+        kernel_lb_addr eloc;
-        uint32_t offset, extoffset, elen;
+        uint32_t elen;
-        struct buffer_head *bh = NULL;
+        sector_t offset;
+        struct extent_position epos = { NULL, 0, { 0, 0}};
        int ret;
        lock_kernel();
-        if (inode_bmap(inode, block, &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (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 >> inode->i_sb->s_blocksize_bits);
+                ret = udf_get_lb_pblock(inode->i_sb, eloc, offset);
        else
                ret = 0;
        unlock_kernel();
-        udf_release_data(bh);
+        brelse(epos.bh);
        if (UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_VARCONV))
                return udf_fixed_to_variable(ret);
diff --git a/fs/udf/misc.c b/fs/udf/misc.c
index cc8ca3254db1..a2b2a98ce78a 100644
--- a/fs/udf/misc.c
+++ b/fs/udf/misc.c
@@ -274,12 +274,6 @@ udf_read_ptagged(struct super_block *sb, kernel_lb_addr loc, uint32_t offset, ui
                loc.logicalBlockNum + offset, ident);
 }
-void udf_release_data(struct buffer_head *bh)
-{
-        if (bh)
-                brelse(bh);
-}
 void udf_update_tag(char *data, int length)
 {
        tag *tptr = (tag *)data;
diff --git a/fs/udf/namei.c b/fs/udf/namei.c
index fe361cd19a98..91df4928651c 100644
--- a/fs/udf/namei.c
+++ b/fs/udf/namei.c
@@ -155,9 +155,10 @@ udf_find_entry(struct inode *dir, struct dentry *dentry,
        uint8_t lfi;
        uint16_t liu;
        loff_t size;
-        kernel_lb_addr bloc, eloc;
+        kernel_lb_addr eloc;
-        uint32_t extoffset, elen, offset;
+        uint32_t elen;
-        struct buffer_head *bh = NULL;
+        sector_t offset;
+        struct extent_position epos = { NULL, 0, { 0, 0}};
        size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
        f_pos = (udf_ext0_offset(dir) >> 2);
@@ -166,42 +167,41 @@ udf_find_entry(struct inode *dir, struct dentry *dentry,
        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
                fibh->sbh = fibh->ebh = NULL;
        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
+                &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
        {
-                offset >>= dir->i_sb->s_blocksize_bits;
                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)
-                                extoffset -= sizeof(short_ad);
+                                epos.offset -= sizeof(short_ad);
                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
-                                extoffset -= sizeof(long_ad);
+                                epos.offset -= sizeof(long_ad);
                }
                else
                        offset = 0;
                if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
                {
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        return NULL;
                }
        }
        else
        {
-                udf_release_data(bh);
+                brelse(epos.bh);
                return NULL;
        }
        while ( (f_pos < size) )
        {
-                fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
+                fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset);
                if (!fi)
                {
                        if (fibh->sbh != fibh->ebh)
-                                udf_release_data(fibh->ebh);
+                                brelse(fibh->ebh);
-                        udf_release_data(fibh->sbh);
+                        brelse(fibh->sbh);
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        return NULL;
                }
@@ -247,15 +247,15 @@ udf_find_entry(struct inode *dir, struct dentry *dentry,
                {
                        if (udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name))
                        {
-                                udf_release_data(bh);
+                                brelse(epos.bh);
                                return fi;
                        }
                }
        }
        if (fibh->sbh != fibh->ebh)
-                udf_release_data(fibh->ebh);
+                brelse(fibh->ebh);
-        udf_release_data(fibh->sbh);
+        brelse(fibh->sbh);
-        udf_release_data(bh);
+        brelse(epos.bh);
        return NULL;
 }
@@ -321,8 +321,8 @@ udf_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
        if (udf_find_entry(dir, dentry, &fibh, &cfi))
        {
                if (fibh.sbh != fibh.ebh)
-                        udf_release_data(fibh.ebh);
+                        brelse(fibh.ebh);
-                udf_release_data(fibh.sbh);
+                brelse(fibh.sbh);
                inode = udf_iget(dir->i_sb, lelb_to_cpu(cfi.icb.extLocation));
                if ( !inode )
@@ -353,9 +353,10 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
        uint8_t lfi;
        uint16_t liu;
        int block;
-        kernel_lb_addr bloc, eloc;
+        kernel_lb_addr eloc;
-        uint32_t extoffset, elen, offset;
+        uint32_t elen;
-        struct buffer_head *bh = NULL;
+        sector_t offset;
+        struct extent_position epos = { NULL, 0, { 0, 0 }};
        sb = dir->i_sb;
@@ -384,23 +385,22 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
                fibh->sbh = fibh->ebh = NULL;
        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
+                &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
        {
-                offset >>= dir->i_sb->s_blocksize_bits;
                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)
-                                extoffset -= sizeof(short_ad);
+                                epos.offset -= sizeof(short_ad);
                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
-                                extoffset -= sizeof(long_ad);
+                                epos.offset -= sizeof(long_ad);
                }
                else
                        offset = 0;
                if (!(fibh->sbh = fibh->ebh = udf_tread(dir->i_sb, block)))
                {
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        *err = -EIO;
                        return NULL;
                }
@@ -418,14 +418,14 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
        while ( (f_pos < size) )
        {
-                fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
+                fi = udf_fileident_read(dir, &f_pos, fibh, cfi, &epos, &eloc, &elen, &offset);
                if (!fi)
                {
                        if (fibh->sbh != fibh->ebh)
-                                udf_release_data(fibh->ebh);
+                                brelse(fibh->ebh);
-                        udf_release_data(fibh->sbh);
+                        brelse(fibh->sbh);
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        *err = -EIO;
                        return NULL;
                }
@@ -455,7 +455,7 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
                {
                        if (((sizeof(struct fileIdentDesc) + liu + lfi + 3) & ~3) == nfidlen)
                        {
-                                udf_release_data(bh);
+                                brelse(epos.bh);
                                cfi->descTag.tagSerialNum = cpu_to_le16(1);
                                cfi->fileVersionNum = cpu_to_le16(1);
                                cfi->fileCharacteristics = 0;
@@ -478,9 +478,9 @@ udf_add_entry(struct inode *dir, struct dentry *dentry,
                        udf_match(flen, fname, dentry->d_name.len, dentry->d_name.name))
                {
                        if (fibh->sbh != fibh->ebh)
-                                udf_release_data(fibh->ebh);
+                                brelse(fibh->ebh);
-                        udf_release_data(fibh->sbh);
+                        brelse(fibh->sbh);
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        *err = -EEXIST;
                        return NULL;
                }
@@ -492,25 +492,25 @@ add:
        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB &&
                sb->s_blocksize - fibh->eoffset < nfidlen)
        {
-                udf_release_data(bh);
+                brelse(epos.bh);
-                bh = NULL;
+                epos.bh = NULL;
                fibh->soffset -= udf_ext0_offset(dir);
                fibh->eoffset -= udf_ext0_offset(dir);
                f_pos -= (udf_ext0_offset(dir) >> 2);
                if (fibh->sbh != fibh->ebh)
-                        udf_release_data(fibh->ebh);
+                        brelse(fibh->ebh);
-                udf_release_data(fibh->sbh);
+                brelse(fibh->sbh);
                if (!(fibh->sbh = fibh->ebh = udf_expand_dir_adinicb(dir, &block, err)))
                        return NULL;
-                bloc = UDF_I_LOCATION(dir);
+                epos.block = UDF_I_LOCATION(dir);
                eloc.logicalBlockNum = block;
                eloc.partitionReferenceNum = UDF_I_LOCATION(dir).partitionReferenceNum;
                elen = dir->i_sb->s_blocksize;
-                extoffset = udf_file_entry_alloc_offset(dir);
+                epos.offset = udf_file_entry_alloc_offset(dir);
                if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_SHORT)
-                        extoffset += sizeof(short_ad);
+                        epos.offset += sizeof(short_ad);
                else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
-                        extoffset += sizeof(long_ad);
+                        epos.offset += sizeof(long_ad);
        }
        if (sb->s_blocksize - fibh->eoffset >= nfidlen)
@@ -519,7 +519,7 @@ add:
                fibh->eoffset += nfidlen;
                if (fibh->sbh != fibh->ebh)
                {
-                        udf_release_data(fibh->sbh);
+                        brelse(fibh->sbh);
                        fibh->sbh = fibh->ebh;
                }
@@ -541,7 +541,7 @@ add:
                fibh->eoffset += nfidlen - sb->s_blocksize;
                if (fibh->sbh != fibh->ebh)
                {
-                        udf_release_data(fibh->sbh);
+                        brelse(fibh->sbh);
                        fibh->sbh = fibh->ebh;
                }
@@ -550,14 +550,14 @@ add:
                if (!(fibh->ebh = udf_bread(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2), 1, err)))
                {
-                        udf_release_data(bh);
+                        brelse(epos.bh);
-                        udf_release_data(fibh->sbh);
+                        brelse(fibh->sbh);
                        return NULL;
                }
                if (!(fibh->soffset))
                {
-                        if (udf_next_aext(dir, &bloc, &extoffset, &eloc, &elen, &bh, 1) ==
+                        if (udf_next_aext(dir, &epos, &eloc, &elen, 1) ==
                                (EXT_RECORDED_ALLOCATED >> 30))
                        {
                                block = eloc.logicalBlockNum + ((elen - 1) >>
@@ -566,7 +566,7 @@ add:
                        else
                                block ++;
-                        udf_release_data(fibh->sbh);
+                        brelse(fibh->sbh);
                        fibh->sbh = fibh->ebh;
                        fi = (struct fileIdentDesc *)(fibh->sbh->b_data);
                }
@@ -587,7 +587,7 @@ add:
        cfi->lengthOfImpUse = cpu_to_le16(0);
        if (!udf_write_fi(dir, cfi, fi, fibh, NULL, name))
        {
-                udf_release_data(bh);
+                brelse(epos.bh);
                dir->i_size += nfidlen;
                if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
                        UDF_I_LENALLOC(dir) += nfidlen;
@@ -596,10 +596,10 @@ add:
        }
        else
        {
-                udf_release_data(bh);
+                brelse(epos.bh);
                if (fibh->sbh != fibh->ebh)
-                        udf_release_data(fibh->ebh);
+                        brelse(fibh->ebh);
-                udf_release_data(fibh->sbh);
+                brelse(fibh->sbh);
                *err = -EIO;
                return NULL;
        }
@@ -656,8 +656,8 @@ static int udf_create(struct inode *dir, struct dentry *dentry, int mode, struct
                mark_inode_dirty(dir);
        }
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
        unlock_kernel();
        d_instantiate(dentry, inode);
        return 0;
@@ -701,8 +701,8 @@ static int udf_mknod(struct inode * dir, struct dentry * dentry, int mode, dev_t
        mark_inode_dirty(inode);
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
        d_instantiate(dentry, inode);
        err = 0;
 out:
@@ -743,7 +743,7 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
                cpu_to_le32(UDF_I_UNIQUE(dir) & 0x00000000FFFFFFFFUL);
        cfi.fileCharacteristics = FID_FILE_CHAR_DIRECTORY | FID_FILE_CHAR_PARENT;
        udf_write_fi(inode, &cfi, fi, &fibh, NULL, NULL);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
        inode->i_mode = S_IFDIR | mode;
        if (dir->i_mode & S_ISGID)
                inode->i_mode |= S_ISGID;
@@ -766,8 +766,8 @@ static int udf_mkdir(struct inode * dir, struct dentry * dentry, int mode)
        mark_inode_dirty(dir);
        d_instantiate(dentry, inode);
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
        err = 0;
 out:
        unlock_kernel();
@@ -781,9 +781,10 @@ static int empty_dir(struct inode *dir)
        loff_t f_pos;
        loff_t size = (udf_ext0_offset(dir) + dir->i_size) >> 2;
        int block;
-        kernel_lb_addr bloc, eloc;
+        kernel_lb_addr eloc;
-        uint32_t extoffset, elen, offset;
+        uint32_t elen;
-        struct buffer_head *bh = NULL;
+        sector_t offset;
+        struct extent_position epos = { NULL, 0, { 0, 0}};
        f_pos = (udf_ext0_offset(dir) >> 2);
@@ -792,59 +793,58 @@ static int empty_dir(struct inode *dir)
        if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_IN_ICB)
                fibh.sbh = fibh.ebh = NULL;
        else if (inode_bmap(dir, f_pos >> (dir->i_sb->s_blocksize_bits - 2),
-                &bloc, &extoffset, &eloc, &elen, &offset, &bh) == (EXT_RECORDED_ALLOCATED >> 30))
+                &epos, &eloc, &elen, &offset) == (EXT_RECORDED_ALLOCATED >> 30))
        {
-                offset >>= dir->i_sb->s_blocksize_bits;
                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)
-                                extoffset -= sizeof(short_ad);
+                                epos.offset -= sizeof(short_ad);
                        else if (UDF_I_ALLOCTYPE(dir) == ICBTAG_FLAG_AD_LONG)
-                                extoffset -= sizeof(long_ad);
+                                epos.offset -= sizeof(long_ad);
                }
                else
                        offset = 0;
                if (!(fibh.sbh = fibh.ebh = udf_tread(dir->i_sb, block)))
                {
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        return 0;
                }
        }
        else
        {
-                udf_release_data(bh);
+                brelse(epos.bh);
                return 0;
        }
        while ( (f_pos < size) )
        {
-                fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
+                fi = udf_fileident_read(dir, &f_pos, &fibh, &cfi, &epos, &eloc, &elen, &offset);
                if (!fi)
                {
                        if (fibh.sbh != fibh.ebh)
-                                udf_release_data(fibh.ebh);
+                                brelse(fibh.ebh);
-                        udf_release_data(fibh.sbh);
+                        brelse(fibh.sbh);
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        return 0;
                }
                if (cfi.lengthFileIdent && (cfi.fileCharacteristics & FID_FILE_CHAR_DELETED) == 0)
                {
                        if (fibh.sbh != fibh.ebh)
-                                udf_release_data(fibh.ebh);
+                                brelse(fibh.ebh);
-                        udf_release_data(fibh.sbh);
+                        brelse(fibh.sbh);
-                        udf_release_data(bh);
+                        brelse(epos.bh);
                        return 0;
                }
        }
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
-        udf_release_data(bh);
+        brelse(epos.bh);
        return 1;
 }
@@ -878,14 +878,14 @@ static int udf_rmdir(struct inode * dir, struct dentry * dentry)
                        inode->i_nlink);
        clear_nlink(inode);
        inode->i_size = 0;
-        inode_dec_link_count(inode);
+        inode_dec_link_count(dir);
        inode->i_ctime = dir->i_ctime = dir->i_mtime = current_fs_time(dir->i_sb);
        mark_inode_dirty(dir);
 end_rmdir:
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
 out:
        unlock_kernel();
        return retval;
@@ -928,8 +928,8 @@ static int udf_unlink(struct inode * dir, struct dentry * dentry)
 end_unlink:
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
 out:
        unlock_kernel();
        return retval;
@@ -941,7 +941,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
        struct pathComponent *pc;
        char *compstart;
        struct udf_fileident_bh fibh;
-        struct buffer_head *bh = NULL;
+        struct extent_position epos = { NULL,  0, {0, 0}};
        int eoffset, elen = 0;
        struct fileIdentDesc *fi;
        struct fileIdentDesc cfi;
@@ -961,33 +961,33 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
        if (UDF_I_ALLOCTYPE(inode) != ICBTAG_FLAG_AD_IN_ICB)
        {
-                struct buffer_head *bh = NULL;
+                kernel_lb_addr eloc;
-                kernel_lb_addr bloc, eloc;
+                uint32_t elen;
-                uint32_t elen, extoffset;
                block = udf_new_block(inode->i_sb, inode,
                        UDF_I_LOCATION(inode).partitionReferenceNum,
                        UDF_I_LOCATION(inode).logicalBlockNum, &err);
                if (!block)
                        goto out_no_entry;
-                bloc = UDF_I_LOCATION(inode);
+                epos.block = UDF_I_LOCATION(inode);
+                epos.offset = udf_file_entry_alloc_offset(inode);
+                epos.bh = NULL;
                eloc.logicalBlockNum = block;
                eloc.partitionReferenceNum = UDF_I_LOCATION(inode).partitionReferenceNum;
                elen = inode->i_sb->s_blocksize;
                UDF_I_LENEXTENTS(inode) = elen;
-                extoffset = udf_file_entry_alloc_offset(inode);
+                udf_add_aext(inode, &epos, eloc, elen, 0);
-                udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 0);
+                brelse(epos.bh);
-                udf_release_data(bh);
                block = udf_get_pblock(inode->i_sb, block,
                        UDF_I_LOCATION(inode).partitionReferenceNum, 0);
-                bh = udf_tread(inode->i_sb, block);
+                epos.bh = udf_tread(inode->i_sb, block);
-                lock_buffer(bh);
+                lock_buffer(epos.bh);
-                memset(bh->b_data, 0x00, inode->i_sb->s_blocksize);
+                memset(epos.bh->b_data, 0x00, inode->i_sb->s_blocksize);
-                set_buffer_uptodate(bh);
+                set_buffer_uptodate(epos.bh);
-                unlock_buffer(bh);
+                unlock_buffer(epos.bh);
-                mark_buffer_dirty_inode(bh, inode);
+                mark_buffer_dirty_inode(epos.bh, inode);
-                ea = bh->b_data + udf_ext0_offset(inode);
+                ea = epos.bh->b_data + udf_ext0_offset(inode);
        }
        else
                ea = UDF_I_DATA(inode) + UDF_I_LENEATTR(inode);
@@ -1060,7 +1060,7 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
                }
        }
-        udf_release_data(bh);
+        brelse(epos.bh);
        inode->i_size = elen;
        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB)
                UDF_I_LENALLOC(inode) = inode->i_size;
@@ -1089,8 +1089,8 @@ static int udf_symlink(struct inode * dir, struct dentry * dentry, const char *
                mark_inode_dirty(dir);
        }
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
        d_instantiate(dentry, inode);
        err = 0;
@@ -1145,8 +1145,8 @@ static int udf_link(struct dentry * old_dentry, struct inode * dir,
                mark_inode_dirty(dir);
        }
        if (fibh.sbh != fibh.ebh)
-                udf_release_data(fibh.ebh);
+                brelse(fibh.ebh);
-        udf_release_data(fibh.sbh);
+        brelse(fibh.sbh);
        inc_nlink(inode);
        inode->i_ctime = current_fs_time(inode->i_sb);
        mark_inode_dirty(inode);
@@ -1174,8 +1174,8 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
        if ((ofi = udf_find_entry(old_dir, old_dentry, &ofibh, &ocfi)))
        {
                if (ofibh.sbh != ofibh.ebh)
-                        udf_release_data(ofibh.ebh);
+                        brelse(ofibh.ebh);
-                udf_release_data(ofibh.sbh);
+                brelse(ofibh.sbh);
        }
        tloc = lelb_to_cpu(ocfi.icb.extLocation);
        if (!ofi || udf_get_lb_pblock(old_dir->i_sb, tloc, 0)
@@ -1188,8 +1188,8 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
                if (!new_inode)
                {
                        if (nfibh.sbh != nfibh.ebh)
-                                udf_release_data(nfibh.ebh);
+                                brelse(nfibh.ebh);
-                        udf_release_data(nfibh.sbh);
+                        brelse(nfibh.sbh);
                        nfi = NULL;
                }
        }
@@ -1290,19 +1290,19 @@ static int udf_rename (struct inode * old_dir, struct dentry * old_dentry,
        if (ofi)
        {
                if (ofibh.sbh != ofibh.ebh)
-                        udf_release_data(ofibh.ebh);
+                        brelse(ofibh.ebh);
-                udf_release_data(ofibh.sbh);
+                brelse(ofibh.sbh);
        }
        retval = 0;
 end_rename:
-        udf_release_data(dir_bh);
+        brelse(dir_bh);
        if (nfi)
        {
                if (nfibh.sbh != nfibh.ebh)
-                        udf_release_data(nfibh.ebh);
+                        brelse(nfibh.ebh);
-                udf_release_data(nfibh.sbh);
+                brelse(nfibh.sbh);
        }
        unlock_kernel();
        return retval;
diff --git a/fs/udf/partition.c b/fs/udf/partition.c
index dabf2b841db8..467a26171cd9 100644
--- a/fs/udf/partition.c
+++ b/fs/udf/partition.c
@@ -81,7 +81,7 @@ uint32_t udf_get_pblock_virt15(struct super_block *sb, uint32_t block, uint16_t
        loc = le32_to_cpu(((__le32 *)bh->b_data)[index]);
-        udf_release_data(bh);
+        brelse(bh);
        if (UDF_I_LOCATION(UDF_SB_VAT(sb)).partitionReferenceNum == partition)
        {
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 023b304fdd99..9b8644a06e53 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -563,7 +563,7 @@ udf_vrs(struct super_block *sb, int silent)
                if (vsd->stdIdent[0] == 0)
                {
-                        udf_release_data(bh);
+                        brelse(bh);
                        break;
                }
                else if (!strncmp(vsd->stdIdent, VSD_STD_ID_CD001, VSD_STD_ID_LEN))
@@ -596,7 +596,7 @@ udf_vrs(struct super_block *sb, int silent)
                }
                else if (!strncmp(vsd->stdIdent, VSD_STD_ID_TEA01, VSD_STD_ID_LEN))
                {
-                        udf_release_data(bh);
+                        brelse(bh);
                        break;
                }
                else if (!strncmp(vsd->stdIdent, VSD_STD_ID_NSR02, VSD_STD_ID_LEN))
@@ -607,7 +607,7 @@ udf_vrs(struct super_block *sb, int silent)
                {
                        nsr03 = sector;
                }
-                udf_release_data(bh);
+                brelse(bh);
        }
        if (nsr03)
@@ -673,7 +673,7 @@ udf_find_anchor(struct super_block *sb)
                        {
                                ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
                                location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
-                                udf_release_data(bh);
+                                brelse(bh);
                        }
                        if (ident == TAG_IDENT_AVDP)
@@ -708,7 +708,7 @@ udf_find_anchor(struct super_block *sb)
                                {
                                        ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
                                        location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
-                                        udf_release_data(bh);
+                                        brelse(bh);
                                }
        
                                if (ident == TAG_IDENT_AVDP &&
@@ -727,7 +727,7 @@ udf_find_anchor(struct super_block *sb)
                                        {
                                                ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
                                                location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
-                                                udf_release_data(bh);
+                                                brelse(bh);
                                        }
        
                                        if (ident == TAG_IDENT_AVDP &&
@@ -749,7 +749,7 @@ udf_find_anchor(struct super_block *sb)
                {
                        ident = le16_to_cpu(((tag *)bh->b_data)->tagIdent);
                        location = le32_to_cpu(((tag *)bh->b_data)->tagLocation);
-                        udf_release_data(bh);
+                        brelse(bh);
                        if (ident == TAG_IDENT_AVDP && location == 256)
                                UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
@@ -766,7 +766,7 @@ udf_find_anchor(struct super_block *sb)
                        }
                        else
                        {
-                                udf_release_data(bh);
+                                brelse(bh);
                                if ((ident != TAG_IDENT_AVDP) && (i ||
                                        (ident != TAG_IDENT_FE && ident != TAG_IDENT_EFE)))
                                {
@@ -795,7 +795,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr
                        return 1;
                else if (ident != TAG_IDENT_FSD)
                {
-                        udf_release_data(bh);
+                        brelse(bh);
                        return 1;
                }
                        
@@ -834,7 +834,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr
                                                newfileset.logicalBlockNum += 1 +
                                                        ((le32_to_cpu(sp->numOfBytes) + sizeof(struct spaceBitmapDesc) - 1)
                                                                >> sb->s_blocksize_bits);
-                                                udf_release_data(bh);
+                                                brelse(bh);
                                                break;
                                        }
                                        case TAG_IDENT_FSD:
@@ -845,7 +845,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr
                                        default:
                                        {
                                                newfileset.logicalBlockNum ++;
-                                                udf_release_data(bh);
+                                                brelse(bh);
                                                bh = NULL;
                                                break;
                                        }
@@ -865,7 +865,7 @@ udf_find_fileset(struct super_block *sb, kernel_lb_addr *fileset, kernel_lb_addr
                UDF_SB_PARTITION(sb) = fileset->partitionReferenceNum;
                udf_load_fileset(sb, bh, root);
-                udf_release_data(bh);
+                brelse(bh);
                return 0;
        }
        return 1;
@@ -1083,7 +1083,7 @@ udf_load_logicalvol(struct super_block *sb, struct buffer_head * bh, kernel_lb_a
                                                if (ident != 0 ||
                                                        strncmp(st->sparingIdent.ident, UDF_ID_SPARING, strlen(UDF_ID_SPARING)))
                                                {
-                                                        udf_release_data(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
+                                                        brelse(UDF_SB_TYPESPAR(sb,i).s_spar_map[j]);
                                                        UDF_SB_TYPESPAR(sb,i).s_spar_map[j] = NULL;
                                                }
                                        }
@@ -1137,12 +1137,12 @@ udf_load_logicalvolint(struct super_block *sb, kernel_extent_ad loc)
                        udf_load_logicalvolint(sb, leea_to_cpu(UDF_SB_LVID(sb)->nextIntegrityExt));
                
                if (UDF_SB_LVIDBH(sb) != bh)
-                        udf_release_data(bh);
+                        brelse(bh);
                loc.extLength -= sb->s_blocksize;
                loc.extLocation ++;
        }
        if (UDF_SB_LVIDBH(sb) != bh)
-                udf_release_data(bh);
+                brelse(bh);
 }
 /*
@@ -1245,7 +1245,7 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_
                                        done = 1;
                                break;
                }
-                udf_release_data(bh);
+                brelse(bh);
        }
        for (i=0; i<VDS_POS_LENGTH; i++)
        {
@@ -1267,10 +1267,10 @@ udf_process_sequence(struct super_block *sb, long block, long lastblock, kernel_
                                        gd = (struct generic_desc *)bh2->b_data;
                                        if (ident == TAG_IDENT_PD)
                                                udf_load_partdesc(sb, bh2);
-                                        udf_release_data(bh2);
+                                        brelse(bh2);
                                }
                        }
-                        udf_release_data(bh);
+                        brelse(bh);
                }
        }
@@ -1333,7 +1333,7 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
                        reserve_e = reserve_e >> sb->s_blocksize_bits;
                        reserve_e += reserve_s;
-                        udf_release_data(bh);
+                        brelse(bh);
                        /* Process the main & reserve sequences */
                        /* responsible for finding the PartitionDesc(s) */
@@ -1403,12 +1403,14 @@ udf_load_partition(struct super_block *sb, kernel_lb_addr *fileset)
                                        pos = udf_block_map(UDF_SB_VAT(sb), 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;
-                                        udf_release_data(bh);
+                                        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);
@@ -1661,7 +1663,7 @@ static int udf_fill_super(struct super_block *sb, void *options, int silent)
                iput(inode);
                goto error_out;
        }
-        sb->s_maxbytes = 1<<30;
+        sb->s_maxbytes = MAX_LFS_FILESIZE;
        return 0;
 error_out:
@@ -1680,7 +1682,7 @@ error_out:
                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
                {
                        for (i=0; i<4; i++)
-                                udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
+                                brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
                }
        }
 #ifdef CONFIG_UDF_NLS
@@ -1689,7 +1691,7 @@ error_out:
 #endif
        if (!(sb->s_flags & MS_RDONLY))
                udf_close_lvid(sb);
-        udf_release_data(UDF_SB_LVIDBH(sb));
+        brelse(UDF_SB_LVIDBH(sb));
        UDF_SB_FREE(sb);
        kfree(sbi);
        sb->s_fs_info = NULL;
@@ -1758,7 +1760,7 @@ udf_put_super(struct super_block *sb)
                if (UDF_SB_PARTTYPE(sb, UDF_SB_PARTITION(sb)) == UDF_SPARABLE_MAP15)
                {
                        for (i=0; i<4; i++)
-                                udf_release_data(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
+                                brelse(UDF_SB_TYPESPAR(sb, UDF_SB_PARTITION(sb)).s_spar_map[i]);
                }
        }
 #ifdef CONFIG_UDF_NLS
@@ -1767,7 +1769,7 @@ udf_put_super(struct super_block *sb)
 #endif
        if (!(sb->s_flags & MS_RDONLY))
                udf_close_lvid(sb);
-        udf_release_data(UDF_SB_LVIDBH(sb));
+        brelse(UDF_SB_LVIDBH(sb));
        UDF_SB_FREE(sb);
        kfree(sb->s_fs_info);
        sb->s_fs_info = NULL;
@@ -1837,7 +1839,7 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
        }
        else if (ident != TAG_IDENT_SBD)
        {
-                udf_release_data(bh);
+                brelse(bh);
                printk(KERN_ERR "udf: udf_count_free failed\n");
                goto out;
        }
@@ -1859,7 +1861,7 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
                }
                if ( bytes )
                {
-                        udf_release_data(bh);
+                        brelse(bh);
                        newblock = udf_get_lb_pblock(sb, loc, ++block);
                        bh = udf_tread(sb, newblock);
                        if (!bh)
@@ -1871,7 +1873,7 @@ udf_count_free_bitmap(struct super_block *sb, struct udf_bitmap *bitmap)
                        ptr = (uint8_t *)bh->b_data;
                }
        }
-        udf_release_data(bh);
+        brelse(bh);
 out:
        unlock_kernel();
@@ -1883,21 +1885,20 @@ static unsigned int
 udf_count_free_table(struct super_block *sb, struct inode * table)
 {
        unsigned int accum = 0;
-        uint32_t extoffset, elen;
+        uint32_t elen;
-        kernel_lb_addr bloc, eloc;
+        kernel_lb_addr eloc;
        int8_t etype;
-        struct buffer_head *bh = NULL;
+        struct extent_position epos;
        lock_kernel();
-        bloc = UDF_I_LOCATION(table);
+        epos.block = UDF_I_LOCATION(table);
-        extoffset = sizeof(struct unallocSpaceEntry);
+        epos.offset = sizeof(struct unallocSpaceEntry);
+        epos.bh = NULL;
-        while ((etype = udf_next_aext(table, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
+        while ((etype = udf_next_aext(table, &epos, &eloc, &elen, 1)) != -1)
-        {
                accum += (elen >> table->i_sb->s_blocksize_bits);
-        }
+        brelse(epos.bh);
-        udf_release_data(bh);
        unlock_kernel();
diff --git a/fs/udf/symlink.c b/fs/udf/symlink.c
index ba068a786563..12613b680cc4 100644
--- a/fs/udf/symlink.c
+++ b/fs/udf/symlink.c
@@ -95,7 +95,7 @@ static int udf_symlink_filler(struct file *file, struct page *page)
        }
        udf_pc_to_char(inode->i_sb, symlink, inode->i_size, p);
-        udf_release_data(bh);
+        brelse(bh);
        unlock_kernel();
        SetPageUptodate(page);
diff --git a/fs/udf/truncate.c b/fs/udf/truncate.c
index 0abd66ce36ea..77975ae291a5 100644
--- a/fs/udf/truncate.c
+++ b/fs/udf/truncate.c
@@ -28,8 +28,8 @@
 #include "udf_i.h"
 #include "udf_sb.h"
-static void extent_trunc(struct inode * inode, kernel_lb_addr bloc, int extoffset,
+static void extent_trunc(struct inode * inode, struct extent_position *epos,
-        kernel_lb_addr eloc, int8_t etype, uint32_t elen, struct buffer_head *bh, uint32_t nelen)
+        kernel_lb_addr eloc, int8_t etype, uint32_t elen, uint32_t nelen)
 {
        kernel_lb_addr neloc = { 0, 0 };
        int last_block = (elen + inode->i_sb->s_blocksize - 1) >> inode->i_sb->s_blocksize_bits;
@@ -49,7 +49,7 @@ static void extent_trunc(struct inode * inode, kernel_lb_addr bloc, int extoffse
        if (elen != nelen)
        {
-                udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 0);
+                udf_write_aext(inode, epos, neloc, nelen, 0);
                if (last_block - first_block > 0)
                {
                        if (etype == (EXT_RECORDED_ALLOCATED >> 30))
@@ -63,18 +63,16 @@ static void extent_trunc(struct inode * inode, kernel_lb_addr bloc, int extoffse
 void udf_discard_prealloc(struct inode * inode)
 {
-        kernel_lb_addr bloc, eloc;
+        struct extent_position epos = { NULL, 0, {0, 0}};
-        uint32_t extoffset = 0, elen, nelen;
+        kernel_lb_addr eloc;
+        uint32_t elen, nelen;
        uint64_t lbcount = 0;
        int8_t etype = -1, netype;
-        struct buffer_head *bh = NULL;
        int adsize;
        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_IN_ICB ||
                inode->i_size == UDF_I_LENEXTENTS(inode))
-        {
                return;
-        }
        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
                adsize = sizeof(short_ad);
@@ -83,52 +81,58 @@ void udf_discard_prealloc(struct inode * inode)
        else
                adsize = 0;
-        bloc = UDF_I_LOCATION(inode);
+        epos.block = UDF_I_LOCATION(inode);
-        while ((netype = udf_next_aext(inode, &bloc, &extoffset, &eloc, &elen, &bh, 1)) != -1)
+        /* Find the last extent in the file */
+        while ((netype = udf_next_aext(inode, &epos, &eloc, &elen, 1)) != -1)
        {
                etype = netype;
                lbcount += elen;
-                if (lbcount > inode->i_size && lbcount - inode->i_size < inode->i_sb->s_blocksize)
+                if (lbcount > inode->i_size && lbcount - elen < inode->i_size)
                {
+                        WARN_ON(lbcount - inode->i_size >= inode->i_sb->s_blocksize);
                        nelen = elen - (lbcount - inode->i_size);
-                        extent_trunc(inode, bloc, extoffset-adsize, eloc, etype, elen, bh, nelen);
+                        epos.offset -= adsize;
+                        extent_trunc(inode, &epos, eloc, etype, elen, nelen);
+                        epos.offset += adsize;
                        lbcount = inode->i_size;
                }
        }
-        if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
+        if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30)) {
-        {
+                epos.offset -= adsize;
-                extoffset -= adsize;
                lbcount -= elen;
-                extent_trunc(inode, bloc, extoffset, eloc, etype, elen, bh, 0);
+                extent_trunc(inode, &epos, eloc, etype, elen, 0);
-                if (!bh)
+                if (!epos.bh)
                {
-                        UDF_I_LENALLOC(inode) = extoffset - udf_file_entry_alloc_offset(inode);
+                        UDF_I_LENALLOC(inode) = epos.offset - udf_file_entry_alloc_offset(inode);
                        mark_inode_dirty(inode);
                }
                else
                {
-                        struct allocExtDesc *aed = (struct allocExtDesc *)(bh->b_data);
+                        struct allocExtDesc *aed = (struct allocExtDesc *)(epos.bh->b_data);
-                        aed->lengthAllocDescs = cpu_to_le32(extoffset - sizeof(struct allocExtDesc));
+                        aed->lengthAllocDescs = 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_update_tag(bh->b_data, extoffset);
+                                udf_update_tag(epos.bh->b_data, epos.offset);
                        else
-                                udf_update_tag(bh->b_data, sizeof(struct allocExtDesc));
+                                udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc));
-                        mark_buffer_dirty_inode(bh, inode);
+                        mark_buffer_dirty_inode(epos.bh, inode);
                }
        }
        UDF_I_LENEXTENTS(inode) = lbcount;
-        udf_release_data(bh);
+        WARN_ON(lbcount != inode->i_size);
+        brelse(epos.bh);
 }
 void udf_truncate_extents(struct inode * inode)
 {
-        kernel_lb_addr bloc, eloc, neloc = { 0, 0 };
+        struct extent_position epos;
-        uint32_t extoffset, elen, offset, nelen = 0, lelen = 0, lenalloc;
+        kernel_lb_addr eloc, neloc = { 0, 0 };
+        uint32_t elen, nelen = 0, indirect_ext_len = 0, lenalloc;
        int8_t etype;
-        int first_block = inode->i_size >> inode->i_sb->s_blocksize_bits;
+        struct super_block *sb = inode->i_sb;
-        struct buffer_head *bh = NULL;
+        sector_t first_block = inode->i_size >> sb->s_blocksize_bits, offset;
+        loff_t byte_offset;
        int adsize;
        if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_SHORT)
@@ -136,158 +140,130 @@ void udf_truncate_extents(struct inode * inode)
        else if (UDF_I_ALLOCTYPE(inode) == ICBTAG_FLAG_AD_LONG)
                adsize = sizeof(long_ad);
        else
-                adsize = 0;
+                BUG();
-        etype = inode_bmap(inode, first_block, &bloc, &extoffset, &eloc, &elen, &offset, &bh);
+        etype = inode_bmap(inode, first_block, &epos, &eloc, &elen, &offset);
-        offset += (inode->i_size & (inode->i_sb->s_blocksize - 1));
+        byte_offset = (offset << sb->s_blocksize_bits) + (inode->i_size & (sb->s_blocksize-1));
        if (etype != -1)
        {
-                extoffset -= adsize;
+                epos.offset -= adsize;
-                extent_trunc(inode, bloc, extoffset, eloc, etype, elen, bh, offset);
+                extent_trunc(inode, &epos, eloc, etype, elen, byte_offset);
-                extoffset += adsize;
+                epos.offset += adsize;
+                if (byte_offset)
-                if (offset)
+                        lenalloc = epos.offset;
-                        lenalloc = extoffset;
                else
-                        lenalloc = extoffset - adsize;
+                        lenalloc = epos.offset - adsize;
-                if (!bh)
+                if (!epos.bh)
                        lenalloc -= udf_file_entry_alloc_offset(inode);
                else
                        lenalloc -= sizeof(struct allocExtDesc);
-                while ((etype = udf_current_aext(inode, &bloc, &extoffset, &eloc, &elen, &bh, 0)) != -1)
+                while ((etype = udf_current_aext(inode, &epos, &eloc, &elen, 0)) != -1)
                {
                        if (etype == (EXT_NEXT_EXTENT_ALLOCDECS >> 30))
                        {
-                                udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 0);
+                                udf_write_aext(inode, &epos, neloc, nelen, 0);
-                                extoffset = 0;
+                                if (indirect_ext_len)
-                                if (lelen)
                                {
-                                        if (!bh)
+                                        /* We managed to free all extents in the
+                                         * indirect extent - free it too */
+                                        if (!epos.bh)
                                                BUG();
-                                        else
+                                        udf_free_blocks(sb, inode, epos.block, 0, indirect_ext_len);
-                                                memset(bh->b_data, 0x00, sizeof(struct allocExtDesc));
-                                        udf_free_blocks(inode->i_sb, inode, bloc, 0, lelen);
                                }
                                else
                                {
-                                        if (!bh)
+                                        if (!epos.bh)
                                        {
                                                UDF_I_LENALLOC(inode) = lenalloc;
                                                mark_inode_dirty(inode);
                                        }
                                        else
                                        {
-                                                struct allocExtDesc *aed = (struct allocExtDesc *)(bh->b_data);
+                                                struct allocExtDesc *aed = (struct allocExtDesc *)(epos.bh->b_data);
                                                aed->lengthAllocDescs = cpu_to_le32(lenalloc);
-                                                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                                                if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(sb) >= 0x0201)
-                                                        udf_update_tag(bh->b_data, lenalloc +
+                                                        udf_update_tag(epos.bh->b_data, lenalloc +
                                                                sizeof(struct allocExtDesc));
                                                else
-                                                        udf_update_tag(bh->b_data, sizeof(struct allocExtDesc));
+                                                        udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc));
-                                                mark_buffer_dirty_inode(bh, inode);
+                                                mark_buffer_dirty_inode(epos.bh, inode);
                                        }
                                }
+                                brelse(epos.bh);
-                                udf_release_data(bh);
+                                epos.offset = sizeof(struct allocExtDesc);
-                                extoffset = sizeof(struct allocExtDesc);
+                                epos.block = eloc;
-                                bloc = eloc;
+                                epos.bh = udf_tread(sb, udf_get_lb_pblock(sb, eloc, 0));
-                                bh = udf_tread(inode->i_sb, udf_get_lb_pblock(inode->i_sb, bloc, 0));
                                if (elen)
-                                        lelen = (elen + inode->i_sb->s_blocksize - 1) >>
+                                        indirect_ext_len = (elen +
-                                                inode->i_sb->s_blocksize_bits;
+                                                sb->s_blocksize - 1) >>
+                                                sb->s_blocksize_bits;
                                else
-                                        lelen = 1;
+                                        indirect_ext_len = 1;
                        }
                        else
                        {
-                                extent_trunc(inode, bloc, extoffset, eloc, etype, elen, bh, 0);
+                                extent_trunc(inode, &epos, eloc, etype, elen, 0);
-                                extoffset += adsize;
+                                epos.offset += adsize;
                        }
                }
-                if (lelen)
+                if (indirect_ext_len)
                {
-                        if (!bh)
+                        if (!epos.bh)
                                BUG();
-                        else
+                        udf_free_blocks(sb, inode, epos.block, 0, indirect_ext_len);
-                                memset(bh->b_data, 0x00, sizeof(struct allocExtDesc));
-                        udf_free_blocks(inode->i_sb, inode, bloc, 0, lelen);
                }
                else
                {
-                        if (!bh)
+                        if (!epos.bh)
                        {
                                UDF_I_LENALLOC(inode) = lenalloc;
                                mark_inode_dirty(inode);
                        }
                        else
                        {
-                                struct allocExtDesc *aed = (struct allocExtDesc *)(bh->b_data);
+                                struct allocExtDesc *aed = (struct allocExtDesc *)(epos.bh->b_data);
                                aed->lengthAllocDescs = cpu_to_le32(lenalloc);
-                                if (!UDF_QUERY_FLAG(inode->i_sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(inode->i_sb) >= 0x0201)
+                                if (!UDF_QUERY_FLAG(sb, UDF_FLAG_STRICT) || UDF_SB_UDFREV(sb) >= 0x0201)
-                                        udf_update_tag(bh->b_data, lenalloc +
+                                        udf_update_tag(epos.bh->b_data, lenalloc +
                                                sizeof(struct allocExtDesc));
                                else
-                                        udf_update_tag(bh->b_data, sizeof(struct allocExtDesc));
+                                        udf_update_tag(epos.bh->b_data, sizeof(struct allocExtDesc));
-                                mark_buffer_dirty_inode(bh, inode);
+                                mark_buffer_dirty_inode(epos.bh, inode);
                        }
                }
        }
        else if (inode->i_size)
        {
-                if (offset)
+                if (byte_offset)
                {
+                        kernel_long_ad extent;
                        /*
                         *  OK, there is not extent covering inode->i_size and
                         *  no extent above inode->i_size => truncate is
-                         *  extending the file by 'offset'.
+                         *  extending the file by 'offset' blocks.
                         */
-                        if ((!bh && extoffset == udf_file_entry_alloc_offset(inode)) ||
+                        if ((!epos.bh && epos.offset == udf_file_entry_alloc_offset(inode)) ||
-                            (bh && extoffset == sizeof(struct allocExtDesc))) {
+                            (epos.bh && epos.offset == sizeof(struct allocExtDesc))) {
-                                /* File has no extents at all! */
+                                /* File has no extents at all or has empty last
-                                memset(&eloc, 0x00, sizeof(kernel_lb_addr));
+                                 * indirect extent! Create a fake extent... */
-                                elen = EXT_NOT_RECORDED_NOT_ALLOCATED | offset;
+                                extent.extLocation.logicalBlockNum = 0;
-                                udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 1);
+                                extent.extLocation.partitionReferenceNum = 0;
+                                extent.extLength = EXT_NOT_RECORDED_NOT_ALLOCATED;
                        }
                        else {
-                                extoffset -= adsize;
+                                epos.offset -= adsize;
-                                etype = udf_next_aext(inode, &bloc, &extoffset, &eloc, &elen, &bh, 1);
+                                etype = udf_next_aext(inode, &epos,
-                                if (etype == (EXT_NOT_RECORDED_NOT_ALLOCATED >> 30))
+                                        &extent.extLocation, &extent.extLength, 0);
-                                {
+                                extent.extLength |= etype << 30;
-                                        extoffset -= adsize;
-                                        elen = EXT_NOT_RECORDED_NOT_ALLOCATED | (elen + offset);
-                                        udf_write_aext(inode, bloc, &extoffset, eloc, elen, bh, 0);
-                                }
-                                else if (etype == (EXT_NOT_RECORDED_ALLOCATED >> 30))
-                                {
-                                        kernel_lb_addr neloc = { 0, 0 };
-                                        extoffset -= adsize;
-                                        nelen = EXT_NOT_RECORDED_NOT_ALLOCATED |
-                                                ((elen + offset + inode->i_sb->s_blocksize - 1) &
-                                                ~(inode->i_sb->s_blocksize - 1));
-                                        udf_write_aext(inode, bloc, &extoffset, neloc, nelen, bh, 1);
-                                        udf_add_aext(inode, &bloc, &extoffset, eloc, (etype << 30) | elen, &bh, 1);
-                                }
-                                else
-                                {
-                                        if (elen & (inode->i_sb->s_blocksize - 1))
-                                        {
-                                                extoffset -= adsize;
-                                                elen = EXT_RECORDED_ALLOCATED |
-                                                        ((elen + inode->i_sb->s_blocksize - 1) &
-                                                        ~(inode->i_sb->s_blocksize - 1));
-                                                udf_write_aext(inode, bloc, &extoffset, eloc, elen, bh, 1);
-                                        }
-                                        memset(&eloc, 0x00, sizeof(kernel_lb_addr));
-                                        elen = EXT_NOT_RECORDED_NOT_ALLOCATED | offset;
-                                        udf_add_aext(inode, &bloc, &extoffset, eloc, elen, &bh, 1);
-                                }
                        }
+                        udf_extend_file(inode, &epos, &extent, offset+((inode->i_size & (sb->s_blocksize-1)) != 0));
                }
        }
        UDF_I_LENEXTENTS(inode) = inode->i_size;
-        udf_release_data(bh);
+        brelse(epos.bh);
 }
diff --git a/fs/udf/udf_sb.h b/fs/udf/udf_sb.h
index 110f8d62616f..3b2e6c8cb151 100644
--- a/fs/udf/udf_sb.h
+++ b/fs/udf/udf_sb.h
@@ -93,7 +93,7 @@ static inline struct udf_sb_info *UDF_SB(struct super_block *sb)
        for (i=0; i<nr_groups; i++)\
        {\
                if (UDF_SB_BITMAP(X,Y,Z,i))\
-                        udf_release_data(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);\
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index ee1dece1f6f5..67ded289497c 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -77,6 +77,13 @@ struct ustr
        uint8_t u_len;
 };
+struct extent_position {
+        struct buffer_head *bh;
+        uint32_t offset;
+        kernel_lb_addr block;
+};
 /* super.c */
 extern void udf_error(struct super_block *, const char *, const char *, ...);
 extern void udf_warning(struct super_block *, const char *, const char *, ...);
@@ -98,13 +105,14 @@ extern void udf_read_inode(struct inode *);
 extern void udf_delete_inode(struct inode *);
 extern void udf_clear_inode(struct inode *);
 extern int udf_write_inode(struct inode *, int);
-extern long udf_block_map(struct inode *, long);
+extern long udf_block_map(struct inode *, sector_t);
-extern int8_t inode_bmap(struct inode *, int, kernel_lb_addr *, uint32_t *, kernel_lb_addr *, uint32_t *, uint32_t *, struct buffer_head **);
+extern int udf_extend_file(struct inode *, struct extent_position *, kernel_long_ad *, sector_t);
-extern int8_t udf_add_aext(struct inode *, kernel_lb_addr *, int *, kernel_lb_addr, uint32_t, struct buffer_head **, int);
+extern int8_t inode_bmap(struct inode *, sector_t, struct extent_position *, kernel_lb_addr *, uint32_t *, sector_t *);
-extern int8_t udf_write_aext(struct inode *, kernel_lb_addr, int *, kernel_lb_addr, uint32_t, struct buffer_head *, int);
+extern int8_t udf_add_aext(struct inode *, struct extent_position *, kernel_lb_addr, uint32_t, int);
-extern int8_t udf_delete_aext(struct inode *, kernel_lb_addr, int, kernel_lb_addr, uint32_t, struct buffer_head *);
+extern int8_t udf_write_aext(struct inode *, struct extent_position *, kernel_lb_addr, uint32_t, int);
-extern int8_t udf_next_aext(struct inode *, kernel_lb_addr *, int *, kernel_lb_addr *, uint32_t *, struct buffer_head **, int);
+extern int8_t udf_delete_aext(struct inode *, struct extent_position, kernel_lb_addr, uint32_t);
-extern int8_t udf_current_aext(struct inode *, kernel_lb_addr *, int *, kernel_lb_addr *, uint32_t *, struct buffer_head **, int);
+extern int8_t udf_next_aext(struct inode *, struct extent_position *, kernel_lb_addr *, uint32_t *, int);
+extern int8_t udf_current_aext(struct inode *, struct extent_position *, kernel_lb_addr *, uint32_t *, int);
 /* misc.c */
 extern struct buffer_head *udf_tgetblk(struct super_block *, int);
@@ -113,7 +121,6 @@ extern struct genericFormat *udf_add_extendedattr(struct inode *, uint32_t, uint
 extern struct genericFormat *udf_get_extendedattr(struct inode *, uint32_t, uint8_t);
 extern struct buffer_head *udf_read_tagged(struct super_block *, uint32_t, uint32_t, uint16_t *);
 extern struct buffer_head *udf_read_ptagged(struct super_block *, kernel_lb_addr, uint32_t, uint16_t *);
-extern void udf_release_data(struct buffer_head *);
 extern void udf_update_tag(char *, int);
 extern void udf_new_tag(char *, uint16_t, uint16_t, uint16_t, uint32_t, int);
@@ -151,7 +158,7 @@ extern int udf_new_block(struct super_block *, struct inode *, uint16_t, uint32_
 extern int udf_fsync_file(struct file *, struct dentry *, int);
 /* directory.c */
-extern struct fileIdentDesc * udf_fileident_read(struct inode *, loff_t *, struct udf_fileident_bh *, struct fileIdentDesc *, kernel_lb_addr *, uint32_t *, kernel_lb_addr *, uint32_t *, uint32_t *, struct buffer_head **);
+extern struct fileIdentDesc * udf_fileident_read(struct inode *, loff_t *, struct udf_fileident_bh *, struct fileIdentDesc *, struct extent_position *, kernel_lb_addr *, uint32_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);
diff --git a/fs/ufs/dir.c b/fs/ufs/dir.c
index 4fb8b2e077ee..154452172f43 100644
--- a/fs/ufs/dir.c
+++ b/fs/ufs/dir.c
@@ -19,7 +19,6 @@
 #include <linux/time.h>
 #include <linux/fs.h>
 #include <linux/ufs_fs.h>
-#include <linux/smp_lock.h>
 #include "swab.h"
 #include "util.h"
diff --git a/fs/utimes.c b/fs/utimes.c
index 99cf2cb11fec..480f7c8c29da 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -1,8 +1,10 @@
 #include <linux/compiler.h>
+#include <linux/file.h>
 #include <linux/fs.h>
 #include <linux/linkage.h>
 #include <linux/namei.h>
 #include <linux/sched.h>
+#include <linux/stat.h>
 #include <linux/utime.h>
 #include <asm/uaccess.h>
 #include <asm/unistd.h>
@@ -20,54 +22,18 @@
 * must be owner or have write permission.
 * Else, update from *times, must be owner or super user.
 */
-asmlinkage long sys_utime(char __user * filename, struct utimbuf __user * times)
+asmlinkage long sys_utime(char __user *filename, struct utimbuf __user *times)
 {
-        int error;
+        struct timespec tv[2];
-        struct nameidata nd;
-        struct inode * inode;
-        struct iattr newattrs;
-        error = user_path_walk(filename, &nd);
-        if (error)
-                goto out;
-        inode = nd.dentry->d_inode;
-        error = -EROFS;
-        if (IS_RDONLY(inode))
-                goto dput_and_out;
-        /* Don't worry, the checks are done in inode_change_ok() */
-        newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
        if (times) {
-                error = -EPERM;
+                if (get_user(tv[0].tv_sec, &times->actime) ||
-                if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
+                    get_user(tv[1].tv_sec, &times->modtime))
-                        goto dput_and_out;
+                        return -EFAULT;
+                tv[0].tv_nsec = 0;
-                error = get_user(newattrs.ia_atime.tv_sec, &times->actime);
+                tv[1].tv_nsec = 0;
-                newattrs.ia_atime.tv_nsec = 0;
-                if (!error)
-                        error = get_user(newattrs.ia_mtime.tv_sec, &times->modtime);
-                newattrs.ia_mtime.tv_nsec = 0;
-                if (error)
-                        goto dput_and_out;
-                newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
-        } else {
-                error = -EACCES;
-                if (IS_IMMUTABLE(inode))
-                        goto dput_and_out;
-                if (current->fsuid != inode->i_uid &&
-                    (error = vfs_permission(&nd, MAY_WRITE)) != 0)
-                        goto dput_and_out;
        }
-        mutex_lock(&inode->i_mutex);
+        return do_utimes(AT_FDCWD, filename, times ? tv : NULL, 0);
-        error = notify_change(nd.dentry, &newattrs);
-        mutex_unlock(&inode->i_mutex);
-dput_and_out:
-        path_release(&nd);
-out:
-        return error;
 }
 #endif
@@ -76,18 +42,38 @@ out:
 * must be owner or have write permission.
 * Else, update from *times, must be owner or super user.
 */
-long do_utimes(int dfd, char __user *filename, struct timeval *times)
+long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags)
 {
        int error;
        struct nameidata nd;
-        struct inode * inode;
+        struct dentry *dentry;
+        struct inode *inode;
        struct iattr newattrs;
+        struct file *f = NULL;
-        error = __user_walk_fd(dfd, filename, LOOKUP_FOLLOW, &nd);
+        error = -EINVAL;
+        if (flags & ~AT_SYMLINK_NOFOLLOW)
-        if (error)
                goto out;
-        inode = nd.dentry->d_inode;
+        if (filename == NULL && dfd != AT_FDCWD) {
+                error = -EINVAL;
+                if (flags & AT_SYMLINK_NOFOLLOW)
+                        goto out;
+                error = -EBADF;
+                f = fget(dfd);
+                if (!f)
+                        goto out;
+                dentry = f->f_path.dentry;
+        } else {
+                error = __user_walk_fd(dfd, filename, (flags & AT_SYMLINK_NOFOLLOW) ? 0 : LOOKUP_FOLLOW, &nd);
+                if (error)
+                        goto out;
+                dentry = nd.dentry;
+        }
+        inode = dentry->d_inode;
        error = -EROFS;
        if (IS_RDONLY(inode))
@@ -100,11 +86,21 @@ long do_utimes(int dfd, char __user *filename, struct timeval *times)
                if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
                        goto dput_and_out;
-                newattrs.ia_atime.tv_sec = times[0].tv_sec;
+                if (times[0].tv_nsec == UTIME_OMIT)
-                newattrs.ia_atime.tv_nsec = times[0].tv_usec * 1000;
+                        newattrs.ia_valid &= ~ATTR_ATIME;
-                newattrs.ia_mtime.tv_sec = times[1].tv_sec;
+                else if (times[0].tv_nsec != UTIME_NOW) {
-                newattrs.ia_mtime.tv_nsec = times[1].tv_usec * 1000;
+                        newattrs.ia_atime.tv_sec = times[0].tv_sec;
-                newattrs.ia_valid |= ATTR_ATIME_SET | ATTR_MTIME_SET;
+                        newattrs.ia_atime.tv_nsec = times[0].tv_nsec;
+                        newattrs.ia_valid |= ATTR_ATIME_SET;
+                }
+                if (times[1].tv_nsec == UTIME_OMIT)
+                        newattrs.ia_valid &= ~ATTR_MTIME;
+                else if (times[1].tv_nsec != UTIME_NOW) {
+                        newattrs.ia_mtime.tv_sec = times[1].tv_sec;
+                        newattrs.ia_mtime.tv_nsec = times[1].tv_nsec;
+                        newattrs.ia_valid |= ATTR_MTIME_SET;
+                }
        } else {
                error = -EACCES;
                if (IS_IMMUTABLE(inode))
@@ -115,21 +111,67 @@ long do_utimes(int dfd, char __user *filename, struct timeval *times)
                        goto dput_and_out;
        }
        mutex_lock(&inode->i_mutex);
-        error = notify_change(nd.dentry, &newattrs);
+        error = notify_change(dentry, &newattrs);
        mutex_unlock(&inode->i_mutex);
 dput_and_out:
-        path_release(&nd);
+        if (f)
+                fput(f);
+        else
+                path_release(&nd);
 out:
        return error;
 }
+asmlinkage long sys_utimensat(int dfd, char __user *filename, struct timespec __user *utimes, int flags)
+{
+        struct timespec tstimes[2];
+        if (utimes) {
+                if (copy_from_user(&tstimes, utimes, sizeof(tstimes)))
+                        return -EFAULT;
+                if ((tstimes[0].tv_nsec == UTIME_OMIT ||
+                     tstimes[0].tv_nsec == UTIME_NOW) &&
+                    tstimes[0].tv_sec != 0)
+                        return -EINVAL;
+                if ((tstimes[1].tv_nsec == UTIME_OMIT ||
+                     tstimes[1].tv_nsec == UTIME_NOW) &&
+                    tstimes[1].tv_sec != 0)
+                        return -EINVAL;
+                /* Nothing to do, we must not even check the path.  */
+                if (tstimes[0].tv_nsec == UTIME_OMIT &&
+                    tstimes[1].tv_nsec == UTIME_OMIT)
+                        return 0;
+        }
+        return do_utimes(dfd, filename, utimes ? tstimes : NULL, flags);
+}
 asmlinkage long sys_futimesat(int dfd, char __user *filename, struct timeval __user *utimes)
 {
        struct timeval times[2];
+        struct timespec tstimes[2];
+        if (utimes) {
+                if (copy_from_user(&times, utimes, sizeof(times)))
+                        return -EFAULT;
+                /* This test is needed to catch all invalid values.  If we
+                   would test only in do_utimes we would miss those invalid
+                   values truncated by the multiplication with 1000.  Note
+                   that we also catch UTIME_{NOW,OMIT} here which are only
+                   valid for utimensat.  */
+                if (times[0].tv_usec >= 1000000 || times[0].tv_usec < 0 ||
+                    times[1].tv_usec >= 1000000 || times[1].tv_usec < 0)
+                        return -EINVAL;
+                tstimes[0].tv_sec = times[0].tv_sec;
+                tstimes[0].tv_nsec = 1000 * times[0].tv_usec;
+                tstimes[1].tv_sec = times[1].tv_sec;
+                tstimes[1].tv_nsec = 1000 * times[1].tv_usec;
+        }
-        if (utimes && copy_from_user(&times, utimes, sizeof(times)))
+        return do_utimes(dfd, filename, utimes ? tstimes : NULL, 0);
-                return -EFAULT;
-        return do_utimes(dfd, filename, utimes ? times : NULL);
 }
 asmlinkage long sys_utimes(char __user *filename, struct timeval __user *utimes)
diff --git a/fs/xattr.c b/fs/xattr.c
index 38646132ab0e..9f4568b55b0f 100644
--- a/fs/xattr.c
+++ b/fs/xattr.c
@@ -9,7 +9,6 @@
 */
 #include <linux/fs.h>
 #include <linux/slab.h>
-#include <linux/smp_lock.h>
 #include <linux/file.h>
 #include <linux/xattr.h>
 #include <linux/namei.h>
diff --git a/fs/xfs/linux-2.6/xfs_lrw.c b/fs/xfs/linux-2.6/xfs_lrw.c
index ff8d64eba9f8..558076dd0752 100644
--- a/fs/xfs/linux-2.6/xfs_lrw.c
+++ b/fs/xfs/linux-2.6/xfs_lrw.c
@@ -639,7 +639,6 @@ xfs_write(
        xfs_fsize_t             isize, new_size;
        xfs_iocore_t            *io;
        bhv_vnode_t             *vp;
-        unsigned long           seg;
        int                     iolock;
        int                     eventsent = 0;
        bhv_vrwlock_t           locktype;
@@ -652,24 +651,9 @@ xfs_write(
        vp = BHV_TO_VNODE(bdp);
        xip = XFS_BHVTOI(bdp);
-        for (seg = 0; seg < segs; seg++) {
+        error = generic_segment_checks(iovp, &segs, &ocount, VERIFY_READ);
-                const struct iovec *iv = &iovp[seg];
+        if (error)
+                return error;
-                /*
-                 * If any segment has a negative length, or the cumulative
-                 * length ever wraps negative then return -EINVAL.
-                 */
-                ocount += iv->iov_len;
-                if (unlikely((ssize_t)(ocount|iv->iov_len) < 0))
-                        return -EINVAL;
-                if (access_ok(VERIFY_READ, iv->iov_base, iv->iov_len))
-                        continue;
-                if (seg == 0)
-                        return -EFAULT;
-                segs = seg;
-                ocount -= iv->iov_len;  /* This segment is no good */
-                break;
-        }
        count = ocount;
        pos = *offset;