Merge branch 'for-bfields' of git://linux-nfs.org/~tomtucker/xprt-switch-2.6 into for-2.6.27

119 files changed, 1913 insertions, 1481 deletions

diff --git a/fs/Kconfig.binfmt b/fs/Kconfig.binfmt
index 55e8ee1900a5..3263084eef9e 100644
--- a/fs/Kconfig.binfmt
+++ b/fs/Kconfig.binfmt
@@ -42,7 +42,7 @@ config BINFMT_ELF_FDPIC
 
 config BINFMT_FLAT
         bool "Kernel support for flat binaries"
-        depends on !MMU
+        depends on !MMU && (!FRV || BROKEN)
         help
           Support uClinux FLAT format binaries.
 
diff --git a/fs/afs/callback.c b/fs/afs/callback.c
index a78d5b236bb1..587ef5123cd8 100644
--- a/fs/afs/callback.c
+++ b/fs/afs/callback.c
@@ -8,7 +8,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- * Authors: David Woodhouse <dwmw2@cambridge.redhat.com>
+ * Authors: David Woodhouse <dwmw2@infradead.org>
  *          David Howells <dhowells@redhat.com>
  *
  */
diff --git a/fs/afs/inode.c b/fs/afs/inode.c
index 08db82e1343a..bb47217f6a18 100644
--- a/fs/afs/inode.c
+++ b/fs/afs/inode.c
@@ -8,7 +8,7 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
- * Authors: David Woodhouse <dwmw2@cambridge.redhat.com>
+ * Authors: David Woodhouse <dwmw2@infradead.org>
  *          David Howells <dhowells@redhat.com>
  *
  */
diff --git a/fs/afs/super.c b/fs/afs/super.c
index 4b572b801d8d..7e3faeef6818 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -10,7 +10,7 @@
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  *
  * Authors: David Howells <dhowells@redhat.com>
- *          David Woodhouse <dwmw2@redhat.com>
+ *          David Woodhouse <dwmw2@infradead.org>
  *
  */
 
diff --git a/fs/aio.c b/fs/aio.c
index b5253e77eb2f..0fb3117ddd93 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -591,10 +591,6 @@ static void use_mm(struct mm_struct *mm)
         atomic_inc(&mm->mm_count);
         tsk->mm = mm;
         tsk->active_mm = mm;
-        /*
-         * Note that on UML this *requires* PF_BORROWED_MM to be set, otherwise
-         * it won't work. Update it accordingly if you change it here
-         */
         switch_mm(active_mm, mm, tsk);
         task_unlock(tsk);
 
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index b25707fee2cc..d48ff5f370f4 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -16,7 +16,6 @@
 #include <linux/time.h>
 #include <linux/mm.h>
 #include <linux/mman.h>
-#include <linux/a.out.h>
 #include <linux/errno.h>
 #include <linux/signal.h>
 #include <linux/binfmts.h>
@@ -256,7 +255,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
                         return -EFAULT;
                 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
                 if (!len || len > MAX_ARG_STRLEN)
-                        return 0;
+                        return -EINVAL;
                 p += len;
         }
         if (__put_user(0, argv))
@@ -268,7 +267,7 @@ create_elf_tables(struct linux_binprm *bprm, struct elfhdr *exec,
                         return -EFAULT;
                 len = strnlen_user((void __user *)p, MAX_ARG_STRLEN);
                 if (!len || len > MAX_ARG_STRLEN)
-                        return 0;
+                        return -EINVAL;
                 p += len;
         }
         if (__put_user(0, envp))
@@ -548,7 +547,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
         struct {
                 struct elfhdr elf_ex;
                 struct elfhdr interp_elf_ex;
-                struct exec interp_ex;
         } *loc;
 
         loc = kmalloc(sizeof(*loc), GFP_KERNEL);
@@ -680,7 +678,6 @@ static int load_elf_binary(struct linux_binprm *bprm, struct pt_regs *regs)
                         }
 
                         /* Get the exec headers */
-                        loc->interp_ex = *((struct exec *)bprm->buf);
                         loc->interp_elf_ex = *((struct elfhdr *)bprm->buf);
                         break;
                 }
@@ -1900,7 +1897,7 @@ static int elf_core_dump(long signr, struct pt_regs *regs, struct file *file, un
         /* alloc memory for large data structures: too large to be on stack */
         elf = kmalloc(sizeof(*elf), GFP_KERNEL);
         if (!elf)
-                goto cleanup;
+                goto out;
         
         segs = current->mm->map_count;
 #ifdef ELF_CORE_EXTRA_PHDRS
@@ -2034,8 +2031,9 @@ end_coredump:
         set_fs(fs);
 
 cleanup:
-        kfree(elf);
         free_note_info(&info);
+        kfree(elf);
+out:
         return has_dumped;
 }
 
diff --git a/fs/binfmt_elf_fdpic.c b/fs/binfmt_elf_fdpic.c
index ddd35d873391..d051a32e6270 100644
--- a/fs/binfmt_elf_fdpic.c
+++ b/fs/binfmt_elf_fdpic.c
@@ -390,7 +390,7 @@ static int load_elf_fdpic_binary(struct linux_binprm *bprm,
         }
 
         /* expand the stack mapping to use up the entire allocation granule */
-        fullsize = ksize((char *) current->mm->start_brk);
+        fullsize = kobjsize((char *) current->mm->start_brk);
         if (!IS_ERR_VALUE(do_mremap(current->mm->start_brk, stack_size,
                                     fullsize, 0, 0)))
                 stack_size = fullsize;
diff --git a/fs/binfmt_flat.c b/fs/binfmt_flat.c
index 3b40d45a3a16..2cb1acda3a82 100644
--- a/fs/binfmt_flat.c
+++ b/fs/binfmt_flat.c
@@ -548,7 +548,7 @@ static int load_flat_file(struct linux_binprm * bprm,
                         PROT_READ|PROT_WRITE|PROT_EXEC, MAP_PRIVATE, 0);
                 /* Remap to use all availabe slack region space */
                 if (realdatastart && (realdatastart < (unsigned long)-4096)) {
-                        reallen = ksize((void *)realdatastart);
+                        reallen = kobjsize((void *)realdatastart);
                         if (reallen > len) {
                                 realdatastart = do_mremap(realdatastart, len,
                                         reallen, MREMAP_FIXED, realdatastart);
@@ -600,7 +600,7 @@ static int load_flat_file(struct linux_binprm * bprm,
                         PROT_READ | PROT_EXEC | PROT_WRITE, MAP_PRIVATE, 0);
                 /* Remap to use all availabe slack region space */
                 if (textpos && (textpos < (unsigned long) -4096)) {
-                        reallen = ksize((void *)textpos);
+                        reallen = kobjsize((void *)textpos);
                         if (reallen > len) {
                                 textpos = do_mremap(textpos, len, reallen,
                                         MREMAP_FIXED, textpos);
@@ -683,7 +683,7 @@ static int load_flat_file(struct linux_binprm * bprm,
                  */
                 current->mm->start_brk = datapos + data_len + bss_len;
                 current->mm->brk = (current->mm->start_brk + 3) & ~3;
-                current->mm->context.end_brk = memp + ksize((void *) memp) - stack_len;
+                current->mm->context.end_brk = memp + kobjsize((void *) memp) - stack_len;
         }
 
         if (flags & FLAT_FLAG_KTRACE)
@@ -790,7 +790,7 @@ static int load_flat_file(struct linux_binprm * bprm,
 
         /* zero the BSS,  BRK and stack areas */
         memset((void*)(datapos + data_len), 0, bss_len + 
-                        (memp + ksize((void *) memp) - stack_len -      /* end brk */
+                        (memp + kobjsize((void *) memp) - stack_len -   /* end brk */
                         libinfo->lib_list[id].start_brk) +              /* start brk */
                         stack_len);
 
diff --git a/fs/block_dev.c b/fs/block_dev.c
index 7d822fae7765..10d8a0aa871a 100644
--- a/fs/block_dev.c
+++ b/fs/block_dev.c
@@ -12,6 +12,7 @@
 #include <linux/kmod.h>
 #include <linux/major.h>
 #include <linux/smp_lock.h>
+#include <linux/device_cgroup.h>
 #include <linux/highmem.h>
 #include <linux/blkdev.h>
 #include <linux/module.h>
@@ -928,9 +929,22 @@ static int do_open(struct block_device *bdev, struct file *file, int for_part)
 {
         struct module *owner = NULL;
         struct gendisk *disk;
-        int ret = -ENXIO;
+        int ret;
         int part;
+        int perm = 0;
+
+        if (file->f_mode & FMODE_READ)
+                perm |= MAY_READ;
+        if (file->f_mode & FMODE_WRITE)
+                perm |= MAY_WRITE;
+        /*
+         * hooks: /n/, see "layering violations".
+         */
+        ret = devcgroup_inode_permission(bdev->bd_inode, perm);
+        if (ret != 0)
+                return ret;
 
+        ret = -ENXIO;
         file->f_mapping = bdev->bd_inode->i_mapping;
         lock_kernel();
         disk = get_gendisk(bdev->bd_dev, &part);
diff --git a/fs/cifs/AUTHORS b/fs/cifs/AUTHORS
index 8848e4dfa026..9c136d7803d9 100644
--- a/fs/cifs/AUTHORS
+++ b/fs/cifs/AUTHORS
@@ -36,6 +36,7 @@ Miklos Szeredi
 Kazeon team for various fixes especially for 2.4 version.
 Asser Ferno (Change Notify support)
 Shaggy (Dave Kleikamp) for inumerable small fs suggestions and some good cleanup
+Igor Mammedov (DFS support)
 
 Test case and Bug Report contributors
 -------------------------------------
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index 8355e918fddf..1f3465201fdf 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -1,5 +1,12 @@
 Version 1.53
 ------------
+DFS support added (Microsoft Distributed File System client support needed
+for referrals which enable a hierarchical name space among servers).
+Disable temporary caching of mode bits to servers which do not support
+storing of mode (e.g. Windows servers, when client mounts without cifsacl
+mount option) and add new "dynperm" mount option to enable temporary caching
+of mode (enable old behavior).  Fix hang on mount caused when server crashes
+tcp session during negotiate protocol.
 
 Version 1.52
 ------------
@@ -12,7 +19,8 @@ Add ability to modify cifs acls for handling chmod (when mounted with
 cifsacl flag). Fix prefixpath path separator so we can handle mounts
 with prefixpaths longer than one directory (one path component) when
 mounted to Windows servers.  Fix slow file open when cifsacl
-enabled.
+enabled. Fix memory leak in FindNext when the SMB call returns -EBADF.
+
 
 Version 1.51
 ------------
diff --git a/fs/cifs/README b/fs/cifs/README
index 621aa1a85971..2bd6fe556f88 100644
--- a/fs/cifs/README
+++ b/fs/cifs/README
@@ -483,6 +483,11 @@ A partial list of the supported mount options follows:
  sign           Must use packet signing (helps avoid unwanted data modification
                 by intermediate systems in the route).  Note that signing
                 does not work with lanman or plaintext authentication.
+ seal           Must seal (encrypt) all data on this mounted share before
+                sending on the network.  Requires support for Unix Extensions.
+                Note that this differs from the sign mount option in that it
+                causes encryption of data sent over this mounted share but other
+                shares mounted to the same server are unaffected.
  sec            Security mode.  Allowed values are:
                         none    attempt to connection as a null user (no name)
                         krb5    Use Kerberos version 5 authentication
diff --git a/fs/cifs/TODO b/fs/cifs/TODO
index 92c9feac440f..5aff46c61e52 100644
--- a/fs/cifs/TODO
+++ b/fs/cifs/TODO
@@ -1,4 +1,4 @@
-Version 1.52 January 3, 2008
+Version 1.53 May 20, 2008
 
 A Partial List of Missing Features
 ==================================
@@ -20,20 +20,21 @@ d) Cleanup now unneeded SessSetup code in
 fs/cifs/connect.c and add back in NTLMSSP code if any servers
 need it
 
-e) ms-dfs and ms-dfs host name resolution cleanup
-
-f) fix NTLMv2 signing when two mounts with different users to same
+e) fix NTLMv2 signing when two mounts with different users to same
 server.
 
-g) Directory entry caching relies on a 1 second timer, rather than 
+f) Directory entry caching relies on a 1 second timer, rather than 
 using FindNotify or equivalent.  - (started)
 
-h) quota support (needs minor kernel change since quota calls
+g) quota support (needs minor kernel change since quota calls
 to make it to network filesystems or deviceless filesystems)
 
-i) investigate sync behavior (including syncpage) and check  
+h) investigate sync behavior (including syncpage) and check  
 for proper behavior of intr/nointr
 
+i) improve support for very old servers (OS/2 and Win9x for example)
+Including support for changing the time remotely (utimes command).
+
 j) hook lower into the sockets api (as NFS/SunRPC does) to avoid the
 extra copy in/out of the socket buffers in some cases.
 
diff --git a/fs/cifs/asn1.c b/fs/cifs/asn1.c
index cb52cbbe45ff..f58e41d3ba48 100644
--- a/fs/cifs/asn1.c
+++ b/fs/cifs/asn1.c
@@ -186,6 +186,11 @@ asn1_length_decode(struct asn1_ctx *ctx, unsigned int *def, unsigned int *len)
                         }
                 }
         }
+
+        /* don't trust len bigger than ctx buffer */
+        if (*len > ctx->end - ctx->pointer)
+                return 0;
+
         return 1;
 }
 
@@ -203,6 +208,10 @@ asn1_header_decode(struct asn1_ctx *ctx,
         if (!asn1_length_decode(ctx, &def, &len))
                 return 0;
 
+        /* primitive shall be definite, indefinite shall be constructed */
+        if (*con == ASN1_PRI && !def)
+                return 0;
+
         if (def)
                 *eoc = ctx->pointer + len;
         else
@@ -389,6 +398,11 @@ asn1_oid_decode(struct asn1_ctx *ctx,
         unsigned long *optr;
 
         size = eoc - ctx->pointer + 1;
+
+        /* first subid actually encodes first two subids */
+        if (size < 2 || size > ULONG_MAX/sizeof(unsigned long))
+                return 0;
+
         *oid = kmalloc(size * sizeof(unsigned long), GFP_ATOMIC);
         if (*oid == NULL)
                 return 0;
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index f6fdecf6598c..d82374c9e329 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -219,53 +219,6 @@ static struct vfsmount *cifs_dfs_do_refmount(const struct vfsmount *mnt_parent,
 
 }
 
-static char *build_full_dfs_path_from_dentry(struct dentry *dentry)
-{
-        char *full_path = NULL;
-        char *search_path;
-        char *tmp_path;
-        size_t l_max_len;
-        struct cifs_sb_info *cifs_sb;
-
-        if (dentry->d_inode == NULL)
-                return NULL;
-
-        cifs_sb = CIFS_SB(dentry->d_inode->i_sb);
-
-        if (cifs_sb->tcon == NULL)
-                return NULL;
-
-        search_path = build_path_from_dentry(dentry);
-        if (search_path == NULL)
-                return NULL;
-
-        if (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS) {
-                int i;
-                /* we should use full path name for correct working with DFS */
-                l_max_len = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE+1) +
-                                        strnlen(search_path, MAX_PATHCONF) + 1;
-                tmp_path = kmalloc(l_max_len, GFP_KERNEL);
-                if (tmp_path == NULL) {
-                        kfree(search_path);
-                        return NULL;
-                }
-                strncpy(tmp_path, cifs_sb->tcon->treeName, l_max_len);
-                tmp_path[l_max_len-1] = 0;
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
-                        for (i = 0; i < l_max_len; i++) {
-                                if (tmp_path[i] == '\\')
-                                        tmp_path[i] = '/';
-                        }
-                strncat(tmp_path, search_path, l_max_len - strlen(tmp_path));
-
-                full_path = tmp_path;
-                kfree(search_path);
-        } else {
-                full_path = search_path;
-        }
-        return full_path;
-}
-
 static int add_mount_helper(struct vfsmount *newmnt, struct nameidata *nd,
                                 struct list_head *mntlist)
 {
@@ -333,7 +286,7 @@ cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
                 goto out_err;
         }
 
-        full_path = build_full_dfs_path_from_dentry(dentry);
+        full_path = build_path_from_dentry(dentry);
         if (full_path == NULL) {
                 rc = -ENOMEM;
                 goto out_err;
diff --git a/fs/cifs/cifs_fs_sb.h b/fs/cifs/cifs_fs_sb.h
index 8ad2330ba061..877c85409f1f 100644
--- a/fs/cifs/cifs_fs_sb.h
+++ b/fs/cifs/cifs_fs_sb.h
@@ -30,6 +30,7 @@
 #define CIFS_MOUNT_CIFS_ACL     0x200 /* send ACL requests to non-POSIX srv   */
 #define CIFS_MOUNT_OVERR_UID    0x400 /* override uid returned from server    */
 #define CIFS_MOUNT_OVERR_GID    0x800 /* override gid returned from server    */
+#define CIFS_MOUNT_DYNPERM      0x1000 /* allow in-memory only mode setting */
 
 struct cifs_sb_info {
         struct cifsTconInfo *tcon;      /* primary mount */
diff --git a/fs/cifs/cifs_spnego.c b/fs/cifs/cifs_spnego.c
index 6653e29637a7..7013aaff6aed 100644
--- a/fs/cifs/cifs_spnego.c
+++ b/fs/cifs/cifs_spnego.c
@@ -119,6 +119,9 @@ cifs_get_spnego_key(struct cifsSesInfo *sesInfo)
         dp = description + strlen(description);
         sprintf(dp, ";uid=0x%x", sesInfo->linux_uid);
 
+        dp = description + strlen(description);
+        sprintf(dp, ";user=%s", sesInfo->userName);
+
         cFYI(1, ("key description = %s", description));
         spnego_key = request_key(&cifs_spnego_key_type, description, "");
 
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index 427a7c695896..86b4d5f405ae 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -1,7 +1,7 @@
 /*
  *   fs/cifs/cifsfs.c
  *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
  *   Author(s): Steve French (sfrench@us.ibm.com)
  *
  *   Common Internet FileSystem (CIFS) client
@@ -97,9 +97,6 @@ cifs_read_super(struct super_block *sb, void *data,
 {
         struct inode *inode;
         struct cifs_sb_info *cifs_sb;
-#ifdef CONFIG_CIFS_DFS_UPCALL
-        int len;
-#endif
         int rc = 0;
 
         /* BB should we make this contingent on mount parm? */
@@ -117,15 +114,17 @@ cifs_read_super(struct super_block *sb, void *data,
          * complex operation (mount), and in case of fail
          * just exit instead of doing mount and attempting
          * undo it if this copy fails?*/
-        len = strlen(data);
-        cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
-        if (cifs_sb->mountdata == NULL) {
-                kfree(sb->s_fs_info);
-                sb->s_fs_info = NULL;
-                return -ENOMEM;
+        if (data) {
+                int len = strlen(data);
+                cifs_sb->mountdata = kzalloc(len + 1, GFP_KERNEL);
+                if (cifs_sb->mountdata == NULL) {
+                        kfree(sb->s_fs_info);
+                        sb->s_fs_info = NULL;
+                        return -ENOMEM;
+                }
+                strncpy(cifs_sb->mountdata, data, len + 1);
+                cifs_sb->mountdata[len] = '\0';
         }
-        strncpy(cifs_sb->mountdata, data, len + 1);
-        cifs_sb->mountdata[len] = '\0';
 #endif
 
         rc = cifs_mount(sb, cifs_sb, data, devname);
@@ -353,9 +352,41 @@ cifs_show_options(struct seq_file *s, struct vfsmount *m)
                         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) ||
                            !(cifs_sb->tcon->unix_ext))
                                 seq_printf(s, ",gid=%d", cifs_sb->mnt_gid);
+                        if (!cifs_sb->tcon->unix_ext) {
+                                seq_printf(s, ",file_mode=0%o,dir_mode=0%o",
+                                           cifs_sb->mnt_file_mode,
+                                           cifs_sb->mnt_dir_mode);
+                        }
+                        if (cifs_sb->tcon->seal)
+                                seq_printf(s, ",seal");
+                        if (cifs_sb->tcon->nocase)
+                                seq_printf(s, ",nocase");
+                        if (cifs_sb->tcon->retry)
+                                seq_printf(s, ",hard");
                 }
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
                         seq_printf(s, ",posixpaths");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)
+                        seq_printf(s, ",setuids");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
+                        seq_printf(s, ",serverino");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO)
+                        seq_printf(s, ",directio");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
+                        seq_printf(s, ",nouser_xattr");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR)
+                        seq_printf(s, ",mapchars");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)
+                        seq_printf(s, ",sfu");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        seq_printf(s, ",nobrl");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
+                        seq_printf(s, ",cifsacl");
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)
+                        seq_printf(s, ",dynperm");
+                if (m->mnt_sb->s_flags & MS_POSIXACL)
+                        seq_printf(s, ",acl");
+
                 seq_printf(s, ",rsize=%d", cifs_sb->rsize);
                 seq_printf(s, ",wsize=%d", cifs_sb->wsize);
         }
@@ -657,7 +688,7 @@ const struct file_operations cifs_file_ops = {
         .splice_read = generic_file_splice_read,
         .llseek = cifs_llseek,
 #ifdef CONFIG_CIFS_POSIX
-        .ioctl  = cifs_ioctl,
+        .unlocked_ioctl = cifs_ioctl,
 #endif /* CONFIG_CIFS_POSIX */
 
 #ifdef CONFIG_CIFS_EXPERIMENTAL
@@ -677,7 +708,7 @@ const struct file_operations cifs_file_direct_ops = {
         .flush = cifs_flush,
         .splice_read = generic_file_splice_read,
 #ifdef CONFIG_CIFS_POSIX
-        .ioctl  = cifs_ioctl,
+        .unlocked_ioctl  = cifs_ioctl,
 #endif /* CONFIG_CIFS_POSIX */
         .llseek = cifs_llseek,
 #ifdef CONFIG_CIFS_EXPERIMENTAL
@@ -697,7 +728,7 @@ const struct file_operations cifs_file_nobrl_ops = {
         .splice_read = generic_file_splice_read,
         .llseek = cifs_llseek,
 #ifdef CONFIG_CIFS_POSIX
-        .ioctl  = cifs_ioctl,
+        .unlocked_ioctl = cifs_ioctl,
 #endif /* CONFIG_CIFS_POSIX */
 
 #ifdef CONFIG_CIFS_EXPERIMENTAL
@@ -716,7 +747,7 @@ const struct file_operations cifs_file_direct_nobrl_ops = {
         .flush = cifs_flush,
         .splice_read = generic_file_splice_read,
 #ifdef CONFIG_CIFS_POSIX
-        .ioctl  = cifs_ioctl,
+        .unlocked_ioctl  = cifs_ioctl,
 #endif /* CONFIG_CIFS_POSIX */
         .llseek = cifs_llseek,
 #ifdef CONFIG_CIFS_EXPERIMENTAL
@@ -731,7 +762,7 @@ const struct file_operations cifs_dir_ops = {
 #ifdef CONFIG_CIFS_EXPERIMENTAL
         .dir_notify = cifs_dir_notify,
 #endif /* CONFIG_CIFS_EXPERIMENTAL */
-        .ioctl  = cifs_ioctl,
+        .unlocked_ioctl  = cifs_ioctl,
 };
 
 static void
diff --git a/fs/cifs/cifsfs.h b/fs/cifs/cifsfs.h
index cd1301a09b3b..25a6cbd15529 100644
--- a/fs/cifs/cifsfs.h
+++ b/fs/cifs/cifsfs.h
@@ -95,8 +95,7 @@ extern int 	cifs_setxattr(struct dentry *, const char *, const void *,
                         size_t, int);
 extern ssize_t  cifs_getxattr(struct dentry *, const char *, void *, size_t);
 extern ssize_t  cifs_listxattr(struct dentry *, char *, size_t);
-extern int cifs_ioctl(struct inode *inode, struct file *filep,
-                       unsigned int command, unsigned long arg);
+extern long cifs_ioctl(struct file *filep, unsigned int cmd, unsigned long arg);
 
 #ifdef CONFIG_CIFS_EXPERIMENTAL
 extern const struct export_operations cifs_export_ops;
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index b7d9f698e63e..9cfcf326ead3 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -281,6 +281,7 @@ struct cifsTconInfo {
         bool ipc:1;             /* set if connection to IPC$ eg for RPC/PIPES */
         bool retry:1;
         bool nocase:1;
+        bool seal:1;      /* transport encryption for this mounted share */
         bool unix_ext:1;  /* if false disable Linux extensions to CIFS protocol
                                 for this mount even if server would support */
         /* BB add field for back pointer to sb struct(s)? */
@@ -332,7 +333,6 @@ struct cifsFileInfo {
         bool messageMode:1;     /* for pipes: message vs byte mode */
         atomic_t wrtPending;   /* handle in use - defer close */
         struct semaphore fh_sem; /* prevents reopen race after dead ses*/
-        char *search_resume_name; /* BB removeme BB */
         struct cifs_search_info srch_inf;
 };
 
@@ -625,7 +625,7 @@ GLOBAL_EXTERN atomic_t tcpSesAllocCount;
 GLOBAL_EXTERN atomic_t tcpSesReconnectCount;
 GLOBAL_EXTERN atomic_t tconInfoReconnectCount;
 
-/* Various Debug counters to remove someday (BB) */
+/* Various Debug counters */
 GLOBAL_EXTERN atomic_t bufAllocCount;    /* current number allocated  */
 #ifdef CONFIG_CIFS_STATS2
 GLOBAL_EXTERN atomic_t totBufAllocCount; /* total allocated over all time */
diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
index c43bf4b7a556..0f327c224da3 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -79,6 +79,19 @@
 #define TRANS2_GET_DFS_REFERRAL       0x10
 #define TRANS2_REPORT_DFS_INCOSISTENCY 0x11
 
+/* SMB Transact (Named Pipe) subcommand codes */
+#define TRANS_SET_NMPIPE_STATE      0x0001
+#define TRANS_RAW_READ_NMPIPE       0x0011
+#define TRANS_QUERY_NMPIPE_STATE    0x0021
+#define TRANS_QUERY_NMPIPE_INFO     0x0022
+#define TRANS_PEEK_NMPIPE           0x0023
+#define TRANS_TRANSACT_NMPIPE       0x0026
+#define TRANS_RAW_WRITE_NMPIPE      0x0031
+#define TRANS_READ_NMPIPE           0x0036
+#define TRANS_WRITE_NMPIPE          0x0037
+#define TRANS_WAIT_NMPIPE           0x0053
+#define TRANS_CALL_NMPIPE           0x0054
+
 /* NT Transact subcommand codes */
 #define NT_TRANSACT_CREATE            0x01
 #define NT_TRANSACT_IOCTL             0x02
@@ -328,12 +341,13 @@
 #define CREATE_COMPLETE_IF_OPLK 0x00000100      /* should be zero */
 #define CREATE_NO_EA_KNOWLEDGE  0x00000200
 #define CREATE_EIGHT_DOT_THREE  0x00000400      /* doc says this is obsolete
-                                                 open for recovery flag - should
-                                                 be zero */
+                                                 "open for recovery" flag - should
+                                                 be zero in any case */
+#define CREATE_OPEN_FOR_RECOVERY 0x00000400
 #define CREATE_RANDOM_ACCESS    0x00000800
 #define CREATE_DELETE_ON_CLOSE  0x00001000
 #define CREATE_OPEN_BY_ID       0x00002000
-#define CREATE_OPEN_BACKUP_INTN 0x00004000
+#define CREATE_OPEN_BACKUP_INTENT 0x00004000
 #define CREATE_NO_COMPRESSION   0x00008000
 #define CREATE_RESERVE_OPFILTER 0x00100000      /* should be zero */
 #define OPEN_REPARSE_POINT      0x00200000
@@ -722,7 +736,6 @@ typedef struct smb_com_tconx_rsp_ext {
 #define SMB_CSC_CACHE_AUTO_REINT   0x0004
 #define SMB_CSC_CACHE_VDO          0x0008
 #define SMB_CSC_NO_CACHING         0x000C
-
 #define SMB_UNIQUE_FILE_NAME    0x0010
 #define SMB_EXTENDED_SIGNATURES 0x0020
 
@@ -806,7 +819,7 @@ typedef struct smb_com_findclose_req {
 #define ICOUNT_MASK             0x00FF
 #define PIPE_READ_MODE          0x0100
 #define NAMED_PIPE_TYPE         0x0400
-#define PIPE_END_POINT          0x0800
+#define PIPE_END_POINT          0x4000
 #define BLOCKING_NAMED_PIPE     0x8000
 
 typedef struct smb_com_open_req {       /* also handles create */
@@ -1904,19 +1917,26 @@ typedef struct smb_com_transaction2_get_dfs_refer_req {
         char RequestFileName[1];
 } __attribute__((packed)) TRANSACTION2_GET_DFS_REFER_REQ;
 
+#define DFS_VERSION cpu_to_le16(0x0003)
+
+/* DFS server target type */
+#define DFS_TYPE_LINK 0x0000  /* also for sysvol targets */
+#define DFS_TYPE_ROOT 0x0001
+ 
+/* Referral Entry Flags */
+#define DFS_NAME_LIST_REF 0x0200
+
 typedef struct dfs_referral_level_3 {
         __le16 VersionNumber;
-        __le16 ReferralSize;
-        __le16 ServerType;      /* 0x0001 = CIFS server */
-        __le16 ReferralFlags;   /* or proximity - not clear which since it is
-                                   always set to zero - SNIA spec says 0x01
-                                   means strip off PathConsumed chars before
-                                   submitting RequestFileName to remote node */
-        __le16 TimeToLive;
-        __le16 Proximity;
+        __le16 Size;
+        __le16 ServerType; /* 0x0001 = root targets; 0x0000 = link targets */
+        __le16 ReferralEntryFlags; /* 0x0200 bit set only for domain
+                                      or DC referral responce */
+        __le32 TimeToLive;
         __le16 DfsPathOffset;
         __le16 DfsAlternatePathOffset;
-        __le16 NetworkAddressOffset;
+        __le16 NetworkAddressOffset; /* offset of the link target */
+        __le16 ServiceSiteGuid;
 } __attribute__((packed)) REFERRAL3;
 
 typedef struct smb_com_transaction_get_dfs_refer_rsp {
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index d481f6c5a2be..b9f5e935f821 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -93,7 +93,7 @@ extern struct timespec cnvrtDosUnixTm(__u16 date, __u16 time);
 
 extern int cifs_get_inode_info(struct inode **pinode,
                         const unsigned char *search_path,
-                        FILE_ALL_INFO * pfile_info,
+                        FILE_ALL_INFO *pfile_info,
                         struct super_block *sb, int xid, const __u16 *pfid);
 extern int cifs_get_inode_info_unix(struct inode **pinode,
                         const unsigned char *search_path,
@@ -130,7 +130,7 @@ extern int CIFSFindClose(const int, struct cifsTconInfo *tcon,
 
 extern int CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
                         const unsigned char *searchName,
-                        FILE_ALL_INFO * findData,
+                        FILE_ALL_INFO *findData,
                         int legacy /* whether to use old info level */,
                         const struct nls_table *nls_codepage, int remap);
 extern int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
@@ -141,18 +141,15 @@ extern int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
 extern int CIFSSMBUnixQPathInfo(const int xid,
                         struct cifsTconInfo *tcon,
                         const unsigned char *searchName,
-                        FILE_UNIX_BASIC_INFO * pFindData,
+                        FILE_UNIX_BASIC_INFO *pFindData,
                         const struct nls_table *nls_codepage, int remap);
 
 extern int CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
                         const unsigned char *searchName,
-                        unsigned char **targetUNCs,
-                        unsigned int *number_of_UNC_in_array,
+                        struct dfs_info3_param **target_nodes,
+                        unsigned int *number_of_nodes_in_array,
                         const struct nls_table *nls_codepage, int remap);
 
-extern int connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
-                        const char *old_path,
-                        const struct nls_table *nls_codepage, int remap);
 extern int get_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
                         const char *old_path,
                         const struct nls_table *nls_codepage,
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 95fbba4ea7d4..4511b708f0f3 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -81,6 +81,40 @@ static struct {
 #endif /* CONFIG_CIFS_WEAK_PW_HASH */
 #endif /* CIFS_POSIX */
 
+/* Allocates buffer into dst and copies smb string from src to it.
+ * caller is responsible for freeing dst if function returned 0.
+ * returns:
+ *      on success - 0
+ *      on failure - errno
+ */
+static int
+cifs_strncpy_to_host(char **dst, const char *src, const int maxlen,
+                 const bool is_unicode, const struct nls_table *nls_codepage)
+{
+        int plen;
+
+        if (is_unicode) {
+                plen = UniStrnlen((wchar_t *)src, maxlen);
+                *dst = kmalloc(plen + 2, GFP_KERNEL);
+                if (!*dst)
+                        goto cifs_strncpy_to_host_ErrExit;
+                cifs_strfromUCS_le(*dst, (__le16 *)src, plen, nls_codepage);
+        } else {
+                plen = strnlen(src, maxlen);
+                *dst = kmalloc(plen + 2, GFP_KERNEL);
+                if (!*dst)
+                        goto cifs_strncpy_to_host_ErrExit;
+                strncpy(*dst, src, plen);
+        }
+        (*dst)[plen] = 0;
+        (*dst)[plen+1] = 0; /* harmless for ASCII case, needed for Unicode */
+        return 0;
+
+cifs_strncpy_to_host_ErrExit:
+        cERROR(1, ("Failed to allocate buffer for string\n"));
+        return -ENOMEM;
+}
+
 
 /* Mark as invalid, all open files on tree connections since they
    were closed when session to server was lost */
@@ -1166,6 +1200,20 @@ static __u16 convert_disposition(int disposition)
         return ofun;
 }
 
+static int
+access_flags_to_smbopen_mode(const int access_flags)
+{
+        int masked_flags = access_flags & (GENERIC_READ | GENERIC_WRITE);
+
+        if (masked_flags == GENERIC_READ)
+                return SMBOPEN_READ;
+        else if (masked_flags == GENERIC_WRITE)
+                return SMBOPEN_WRITE;
+
+        /* just go for read/write */
+        return SMBOPEN_READWRITE;
+}
+
 int
 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
             const char *fileName, const int openDisposition,
@@ -1207,13 +1255,7 @@ OldOpenRetry:
                 pSMB->OpenFlags = cpu_to_le16(REQ_BATCHOPLOCK);
 
         pSMB->OpenFlags |= cpu_to_le16(REQ_MORE_INFO);
-        /* BB fixme add conversion for access_flags to bits 0 - 2 of mode */
-        /* 0 = read
-           1 = write
-           2 = rw
-           3 = execute
-         */
-        pSMB->Mode = cpu_to_le16(2);
+        pSMB->Mode = cpu_to_le16(access_flags_to_smbopen_mode(access_flags));
         pSMB->Mode |= cpu_to_le16(0x40); /* deny none */
         /* set file as system file if special file such
            as fifo and server expecting SFU style and
@@ -1247,7 +1289,7 @@ OldOpenRetry:
         } else {
         /* BB verify if wct == 15 */
 
-/*              *pOplock = pSMBr->OplockLevel; */  /* BB take from action field BB */
+/*              *pOplock = pSMBr->OplockLevel; */ /* BB take from action field*/
 
                 *netfid = pSMBr->Fid;   /* cifs fid stays in le */
                 /* Let caller know file was created so we can set the mode. */
@@ -1686,7 +1728,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
 {
         int rc = 0;
         LOCK_REQ *pSMB = NULL;
-        LOCK_RSP *pSMBr = NULL;
+/*      LOCK_RSP *pSMBr = NULL; */ /* No response data other than rc to parse */
         int bytes_returned;
         int timeout = 0;
         __u16 count;
@@ -1697,8 +1739,6 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
         if (rc)
                 return rc;
 
-        pSMBr = (LOCK_RSP *)pSMB; /* BB removeme BB */
-
         if (lockType == LOCKING_ANDX_OPLOCK_RELEASE) {
                 timeout = CIFS_ASYNC_OP; /* no response expected */
                 pSMB->Timeout = 0;
@@ -1732,7 +1772,7 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
 
         if (waitFlag) {
                 rc = SendReceiveBlockingLock(xid, tcon, (struct smb_hdr *) pSMB,
-                        (struct smb_hdr *) pSMBr, &bytes_returned);
+                        (struct smb_hdr *) pSMB, &bytes_returned);
                 cifs_small_buf_release(pSMB);
         } else {
                 rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *)pSMB,
@@ -1767,7 +1807,7 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
         cFYI(1, ("Posix Lock"));
 
         if (pLockData == NULL)
-                return EINVAL;
+                return -EINVAL;
 
         rc = small_smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB);
 
@@ -1944,7 +1984,7 @@ renameRetry:
         /* protocol requires ASCII signature byte on Unicode string */
                 pSMB->OldFileName[name_len + 1] = 0x00;
                 name_len2 =
-                    cifsConvertToUCS((__le16 *) &pSMB->OldFileName[name_len + 2],
+                    cifsConvertToUCS((__le16 *)&pSMB->OldFileName[name_len + 2],
                                      toName, PATH_MAX, nls_codepage, remap);
                 name_len2 += 1 /* trailing null */  + 1 /* Signature word */ ;
                 name_len2 *= 2; /* convert to bytes */
@@ -2117,8 +2157,7 @@ copyRetry:
                 cFYI(1, ("Send error in copy = %d with %d files copied",
                         rc, le16_to_cpu(pSMBr->CopyCount)));
         }
-        if (pSMB)
-                cifs_buf_release(pSMB);
+        cifs_buf_release(pSMB);
 
         if (rc == -EAGAIN)
                 goto copyRetry;
@@ -2207,8 +2246,7 @@ createSymLinkRetry:
         if (rc)
                 cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
 
-        if (pSMB)
-                cifs_buf_release(pSMB);
+        cifs_buf_release(pSMB);
 
         if (rc == -EAGAIN)
                 goto createSymLinkRetry;
@@ -2925,7 +2963,8 @@ setAclRetry:
         }
         params = 6 + name_len;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
+        /* BB find max SMB size from sess */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -3322,7 +3361,8 @@ QPathInfoRetry:
         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(4000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -3388,7 +3428,7 @@ QPathInfoRetry:
 int
 CIFSSMBUnixQPathInfo(const int xid, struct cifsTconInfo *tcon,
                      const unsigned char *searchName,
-                     FILE_UNIX_BASIC_INFO * pFindData,
+                     FILE_UNIX_BASIC_INFO *pFindData,
                      const struct nls_table *nls_codepage, int remap)
 {
 /* SMB_QUERY_FILE_UNIX_BASIC */
@@ -3679,6 +3719,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
         if (rc) {
                 if (rc == -EBADF) {
                         psrch_inf->endOfSearch = true;
+                        cifs_buf_release(pSMB);
                         rc = 0; /* search probably was closed at end of search*/
                 } else
                         cFYI(1, ("FindNext returned = %d", rc));
@@ -3856,25 +3897,112 @@ GetInodeNumOut:
         return rc;
 }
 
+/* parses DFS refferal V3 structure
+ * caller is responsible for freeing target_nodes
+ * returns:
+ *      on success - 0
+ *      on failure - errno
+ */
+static int
+parse_DFS_referrals(TRANSACTION2_GET_DFS_REFER_RSP *pSMBr,
+                unsigned int *num_of_nodes,
+                struct dfs_info3_param **target_nodes,
+                const struct nls_table *nls_codepage)
+{
+        int i, rc = 0;
+        char *data_end;
+        bool is_unicode;
+        struct dfs_referral_level_3 *ref;
+
+        is_unicode = pSMBr->hdr.Flags2 & SMBFLG2_UNICODE;
+        *num_of_nodes = le16_to_cpu(pSMBr->NumberOfReferrals);
+
+        if (*num_of_nodes < 1) {
+                cERROR(1, ("num_referrals: must be at least > 0,"
+                        "but we get num_referrals = %d\n", *num_of_nodes));
+                rc = -EINVAL;
+                goto parse_DFS_referrals_exit;
+        }
+
+        ref = (struct dfs_referral_level_3 *) &(pSMBr->referrals);
+        if (ref->VersionNumber != cpu_to_le16(3)) {
+                cERROR(1, ("Referrals of V%d version are not supported,"
+                        "should be V3", le16_to_cpu(ref->VersionNumber)));
+                rc = -EINVAL;
+                goto parse_DFS_referrals_exit;
+        }
+
+        /* get the upper boundary of the resp buffer */
+        data_end = (char *)(&(pSMBr->PathConsumed)) +
+                                le16_to_cpu(pSMBr->t2.DataCount);
+
+        cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n",
+                        *num_of_nodes,
+                        le16_to_cpu(pSMBr->DFSFlags)));
+
+        *target_nodes = kzalloc(sizeof(struct dfs_info3_param) *
+                        *num_of_nodes, GFP_KERNEL);
+        if (*target_nodes == NULL) {
+                cERROR(1, ("Failed to allocate buffer for target_nodes\n"));
+                rc = -ENOMEM;
+                goto parse_DFS_referrals_exit;
+        }
+
+        /* collect neccessary data from referrals */
+        for (i = 0; i < *num_of_nodes; i++) {
+                char *temp;
+                int max_len;
+                struct dfs_info3_param *node = (*target_nodes)+i;
+
+                node->flags = le16_to_cpu(pSMBr->DFSFlags);
+                node->path_consumed = le16_to_cpu(pSMBr->PathConsumed);
+                node->server_type = le16_to_cpu(ref->ServerType);
+                node->ref_flag = le16_to_cpu(ref->ReferralEntryFlags);
+
+                /* copy DfsPath */
+                temp = (char *)ref + le16_to_cpu(ref->DfsPathOffset);
+                max_len = data_end - temp;
+                rc = cifs_strncpy_to_host(&(node->path_name), temp,
+                                        max_len, is_unicode, nls_codepage);
+                if (rc)
+                        goto parse_DFS_referrals_exit;
+
+                /* copy link target UNC */
+                temp = (char *)ref + le16_to_cpu(ref->NetworkAddressOffset);
+                max_len = data_end - temp;
+                rc = cifs_strncpy_to_host(&(node->node_name), temp,
+                                        max_len, is_unicode, nls_codepage);
+                if (rc)
+                        goto parse_DFS_referrals_exit;
+
+                ref += le16_to_cpu(ref->Size);
+        }
+
+parse_DFS_referrals_exit:
+        if (rc) {
+                free_dfs_info_array(*target_nodes, *num_of_nodes);
+                *target_nodes = NULL;
+                *num_of_nodes = 0;
+        }
+        return rc;
+}
+
 int
 CIFSGetDFSRefer(const int xid, struct cifsSesInfo *ses,
                 const unsigned char *searchName,
-                unsigned char **targetUNCs,
-                unsigned int *number_of_UNC_in_array,
+                struct dfs_info3_param **target_nodes,
+                unsigned int *num_of_nodes,
                 const struct nls_table *nls_codepage, int remap)
 {
 /* TRANS2_GET_DFS_REFERRAL */
         TRANSACTION2_GET_DFS_REFER_REQ *pSMB = NULL;
         TRANSACTION2_GET_DFS_REFER_RSP *pSMBr = NULL;
-        struct dfs_referral_level_3 *referrals = NULL;
         int rc = 0;
         int bytes_returned;
         int name_len;
-        unsigned int i;
-        char *temp;
         __u16 params, byte_count;
-        *number_of_UNC_in_array = 0;
-        *targetUNCs = NULL;
+        *num_of_nodes = 0;
+        *target_nodes = NULL;
 
         cFYI(1, ("In GetDFSRefer the path %s", searchName));
         if (ses == NULL)
@@ -3921,7 +4049,8 @@ getDFSRetry:
         pSMB->DataCount = 0;
         pSMB->DataOffset = 0;
         pSMB->MaxParameterCount = 0;
-        pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(4000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -3943,103 +4072,26 @@ getDFSRetry:
                          (struct smb_hdr *) pSMBr, &bytes_returned, 0);
         if (rc) {
                 cFYI(1, ("Send error in GetDFSRefer = %d", rc));
-        } else {                /* decode response */
-/* BB Add logic to parse referrals here */
-                rc = validate_t2((struct smb_t2_rsp *)pSMBr);
+                goto GetDFSRefExit;
+        }
+        rc = validate_t2((struct smb_t2_rsp *)pSMBr);
 
-                /* BB Also check if enough total bytes returned? */
-                if (rc || (pSMBr->ByteCount < 17))
-                        rc = -EIO;      /* bad smb */
-                else {
-                        __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
-                        __u16 data_count = le16_to_cpu(pSMBr->t2.DataCount);
+        /* BB Also check if enough total bytes returned? */
+        if (rc || (pSMBr->ByteCount < 17)) {
+                rc = -EIO;      /* bad smb */
+                goto GetDFSRefExit;
+        }
 
-                        cFYI(1,
-                            ("Decoding GetDFSRefer response BCC: %d  Offset %d",
-                              pSMBr->ByteCount, data_offset));
-                        referrals =
-                            (struct dfs_referral_level_3 *)
-                                        (8 /* sizeof start of data block */ +
-                                        data_offset +
-                                        (char *) &pSMBr->hdr.Protocol);
-                        cFYI(1, ("num_referrals: %d dfs flags: 0x%x ... \n"
-                                "for referral one refer size: 0x%x srv "
-                                "type: 0x%x refer flags: 0x%x ttl: 0x%x",
-                                le16_to_cpu(pSMBr->NumberOfReferrals),
-                                le16_to_cpu(pSMBr->DFSFlags),
-                                le16_to_cpu(referrals->ReferralSize),
-                                le16_to_cpu(referrals->ServerType),
-                                le16_to_cpu(referrals->ReferralFlags),
-                                le16_to_cpu(referrals->TimeToLive)));
-                        /* BB This field is actually two bytes in from start of
-                           data block so we could do safety check that DataBlock
-                           begins at address of pSMBr->NumberOfReferrals */
-                        *number_of_UNC_in_array =
-                                        le16_to_cpu(pSMBr->NumberOfReferrals);
-
-                        /* BB Fix below so can return more than one referral */
-                        if (*number_of_UNC_in_array > 1)
-                                *number_of_UNC_in_array = 1;
-
-                        /* get the length of the strings describing refs */
-                        name_len = 0;
-                        for (i = 0; i < *number_of_UNC_in_array; i++) {
-                                /* make sure that DfsPathOffset not past end */
-                                __u16 offset =
-                                        le16_to_cpu(referrals->DfsPathOffset);
-                                if (offset > data_count) {
-                                        /* if invalid referral, stop here and do
-                                        not try to copy any more */
-                                        *number_of_UNC_in_array = i;
-                                        break;
-                                }
-                                temp = ((char *)referrals) + offset;
+        cFYI(1, ("Decoding GetDFSRefer response BCC: %d  Offset %d",
+                                pSMBr->ByteCount,
+                                le16_to_cpu(pSMBr->t2.DataOffset)));
 
-                                if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
-                                        name_len += UniStrnlen((wchar_t *)temp,
-                                                                data_count);
-                                } else {
-                                        name_len += strnlen(temp, data_count);
-                                }
-                                referrals++;
-                                /* BB add check that referral pointer does
-                                   not fall off end PDU */
-                        }
-                        /* BB add check for name_len bigger than bcc */
-                        *targetUNCs =
-                                kmalloc(name_len+1+(*number_of_UNC_in_array),
-                                        GFP_KERNEL);
-                        if (*targetUNCs == NULL) {
-                                rc = -ENOMEM;
-                                goto GetDFSRefExit;
-                        }
-                        /* copy the ref strings */
-                        referrals = (struct dfs_referral_level_3 *)
-                                        (8 /* sizeof data hdr */ + data_offset +
-                                        (char *) &pSMBr->hdr.Protocol);
-
-                        for (i = 0; i < *number_of_UNC_in_array; i++) {
-                                temp = ((char *)referrals) +
-                                          le16_to_cpu(referrals->DfsPathOffset);
-                                if (pSMBr->hdr.Flags2 & SMBFLG2_UNICODE) {
-                                        cifs_strfromUCS_le(*targetUNCs,
-                                                          (__le16 *) temp,
-                                                          name_len,
-                                                          nls_codepage);
-                                } else {
-                                        strncpy(*targetUNCs, temp, name_len);
-                                }
-                                /*  BB update target_uncs pointers */
-                                referrals++;
-                        }
-                        temp = *targetUNCs;
-                        temp[name_len] = 0;
-                }
+        /* parse returned result into more usable form */
+        rc = parse_DFS_referrals(pSMBr, num_of_nodes,
+                                 target_nodes, nls_codepage);
 
-        }
 GetDFSRefExit:
-        if (pSMB)
-                cifs_buf_release(pSMB);
+        cifs_buf_release(pSMB);
 
         if (rc == -EAGAIN)
                 goto getDFSRetry;
@@ -4229,7 +4281,8 @@ QFSAttributeRetry:
         params = 2;     /* level */
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -4298,7 +4351,8 @@ QFSDeviceRetry:
         params = 2;     /* level */
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -4369,7 +4423,8 @@ QFSUnixRetry:
         pSMB->DataCount = 0;
         pSMB->DataOffset = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(100);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -4444,7 +4499,8 @@ SETFSUnixRetry:
         offset = param_offset + params;
 
         pSMB->MaxParameterCount = cpu_to_le16(4);
-        pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(100);
         pSMB->SetupCount = 1;
         pSMB->Reserved3 = 0;
         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FS_INFORMATION);
@@ -4512,7 +4568,8 @@ QFSPosixRetry:
         pSMB->DataCount = 0;
         pSMB->DataOffset = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(100);  /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(100);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -4702,7 +4759,8 @@ CIFSSMBSetFileSize(const int xid, struct cifsTconInfo *tcon, __u64 size,
 
         count = sizeof(struct file_end_of_file_info);
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->SetupCount = 1;
         pSMB->Reserved3 = 0;
         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
@@ -4789,7 +4847,8 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
 
         count = sizeof(FILE_BASIC_INFO);
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
+        /* BB find max SMB PDU from sess */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->SetupCount = 1;
         pSMB->Reserved3 = 0;
         pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
@@ -4856,7 +4915,8 @@ SetTimesRetry:
         params = 6 + name_len;
         count = sizeof(FILE_BASIC_INFO);
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -4986,7 +5046,8 @@ setPermsRetry:
         params = 6 + name_len;
         count = sizeof(FILE_UNIX_BASIC_INFO);
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -5051,8 +5112,7 @@ setPermsRetry:
         if (rc)
                 cFYI(1, ("SetPathInfo (perms) returned %d", rc));
 
-        if (pSMB)
-                cifs_buf_release(pSMB);
+        cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
                 goto setPermsRetry;
         return rc;
@@ -5169,7 +5229,8 @@ QAllEAsRetry:
         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(4000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -5273,8 +5334,7 @@ QAllEAsRetry:
                         }
                 }
         }
-        if (pSMB)
-                cifs_buf_release(pSMB);
+        cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
                 goto QAllEAsRetry;
 
@@ -5317,7 +5377,8 @@ QEARetry:
         params = 2 /* level */ + 4 /* reserved */ + name_len /* includes NUL */;
         pSMB->TotalDataCount = 0;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
+        /* BB find exact max SMB PDU from sess structure BB */
+        pSMB->MaxDataCount = cpu_to_le16(4000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
@@ -5422,8 +5483,7 @@ QEARetry:
                         }
                 }
         }
-        if (pSMB)
-                cifs_buf_release(pSMB);
+        cifs_buf_release(pSMB);
         if (rc == -EAGAIN)
                 goto QEARetry;
 
@@ -5475,7 +5535,8 @@ SetEARetry:
 
         count = sizeof(*parm_data) + ea_value_len + name_len;
         pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB size from sess */
+        /* BB find max SMB PDU from sess */
+        pSMB->MaxDataCount = cpu_to_le16(1000);
         pSMB->MaxSetupCount = 0;
         pSMB->Reserved = 0;
         pSMB->Flags = 0;
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index f428bf3bf1a9..e8fa46c7cff2 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -60,7 +60,7 @@ struct smb_vol {
         char *domainname;
         char *UNC;
         char *UNCip;
-        char *in6_addr;  /* ipv6 address as human readable form of in6_addr */
+        char *in6_addr;   /* ipv6 address as human readable form of in6_addr */
         char *iocharset;  /* local code page for mapping to and from Unicode */
         char source_rfc1001_name[16]; /* netbios name of client */
         char target_rfc1001_name[16]; /* netbios name of server for Win9x/ME */
@@ -75,19 +75,21 @@ struct smb_vol {
         bool setuids:1;
         bool override_uid:1;
         bool override_gid:1;
+        bool dynperm:1;
         bool noperm:1;
         bool no_psx_acl:1; /* set if posix acl support should be disabled */
         bool cifs_acl:1;
         bool no_xattr:1;   /* set if xattr (EA) support should be disabled*/
         bool server_ino:1; /* use inode numbers from server ie UniqueId */
         bool direct_io:1;
-        bool remap:1;     /* set to remap seven reserved chars in filenames */
-        bool posix_paths:1;   /* unset to not ask for posix pathnames. */
+        bool remap:1;      /* set to remap seven reserved chars in filenames */
+        bool posix_paths:1; /* unset to not ask for posix pathnames. */
         bool no_linux_ext:1;
         bool sfu_emul:1;
-        bool nullauth:1; /* attempt to authenticate with null user */
-        unsigned nocase;     /* request case insensitive filenames */
-        unsigned nobrl;      /* disable sending byte range locks to srv */
+        bool nullauth:1;   /* attempt to authenticate with null user */
+        bool nocase:1;     /* request case insensitive filenames */
+        bool nobrl:1;      /* disable sending byte range locks to srv */
+        bool seal:1;       /* request transport encryption on share */
         unsigned int rsize;
         unsigned int wsize;
         unsigned int sockopt;
@@ -651,6 +653,7 @@ multi_t2_fnd:
         spin_lock(&GlobalMid_Lock);
         server->tcpStatus = CifsExiting;
         spin_unlock(&GlobalMid_Lock);
+        wake_up_all(&server->response_q);
 
         /* don't exit until kthread_stop is called */
         set_current_state(TASK_UNINTERRUPTIBLE);
@@ -1246,6 +1249,10 @@ cifs_parse_mount_options(char *options, const char *devname,
                         vol->setuids = 1;
                 } else if (strnicmp(data, "nosetuids", 9) == 0) {
                         vol->setuids = 0;
+                } else if (strnicmp(data, "dynperm", 7) == 0) {
+                        vol->dynperm = true;
+                } else if (strnicmp(data, "nodynperm", 9) == 0) {
+                        vol->dynperm = false;
                 } else if (strnicmp(data, "nohard", 6) == 0) {
                         vol->retry = 0;
                 } else if (strnicmp(data, "nosoft", 6) == 0) {
@@ -1268,8 +1275,12 @@ cifs_parse_mount_options(char *options, const char *devname,
                         vol->no_psx_acl = 1;
                 } else if (strnicmp(data, "sign", 4) == 0) {
                         vol->secFlg |= CIFSSEC_MUST_SIGN;
-/*              } else if (strnicmp(data, "seal",4) == 0) {
-                        vol->secFlg |= CIFSSEC_MUST_SEAL; */
+                } else if (strnicmp(data, "seal", 4) == 0) {
+                        /* we do not do the following in secFlags because seal
+                           is a per tree connection (mount) not a per socket
+                           or per-smb connection option in the protocol */
+                        /* vol->secFlg |= CIFSSEC_MUST_SEAL; */
+                        vol->seal = 1;
                 } else if (strnicmp(data, "direct", 6) == 0) {
                         vol->direct_io = 1;
                 } else if (strnicmp(data, "forcedirectio", 13) == 0) {
@@ -1414,34 +1425,12 @@ find_unc(__be32 new_target_ip_addr, char *uncName, char *userName)
 }
 
 int
-connect_to_dfs_path(int xid, struct cifsSesInfo *pSesInfo,
-                    const char *old_path, const struct nls_table *nls_codepage,
-                    int remap)
-{
-        struct dfs_info3_param *referrals = NULL;
-        unsigned int num_referrals;
-        int rc = 0;
-
-        rc = get_dfs_path(xid, pSesInfo, old_path, nls_codepage,
-                        &num_referrals, &referrals, remap);
-
-        /* BB Add in code to: if valid refrl, if not ip address contact
-                the helper that resolves tcp names, mount to it, try to
-                tcon to it unmount it if fail */
-
-        kfree(referrals);
-
-        return rc;
-}
-
-int
 get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
              const struct nls_table *nls_codepage, unsigned int *pnum_referrals,
              struct dfs_info3_param **preferrals, int remap)
 {
         char *temp_unc;
         int rc = 0;
-        unsigned char *targetUNCs;
 
         *pnum_referrals = 0;
         *preferrals = NULL;
@@ -1464,7 +1453,7 @@ get_dfs_path(int xid, struct cifsSesInfo *pSesInfo, const char *old_path,
                 kfree(temp_unc);
         }
         if (rc == 0)
-                rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, &targetUNCs,
+                rc = CIFSGetDFSRefer(xid, pSesInfo, old_path, preferrals,
                                      pnum_referrals, nls_codepage, remap);
         /* BB map targetUNCs to dfs_info3 structures, here or
                 in CIFSGetDFSRefer BB */
@@ -1815,7 +1804,7 @@ convert_delimiter(char *path, char delim)
         if (path == NULL)
                 return;
 
-        if (delim == '/') 
+        if (delim == '/')
                 old_delim = '\\';
         else
                 old_delim = '/';
@@ -2125,11 +2114,17 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_UID;
                 if (volume_info.override_gid)
                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_OVERR_GID;
+                if (volume_info.dynperm)
+                        cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DYNPERM;
                 if (volume_info.direct_io) {
                         cFYI(1, ("mounting share using direct i/o"));
                         cifs_sb->mnt_cifs_flags |= CIFS_MOUNT_DIRECT_IO;
                 }
 
+                if ((volume_info.cifs_acl) && (volume_info.dynperm))
+                        cERROR(1, ("mount option dynperm ignored if cifsacl "
+                                   "mount option supported"));
+
                 tcon =
                     find_unc(sin_server.sin_addr.s_addr, volume_info.UNC,
                              volume_info.username);
@@ -2141,6 +2136,9 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                            for the retry flag is used */
                         tcon->retry = volume_info.retry;
                         tcon->nocase = volume_info.nocase;
+                        if (tcon->seal != volume_info.seal)
+                                cERROR(1, ("transport encryption setting "
+                                           "conflicts with existing tid"));
                 } else {
                         tcon = tconInfoAlloc();
                         if (tcon == NULL)
@@ -2154,10 +2152,11 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                 if ((strchr(volume_info.UNC + 3, '\\') == NULL)
                                     && (strchr(volume_info.UNC + 3, '/') ==
                                         NULL)) {
-                                        rc = connect_to_dfs_path(xid, pSesInfo,
+/*                                      rc = connect_to_dfs_path(xid, pSesInfo,
                                                 "", cifs_sb->local_nls,
                                                 cifs_sb->mnt_cifs_flags &
-                                                  CIFS_MOUNT_MAP_SPECIAL_CHR);
+                                                  CIFS_MOUNT_MAP_SPECIAL_CHR);*/
+                                        cFYI(1, ("DFS root not supported"));
                                         rc = -ENODEV;
                                         goto out;
                                 } else {
@@ -2173,6 +2172,7 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                         atomic_inc(&pSesInfo->inUse);
                                         tcon->retry = volume_info.retry;
                                         tcon->nocase = volume_info.nocase;
+                                        tcon->seal = volume_info.seal;
                                 }
                         }
                 }
@@ -2314,9 +2314,10 @@ CIFSSessSetup(unsigned int xid, struct cifsSesInfo *ses,
         user = ses->userName;
         domain = ses->domainName;
         smb_buffer = cifs_buf_get();
-        if (smb_buffer == NULL) {
+
+        if (smb_buffer == NULL)
                 return -ENOMEM;
-        }
+
         smb_buffer_response = smb_buffer;
         pSMBr = pSMB = (SESSION_SETUP_ANDX *) smb_buffer;
 
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index e4e0078a0526..fb69c1fa85c9 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -49,18 +49,25 @@ build_path_from_dentry(struct dentry *direntry)
         struct dentry *temp;
         int namelen;
         int pplen;
+        int dfsplen;
         char *full_path;
         char dirsep;
+        struct cifs_sb_info *cifs_sb;
 
         if (direntry == NULL)
                 return NULL;  /* not much we can do if dentry is freed and
                 we need to reopen the file after it was closed implicitly
                 when the server crashed */
 
-        dirsep = CIFS_DIR_SEP(CIFS_SB(direntry->d_sb));
-        pplen = CIFS_SB(direntry->d_sb)->prepathlen;
+        cifs_sb = CIFS_SB(direntry->d_sb);
+        dirsep = CIFS_DIR_SEP(cifs_sb);
+        pplen = cifs_sb->prepathlen;
+        if (cifs_sb->tcon && (cifs_sb->tcon->Flags & SMB_SHARE_IS_IN_DFS))
+                dfsplen = strnlen(cifs_sb->tcon->treeName, MAX_TREE_SIZE + 1);
+        else
+                dfsplen = 0;
 cifs_bp_rename_retry:
-        namelen = pplen;
+        namelen = pplen + dfsplen;
         for (temp = direntry; !IS_ROOT(temp);) {
                 namelen += (1 + temp->d_name.len);
                 temp = temp->d_parent;
@@ -91,7 +98,7 @@ cifs_bp_rename_retry:
                         return NULL;
                 }
         }
-        if (namelen != pplen) {
+        if (namelen != pplen + dfsplen) {
                 cERROR(1,
                        ("did not end path lookup where expected namelen is %d",
                         namelen));
@@ -107,7 +114,18 @@ cifs_bp_rename_retry:
            since the '\' is a valid posix character so we can not switch
            those safely to '/' if any are found in the middle of the prepath */
         /* BB test paths to Windows with '/' in the midst of prepath */
-        strncpy(full_path, CIFS_SB(direntry->d_sb)->prepath, pplen);
+
+        if (dfsplen) {
+                strncpy(full_path, cifs_sb->tcon->treeName, dfsplen);
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) {
+                        int i;
+                        for (i = 0; i < dfsplen; i++) {
+                                if (full_path[i] == '\\')
+                                        full_path[i] = '/';
+                        }
+                }
+        }
+        strncpy(full_path + dfsplen, CIFS_SB(direntry->d_sb)->prepath, pplen);
         return full_path;
 }
 
@@ -242,7 +260,9 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                                                  buf, inode->i_sb, xid,
                                                  &fileHandle);
                         if (newinode) {
-                                newinode->i_mode = mode;
+                                if (cifs_sb->mnt_cifs_flags &
+                                    CIFS_MOUNT_DYNPERM)
+                                        newinode->i_mode = mode;
                                 if ((oplock & CIFS_CREATE_ACTION) &&
                                     (cifs_sb->mnt_cifs_flags &
                                      CIFS_MOUNT_SET_UID)) {
@@ -590,7 +610,7 @@ static int cifs_ci_compare(struct dentry *dentry, struct qstr *a,
                  * case take precedence.  If a is not a negative dentry, this
                  * should have no side effects
                  */
-                memcpy(a->name, b->name, a->len);
+                memcpy((void *)a->name, b->name, a->len);
                 return 0;
         }
         return 1;
diff --git a/fs/cifs/dns_resolve.c b/fs/cifs/dns_resolve.c
index 939e256f8497..f730ef35499e 100644
--- a/fs/cifs/dns_resolve.c
+++ b/fs/cifs/dns_resolve.c
@@ -134,10 +134,6 @@ dns_resolve_server_name_to_ip(const char *unc, char **ip_addr)
         rkey = request_key(&key_type_dns_resolver, name, "");
         if (!IS_ERR(rkey)) {
                 data = rkey->payload.data;
-                cFYI(1, ("%s: resolved: %s to %s", __func__,
-                                        rkey->description,
-                                        *ip_addr
-                                ));
         } else {
                 cERROR(1, ("%s: unable to resolve: %s", __func__, name));
                 goto out;
@@ -150,6 +146,11 @@ skip_upcall:
                 if (*ip_addr) {
                         memcpy(*ip_addr, data, len);
                         (*ip_addr)[len] = '\0';
+                        if (!IS_ERR(rkey))
+                                cFYI(1, ("%s: resolved: %s to %s", __func__,
+                                                        name,
+                                                        *ip_addr
+                                        ));
                         rc = 0;
                 } else {
                         rc = -ENOMEM;
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 31a0a33b9d95..0aac824371a5 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -75,7 +75,11 @@ static inline int cifs_convert_flags(unsigned int flags)
                 return (GENERIC_READ | GENERIC_WRITE);
         }
 
-        return 0x20197;
+        return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
+                FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
+                FILE_READ_DATA);
+
+
 }
 
 static inline int cifs_get_disposition(unsigned int flags)
@@ -542,7 +546,6 @@ int cifs_close(struct inode *inode, struct file *file)
                         msleep(timeout);
                         timeout *= 8;
                 }
-                kfree(pSMBFile->search_resume_name);
                 kfree(file->private_data);
                 file->private_data = NULL;
         } else
@@ -601,12 +604,6 @@ int cifs_closedir(struct inode *inode, struct file *file)
                         else
                                 cifs_buf_release(ptmp);
                 }
-                ptmp = pCFileStruct->search_resume_name;
-                if (ptmp) {
-                        cFYI(1, ("closedir free resume name"));
-                        pCFileStruct->search_resume_name = NULL;
-                        kfree(ptmp);
-                }
                 kfree(file->private_data);
                 file->private_data = NULL;
         }
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index fcbdbb6ad7bf..722be543ceec 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -161,118 +161,115 @@ static void cifs_unix_info_to_inode(struct inode *inode,
         spin_unlock(&inode->i_lock);
 }
 
-static const unsigned char *cifs_get_search_path(struct cifs_sb_info *cifs_sb,
-                                                const char *search_path)
-{
-        int tree_len;
-        int path_len;
-        int i;
-        char *tmp_path;
-        struct cifsTconInfo *pTcon = cifs_sb->tcon;
-
-        if (!(pTcon->Flags & SMB_SHARE_IS_IN_DFS))
-                return search_path;
-
-        /* use full path name for working with DFS */
-        tree_len = strnlen(pTcon->treeName, MAX_TREE_SIZE + 1);
-        path_len = strnlen(search_path, MAX_PATHCONF);
 
-        tmp_path = kmalloc(tree_len+path_len+1, GFP_KERNEL);
-        if (tmp_path == NULL)
-                return search_path;
+/*
+ *      Needed to setup inode data for the directory which is the
+ *      junction to the new submount (ie to setup the fake directory
+ *      which represents a DFS referral)
+ */
+static void fill_fake_finddataunix(FILE_UNIX_BASIC_INFO *pfnd_dat,
+                               struct super_block *sb)
+{
+        struct inode *pinode = NULL;
+
+        memset(pfnd_dat, 0, sizeof(FILE_UNIX_BASIC_INFO));
+
+/*      __le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
+        __le64 pfnd_dat->NumOfBytes = cpu_to_le64(0);
+        __u64 UniqueId = 0;  */
+        pfnd_dat->LastStatusChange =
+                cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
+        pfnd_dat->LastAccessTime =
+                cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
+        pfnd_dat->LastModificationTime =
+                cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
+        pfnd_dat->Type = cpu_to_le32(UNIX_DIR);
+        pfnd_dat->Permissions = cpu_to_le64(S_IXUGO | S_IRWXU);
+        pfnd_dat->Nlinks = cpu_to_le64(2);
+        if (sb->s_root)
+                pinode = sb->s_root->d_inode;
+        if (pinode == NULL)
+                return;
 
-        strncpy(tmp_path, pTcon->treeName, tree_len);
-        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS)
-                for (i = 0; i < tree_len; i++) {
-                        if (tmp_path[i] == '\\')
-                                tmp_path[i] = '/';
-                }
-        strncpy(tmp_path+tree_len, search_path, path_len);
-        tmp_path[tree_len+path_len] = 0;
-        return tmp_path;
+        /* fill in default values for the remaining based on root
+           inode since we can not query the server for this inode info */
+        pfnd_dat->DevMajor = cpu_to_le64(MAJOR(pinode->i_rdev));
+        pfnd_dat->DevMinor = cpu_to_le64(MINOR(pinode->i_rdev));
+        pfnd_dat->Uid = cpu_to_le64(pinode->i_uid);
+        pfnd_dat->Gid = cpu_to_le64(pinode->i_gid);
 }
 
 int cifs_get_inode_info_unix(struct inode **pinode,
-        const unsigned char *search_path, struct super_block *sb, int xid)
+        const unsigned char *full_path, struct super_block *sb, int xid)
 {
         int rc = 0;
-        FILE_UNIX_BASIC_INFO findData;
+        FILE_UNIX_BASIC_INFO find_data;
         struct cifsTconInfo *pTcon;
         struct inode *inode;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
-        const unsigned char *full_path;
         bool is_dfs_referral = false;
+        struct cifsInodeInfo *cifsInfo;
+        __u64 num_of_bytes;
+        __u64 end_of_file;
 
         pTcon = cifs_sb->tcon;
-        cFYI(1, ("Getting info on %s", search_path));
-
-        full_path = cifs_get_search_path(cifs_sb, search_path);
+        cFYI(1, ("Getting info on %s", full_path));
 
-try_again_CIFSSMBUnixQPathInfo:
         /* could have done a find first instead but this returns more info */
-        rc = CIFSSMBUnixQPathInfo(xid, pTcon, full_path, &findData,
+        rc = CIFSSMBUnixQPathInfo(xid, pTcon, full_path, &find_data,
                                   cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
-/*      dump_mem("\nUnixQPathInfo return data", &findData,
-                 sizeof(findData)); */
         if (rc) {
                 if (rc == -EREMOTE && !is_dfs_referral) {
                         is_dfs_referral = true;
-                        if (full_path != search_path) {
-                                kfree(full_path);
-                                full_path = search_path;
-                        }
-                        goto try_again_CIFSSMBUnixQPathInfo;
+                        cFYI(DBG2, ("DFS ref"));
+                        /* for DFS, server does not give us real inode data */
+                        fill_fake_finddataunix(&find_data, sb);
+                        rc = 0;
                 }
-                goto cgiiu_exit;
-        } else {
-                struct cifsInodeInfo *cifsInfo;
-                __u64 num_of_bytes = le64_to_cpu(findData.NumOfBytes);
-                __u64 end_of_file = le64_to_cpu(findData.EndOfFile);
+        }
+        num_of_bytes = le64_to_cpu(find_data.NumOfBytes);
+        end_of_file = le64_to_cpu(find_data.EndOfFile);
 
-                /* get new inode */
+        /* get new inode */
+        if (*pinode == NULL) {
+                *pinode = new_inode(sb);
                 if (*pinode == NULL) {
-                        *pinode = new_inode(sb);
-                        if (*pinode == NULL) {
-                                rc = -ENOMEM;
-                                goto cgiiu_exit;
-                        }
-                        /* Is an i_ino of zero legal? */
-                        /* Are there sanity checks we can use to ensure that
-                           the server is really filling in that field? */
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
-                                (*pinode)->i_ino =
-                                        (unsigned long)findData.UniqueId;
-                        } /* note ino incremented to unique num in new_inode */
-                        if (sb->s_flags & MS_NOATIME)
-                                (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
-
-                        insert_inode_hash(*pinode);
+                        rc = -ENOMEM;
+                goto cgiiu_exit;
                 }
+                /* Is an i_ino of zero legal? */
+                /* note ino incremented to unique num in new_inode */
+                /* Are there sanity checks we can use to ensure that
+                   the server is really filling in that field? */
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM)
+                        (*pinode)->i_ino = (unsigned long)find_data.UniqueId;
 
-                inode = *pinode;
-                cifsInfo = CIFS_I(inode);
+                if (sb->s_flags & MS_NOATIME)
+                        (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
 
-                cFYI(1, ("Old time %ld", cifsInfo->time));
-                cifsInfo->time = jiffies;
-                cFYI(1, ("New time %ld", cifsInfo->time));
-                /* this is ok to set on every inode revalidate */
-                atomic_set(&cifsInfo->inUse, 1);
+                insert_inode_hash(*pinode);
+        }
+
+        inode = *pinode;
+        cifsInfo = CIFS_I(inode);
 
-                cifs_unix_info_to_inode(inode, &findData, 0);
+        cFYI(1, ("Old time %ld", cifsInfo->time));
+        cifsInfo->time = jiffies;
+        cFYI(1, ("New time %ld", cifsInfo->time));
+        /* this is ok to set on every inode revalidate */
+        atomic_set(&cifsInfo->inUse, 1);
 
+        cifs_unix_info_to_inode(inode, &find_data, 0);
 
-                if (num_of_bytes < end_of_file)
-                        cFYI(1, ("allocation size less than end of file"));
-                cFYI(1, ("Size %ld and blocks %llu",
-                        (unsigned long) inode->i_size,
-                        (unsigned long long)inode->i_blocks));
+        if (num_of_bytes < end_of_file)
+                cFYI(1, ("allocation size less than end of file"));
+        cFYI(1, ("Size %ld and blocks %llu",
+                (unsigned long) inode->i_size,
+                (unsigned long long)inode->i_blocks));
 
-                cifs_set_ops(inode, is_dfs_referral);
-        }
+        cifs_set_ops(inode, is_dfs_referral);
 cgiiu_exit:
-        if (full_path != search_path)
-                kfree(full_path);
         return rc;
 }
 
@@ -379,21 +376,52 @@ static int get_sfu_mode(struct inode *inode,
 #endif
 }
 
+/*
+ *      Needed to setup inode data for the directory which is the
+ *      junction to the new submount (ie to setup the fake directory
+ *      which represents a DFS referral)
+ */
+static void fill_fake_finddata(FILE_ALL_INFO *pfnd_dat,
+                               struct super_block *sb)
+{
+        memset(pfnd_dat, 0, sizeof(FILE_ALL_INFO));
+
+/*      __le64 pfnd_dat->AllocationSize = cpu_to_le64(0);
+        __le64 pfnd_dat->EndOfFile = cpu_to_le64(0);
+        __u8 pfnd_dat->DeletePending = 0;
+        __u8 pfnd_data->Directory = 0;
+        __le32 pfnd_dat->EASize = 0;
+        __u64 pfnd_dat->IndexNumber = 0;
+        __u64 pfnd_dat->IndexNumber1 = 0;  */
+        pfnd_dat->CreationTime =
+                cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
+        pfnd_dat->LastAccessTime =
+                cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
+        pfnd_dat->LastWriteTime =
+                cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
+        pfnd_dat->ChangeTime =
+                cpu_to_le64(cifs_UnixTimeToNT(CURRENT_TIME));
+        pfnd_dat->Attributes = cpu_to_le32(ATTR_DIRECTORY);
+        pfnd_dat->NumberOfLinks = cpu_to_le32(2);
+}
+
 int cifs_get_inode_info(struct inode **pinode,
-        const unsigned char *search_path, FILE_ALL_INFO *pfindData,
+        const unsigned char *full_path, FILE_ALL_INFO *pfindData,
         struct super_block *sb, int xid, const __u16 *pfid)
 {
         int rc = 0;
+        __u32 attr;
+        struct cifsInodeInfo *cifsInfo;
         struct cifsTconInfo *pTcon;
         struct inode *inode;
         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
-        const unsigned char *full_path = NULL;
         char *buf = NULL;
         bool adjustTZ = false;
         bool is_dfs_referral = false;
+        umode_t default_mode;
 
         pTcon = cifs_sb->tcon;
-        cFYI(1, ("Getting info on %s", search_path));
+        cFYI(1, ("Getting info on %s", full_path));
 
         if ((pfindData == NULL) && (*pinode != NULL)) {
                 if (CIFS_I(*pinode)->clientCanCacheRead) {
@@ -409,9 +437,6 @@ int cifs_get_inode_info(struct inode **pinode,
                         return -ENOMEM;
                 pfindData = (FILE_ALL_INFO *)buf;
 
-                full_path = cifs_get_search_path(cifs_sb, search_path);
-
-try_again_CIFSSMBQPathInfo:
                 /* could do find first instead but this returns more info */
                 rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
                               0 /* not legacy */,
@@ -429,178 +454,163 @@ try_again_CIFSSMBQPathInfo:
                 }
         }
         /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
-        if (rc) {
-                if (rc == -EREMOTE && !is_dfs_referral) {
-                        is_dfs_referral = true;
-                        if (full_path != search_path) {
-                                kfree(full_path);
-                                full_path = search_path;
-                        }
-                        goto try_again_CIFSSMBQPathInfo;
-                }
+        if (rc == -EREMOTE) {
+                is_dfs_referral = true;
+                fill_fake_finddata(pfindData, sb);
+                rc = 0;
+        } else if (rc)
                 goto cgii_exit;
-        } else {
-                struct cifsInodeInfo *cifsInfo;
-                __u32 attr = le32_to_cpu(pfindData->Attributes);
-
-                /* get new inode */
-                if (*pinode == NULL) {
-                        *pinode = new_inode(sb);
-                        if (*pinode == NULL) {
-                                rc = -ENOMEM;
-                                goto cgii_exit;
-                        }
-                        /* Is an i_ino of zero legal? Can we use that to check
-                           if the server supports returning inode numbers?  Are
-                           there other sanity checks we can use to ensure that
-                           the server is really filling in that field? */
-
-                        /* We can not use the IndexNumber field by default from
-                           Windows or Samba (in ALL_INFO buf) but we can request
-                           it explicitly.  It may not be unique presumably if
-                           the server has multiple devices mounted under one
-                           share */
 
-                        /* There may be higher info levels that work but are
-                           there Windows server or network appliances for which
-                           IndexNumber field is not guaranteed unique? */
+        attr = le32_to_cpu(pfindData->Attributes);
 
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
-                                int rc1 = 0;
-                                __u64 inode_num;
-
-                                rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
-                                        search_path, &inode_num,
+        /* get new inode */
+        if (*pinode == NULL) {
+                *pinode = new_inode(sb);
+                if (*pinode == NULL) {
+                        rc = -ENOMEM;
+                        goto cgii_exit;
+                }
+                /* Is an i_ino of zero legal? Can we use that to check
+                   if the server supports returning inode numbers?  Are
+                   there other sanity checks we can use to ensure that
+                   the server is really filling in that field? */
+
+                /* We can not use the IndexNumber field by default from
+                   Windows or Samba (in ALL_INFO buf) but we can request
+                   it explicitly.  It may not be unique presumably if
+                   the server has multiple devices mounted under one share */
+
+                /* There may be higher info levels that work but are
+                   there Windows server or network appliances for which
+                   IndexNumber field is not guaranteed unique? */
+
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
+                        int rc1 = 0;
+                        __u64 inode_num;
+
+                        rc1 = CIFSGetSrvInodeNumber(xid, pTcon,
+                                        full_path, &inode_num,
                                         cifs_sb->local_nls,
                                         cifs_sb->mnt_cifs_flags &
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
-                                if (rc1) {
-                                        cFYI(1, ("GetSrvInodeNum rc %d", rc1));
-                                        /* BB EOPNOSUPP disable SERVER_INUM? */
-                                } else /* do we need cast or hash to ino? */
-                                        (*pinode)->i_ino = inode_num;
-                        } /* else ino incremented to unique num in new_inode*/
-                        if (sb->s_flags & MS_NOATIME)
-                                (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
-                        insert_inode_hash(*pinode);
-                }
-                inode = *pinode;
-                cifsInfo = CIFS_I(inode);
-                cifsInfo->cifsAttrs = attr;
-                cFYI(1, ("Old time %ld", cifsInfo->time));
-                cifsInfo->time = jiffies;
-                cFYI(1, ("New time %ld", cifsInfo->time));
-
-                /* blksize needs to be multiple of two. So safer to default to
-                blksize and blkbits set in superblock so 2**blkbits and blksize
-                will match rather than setting to:
-                (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
-
-                /* Linux can not store file creation time so ignore it */
-                if (pfindData->LastAccessTime)
-                        inode->i_atime = cifs_NTtimeToUnix
-                                (le64_to_cpu(pfindData->LastAccessTime));
-                else /* do not need to use current_fs_time - time not stored */
-                        inode->i_atime = CURRENT_TIME;
-                inode->i_mtime =
+                        if (rc1) {
+                                cFYI(1, ("GetSrvInodeNum rc %d", rc1));
+                                /* BB EOPNOSUPP disable SERVER_INUM? */
+                        } else /* do we need cast or hash to ino? */
+                                (*pinode)->i_ino = inode_num;
+                } /* else ino incremented to unique num in new_inode*/
+                if (sb->s_flags & MS_NOATIME)
+                        (*pinode)->i_flags |= S_NOATIME | S_NOCMTIME;
+                insert_inode_hash(*pinode);
+        }
+        inode = *pinode;
+        cifsInfo = CIFS_I(inode);
+        cifsInfo->cifsAttrs = attr;
+        cFYI(1, ("Old time %ld", cifsInfo->time));
+        cifsInfo->time = jiffies;
+        cFYI(1, ("New time %ld", cifsInfo->time));
+
+        /* blksize needs to be multiple of two. So safer to default to
+        blksize and blkbits set in superblock so 2**blkbits and blksize
+        will match rather than setting to:
+        (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
+
+        /* Linux can not store file creation time so ignore it */
+        if (pfindData->LastAccessTime)
+                inode->i_atime = cifs_NTtimeToUnix
+                        (le64_to_cpu(pfindData->LastAccessTime));
+        else /* do not need to use current_fs_time - time not stored */
+                inode->i_atime = CURRENT_TIME;
+        inode->i_mtime =
                     cifs_NTtimeToUnix(le64_to_cpu(pfindData->LastWriteTime));
-                inode->i_ctime =
-                    cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
-                cFYI(0, ("Attributes came in as 0x%x", attr));
-                if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
-                        inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
-                        inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
-                }
+        inode->i_ctime =
+            cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
+        cFYI(DBG2, ("Attributes came in as 0x%x", attr));
+        if (adjustTZ && (pTcon->ses) && (pTcon->ses->server)) {
+                inode->i_ctime.tv_sec += pTcon->ses->server->timeAdj;
+                inode->i_mtime.tv_sec += pTcon->ses->server->timeAdj;
+        }
 
-                /* set default mode. will override for dirs below */
-                if (atomic_read(&cifsInfo->inUse) == 0)
-                        /* new inode, can safely set these fields */
-                        inode->i_mode = cifs_sb->mnt_file_mode;
-                else /* since we set the inode type below we need to mask off
-                     to avoid strange results if type changes and both
-                     get orred in */
+        /* get default inode mode */
+        if (attr & ATTR_DIRECTORY)
+                default_mode = cifs_sb->mnt_dir_mode;
+        else
+                default_mode = cifs_sb->mnt_file_mode;
+
+        /* set permission bits */
+        if (atomic_read(&cifsInfo->inUse) == 0 ||
+            (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
+                inode->i_mode = default_mode;
+        else {
+                /* just reenable write bits if !ATTR_READONLY */
+                if ((inode->i_mode & S_IWUGO) == 0 &&
+                    (attr & ATTR_READONLY) == 0)
+                        inode->i_mode |= (S_IWUGO & default_mode);
                         inode->i_mode &= ~S_IFMT;
-/*              if (attr & ATTR_REPARSE)  */
-                /* We no longer handle these as symlinks because we could not
-                   follow them due to the absolute path with drive letter */
-                if (attr & ATTR_DIRECTORY) {
-                /* override default perms since we do not do byte range locking
-                   on dirs */
-                        inode->i_mode = cifs_sb->mnt_dir_mode;
-                        inode->i_mode |= S_IFDIR;
-                } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
-                           (cifsInfo->cifsAttrs & ATTR_SYSTEM) &&
-                           /* No need to le64 convert size of zero */
-                           (pfindData->EndOfFile == 0)) {
-                        inode->i_mode = cifs_sb->mnt_file_mode;
+        }
+        /* clear write bits if ATTR_READONLY is set */
+        if (attr & ATTR_READONLY)
+                inode->i_mode &= ~S_IWUGO;
+
+        /* set inode type */
+        if ((attr & ATTR_SYSTEM) &&
+            (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
+                /* no need to fix endianness on 0 */
+                if (pfindData->EndOfFile == 0)
                         inode->i_mode |= S_IFIFO;
-/* BB Finish for SFU style symlinks and devices */
-                } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
-                           (cifsInfo->cifsAttrs & ATTR_SYSTEM)) {
-                        if (decode_sfu_inode(inode,
-                                         le64_to_cpu(pfindData->EndOfFile),
-                                         search_path,
-                                         cifs_sb, xid))
-                                cFYI(1, ("Unrecognized sfu inode type"));
-
-                        cFYI(1, ("sfu mode 0%o", inode->i_mode));
-                } else {
+                else if (decode_sfu_inode(inode,
+                                le64_to_cpu(pfindData->EndOfFile),
+                                full_path, cifs_sb, xid))
+                        cFYI(1, ("unknown SFU file type\n"));
+        } else {
+                if (attr & ATTR_DIRECTORY)
+                        inode->i_mode |= S_IFDIR;
+                else
                         inode->i_mode |= S_IFREG;
-                        /* treat the dos attribute of read-only as read-only
-                           mode e.g. 555 */
-                        if (cifsInfo->cifsAttrs & ATTR_READONLY)
-                                inode->i_mode &= ~(S_IWUGO);
-                        else if ((inode->i_mode & S_IWUGO) == 0)
-                                /* the ATTR_READONLY flag may have been */
-                                /* changed on server -- set any w bits  */
-                                /* allowed by mnt_file_mode             */
-                                inode->i_mode |= (S_IWUGO &
-                                                  cifs_sb->mnt_file_mode);
-                /* BB add code here -
-                   validate if device or weird share or device type? */
-                }
+        }
 
-                spin_lock(&inode->i_lock);
-                if (is_size_safe_to_change(cifsInfo,
-                                           le64_to_cpu(pfindData->EndOfFile))) {
-                        /* can not safely shrink the file size here if the
-                           client is writing to it due to potential races */
-                        i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
-
-                        /* 512 bytes (2**9) is the fake blocksize that must be
-                           used for this calculation */
-                        inode->i_blocks = (512 - 1 + le64_to_cpu(
-                                           pfindData->AllocationSize)) >> 9;
-                }
-                spin_unlock(&inode->i_lock);
+        spin_lock(&inode->i_lock);
+        if (is_size_safe_to_change(cifsInfo,
+                                   le64_to_cpu(pfindData->EndOfFile))) {
+                /* can not safely shrink the file size here if the
+                   client is writing to it due to potential races */
+                i_size_write(inode, le64_to_cpu(pfindData->EndOfFile));
+
+                /* 512 bytes (2**9) is the fake blocksize that must be
+                   used for this calculation */
+                inode->i_blocks = (512 - 1 + le64_to_cpu(
+                                   pfindData->AllocationSize)) >> 9;
+        }
+        spin_unlock(&inode->i_lock);
 
-                inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
+        inode->i_nlink = le32_to_cpu(pfindData->NumberOfLinks);
 
-                /* BB fill in uid and gid here? with help from winbind?
-                   or retrieve from NTFS stream extended attribute */
+        /* BB fill in uid and gid here? with help from winbind?
+           or retrieve from NTFS stream extended attribute */
 #ifdef CONFIG_CIFS_EXPERIMENTAL
-                /* fill in 0777 bits from ACL */
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
-                        cFYI(1, ("Getting mode bits from ACL"));
-                        acl_to_uid_mode(inode, search_path, pfid);
-                }
+        /* fill in 0777 bits from ACL */
+        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
+                cFYI(1, ("Getting mode bits from ACL"));
+                acl_to_uid_mode(inode, full_path, pfid);
+        }
 #endif
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
-                        /* fill in remaining high mode bits e.g. SUID, VTX */
-                        get_sfu_mode(inode, search_path, cifs_sb, xid);
-                } else if (atomic_read(&cifsInfo->inUse) == 0) {
-                        inode->i_uid = cifs_sb->mnt_uid;
-                        inode->i_gid = cifs_sb->mnt_gid;
-                        /* set so we do not keep refreshing these fields with
-                           bad data after user has changed them in memory */
-                        atomic_set(&cifsInfo->inUse, 1);
-                }
-
-                cifs_set_ops(inode, is_dfs_referral);
+        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
+                /* fill in remaining high mode bits e.g. SUID, VTX */
+                get_sfu_mode(inode, full_path, cifs_sb, xid);
+        } else if (atomic_read(&cifsInfo->inUse) == 0) {
+                inode->i_uid = cifs_sb->mnt_uid;
+                inode->i_gid = cifs_sb->mnt_gid;
+                /* set so we do not keep refreshing these fields with
+                   bad data after user has changed them in memory */
+                atomic_set(&cifsInfo->inUse, 1);
         }
+
+        cifs_set_ops(inode, is_dfs_referral);
+
+
+
+
 cgii_exit:
-        if (full_path != search_path)
-                kfree(full_path);
         kfree(buf);
         return rc;
 }
@@ -1005,8 +1015,11 @@ mkdir_get_info:
                                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
                         }
                         if (direntry->d_inode) {
-                                direntry->d_inode->i_mode = mode;
-                                direntry->d_inode->i_mode |= S_IFDIR;
+                                if (cifs_sb->mnt_cifs_flags &
+                                     CIFS_MOUNT_DYNPERM)
+                                        direntry->d_inode->i_mode =
+                                                (mode | S_IFDIR);
+
                                 if (cifs_sb->mnt_cifs_flags &
                                      CIFS_MOUNT_SET_UID) {
                                         direntry->d_inode->i_uid =
@@ -1502,8 +1515,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                                 int oplock = 0;
 
                                 rc = SMBLegacyOpen(xid, pTcon, full_path,
-                                        FILE_OPEN,
-                                        SYNCHRONIZE | FILE_WRITE_ATTRIBUTES,
+                                        FILE_OPEN, GENERIC_WRITE,
                                         CREATE_NOT_DIR, &netfid, &oplock,
                                         NULL, cifs_sb->local_nls,
                                         cifs_sb->mnt_cifs_flags &
@@ -1534,13 +1546,26 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                 } else
                         goto cifs_setattr_exit;
         }
-        if (attrs->ia_valid & ATTR_UID) {
-                cFYI(1, ("UID changed to %d", attrs->ia_uid));
-                uid = attrs->ia_uid;
-        }
-        if (attrs->ia_valid & ATTR_GID) {
-                cFYI(1, ("GID changed to %d", attrs->ia_gid));
-                gid = attrs->ia_gid;
+
+        /*
+         * Without unix extensions we can't send ownership changes to the
+         * server, so silently ignore them. This is consistent with how
+         * local DOS/Windows filesystems behave (VFAT, NTFS, etc). With
+         * CIFSACL support + proper Windows to Unix idmapping, we may be
+         * able to support this in the future.
+         */
+        if (!pTcon->unix_ext &&
+            !(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID)) {
+                attrs->ia_valid &= ~(ATTR_UID | ATTR_GID);
+        } else {
+                if (attrs->ia_valid & ATTR_UID) {
+                        cFYI(1, ("UID changed to %d", attrs->ia_uid));
+                        uid = attrs->ia_uid;
+                }
+                if (attrs->ia_valid & ATTR_GID) {
+                        cFYI(1, ("GID changed to %d", attrs->ia_gid));
+                        gid = attrs->ia_gid;
+                }
         }
 
         time_buf.Attributes = 0;
@@ -1550,7 +1575,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                 attrs->ia_valid &= ~ATTR_MODE;
 
         if (attrs->ia_valid & ATTR_MODE) {
-                cFYI(1, ("Mode changed to 0x%x", attrs->ia_mode));
+                cFYI(1, ("Mode changed to 0%o", attrs->ia_mode));
                 mode = attrs->ia_mode;
         }
 
@@ -1565,18 +1590,18 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
 #ifdef CONFIG_CIFS_EXPERIMENTAL
                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
                         rc = mode_to_acl(inode, full_path, mode);
-                else if ((mode & S_IWUGO) == 0) {
-#else
-                if ((mode & S_IWUGO) == 0) {
+                else
 #endif
-                        /* not writeable */
-                        if ((cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
-                                set_dosattr = true;
-                                time_buf.Attributes =
-                                        cpu_to_le32(cifsInode->cifsAttrs |
-                                                    ATTR_READONLY);
-                        }
-                } else if (cifsInode->cifsAttrs & ATTR_READONLY) {
+                if (((mode & S_IWUGO) == 0) &&
+                    (cifsInode->cifsAttrs & ATTR_READONLY) == 0) {
+                        set_dosattr = true;
+                        time_buf.Attributes = cpu_to_le32(cifsInode->cifsAttrs |
+                                                          ATTR_READONLY);
+                        /* fix up mode if we're not using dynperm */
+                        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
+                                attrs->ia_mode = inode->i_mode & ~S_IWUGO;
+                } else if ((mode & S_IWUGO) &&
+                           (cifsInode->cifsAttrs & ATTR_READONLY)) {
                         /* If file is readonly on server, we would
                         not be able to write to it - so if any write
                         bit is enabled for user or group or other we
@@ -1587,6 +1612,20 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                         /* Windows ignores set to zero */
                         if (time_buf.Attributes == 0)
                                 time_buf.Attributes |= cpu_to_le32(ATTR_NORMAL);
+
+                        /* reset local inode permissions to normal */
+                        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
+                                attrs->ia_mode &= ~(S_IALLUGO);
+                                if (S_ISDIR(inode->i_mode))
+                                        attrs->ia_mode |=
+                                                cifs_sb->mnt_dir_mode;
+                                else
+                                        attrs->ia_mode |=
+                                                cifs_sb->mnt_file_mode;
+                        }
+                } else if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM)) {
+                        /* ignore mode change - ATTR_READONLY hasn't changed */
+                        attrs->ia_valid &= ~ATTR_MODE;
                 }
         }
 
diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index 5c792df13d62..0088a5b52564 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -30,9 +30,9 @@
 
 #define CIFS_IOC_CHECKUMOUNT _IO(0xCF, 2)
 
-int cifs_ioctl(struct inode *inode, struct file *filep,
-                unsigned int command, unsigned long arg)
+long cifs_ioctl(struct file *filep, unsigned int command, unsigned long arg)
 {
+        struct inode *inode = filep->f_dentry->d_inode;
         int rc = -ENOTTY; /* strange error - but the precedent */
         int xid;
         struct cifs_sb_info *cifs_sb;
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 1c2c3ce5020b..63f644000ce5 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -234,7 +234,6 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
         struct cifs_sb_info *cifs_sb;
         struct cifsTconInfo *pTcon;
         char *full_path = NULL;
-        char *tmp_path = NULL;
         char *tmpbuffer;
         int len;
         __u16 fid;
@@ -295,45 +294,9 @@ cifs_readlink(struct dentry *direntry, char __user *pBuffer, int buflen)
                                 cFYI(1, ("Error closing junction point "
                                          "(open for ioctl)"));
                         }
-                        /* BB unwind this long, nested function, or remove BB */
-                        if (rc == -EIO) {
-                                /* Query if DFS Junction */
-                                unsigned int num_referrals = 0;
-                                struct dfs_info3_param *refs = NULL;
-                                tmp_path =
-                                        kmalloc(MAX_TREE_SIZE + MAX_PATHCONF + 1,
-                                                GFP_KERNEL);
-                                if (tmp_path) {
-                                        strncpy(tmp_path, pTcon->treeName,
-                                                MAX_TREE_SIZE);
-                                        strncat(tmp_path, full_path,
-                                                MAX_PATHCONF);
-                                        rc = get_dfs_path(xid, pTcon->ses,
-                                                tmp_path,
-                                                cifs_sb->local_nls,
-                                                &num_referrals, &refs,
-                                                cifs_sb->mnt_cifs_flags &
-                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
-                                        cFYI(1, ("Get DFS for %s rc = %d ",
-                                                tmp_path, rc));
-                                        if ((num_referrals == 0) && (rc == 0))
-                                                rc = -EACCES;
-                                        else {
-                                                cFYI(1, ("num referral: %d",
-                                                        num_referrals));
-                                                if (refs && refs->path_name) {
-                                                        strncpy(tmpbuffer,
-                                                                refs->path_name,
-                                                                len-1);
-                                                }
-                                        }
-                                        kfree(refs);
-                                        kfree(tmp_path);
-}
-                                /* BB add code like else decode referrals
-                                then memcpy to tmpbuffer and free referrals
-                                string array BB */
-                        }
+                        /* If it is a DFS junction earlier we would have gotten
+                           PATH_NOT_COVERED returned from server so we do
+                           not need to request the DFS info here */
                 }
         }
         /* BB Anything else to do to handle recursive links? */
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 1d69b8014e0b..4b17f8fe3157 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -519,8 +519,7 @@ is_valid_oplock_break(struct smb_hdr *buf, struct TCP_Server_Info *srv)
                         pnotify = (struct file_notify_information *)
                                 ((char *)&pSMBr->hdr.Protocol + data_offset);
                         cFYI(1, ("dnotify on %s Action: 0x%x",
-                                 pnotify->FileName,
-                                pnotify->Action));  /* BB removeme BB */
+                                 pnotify->FileName, pnotify->Action));
                         /*   cifs_dump_mem("Rcvd notify Data: ",buf,
                                 sizeof(struct smb_hdr)+60); */
                         return true;
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index 00f4cff400b3..8703d68f5b20 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -141,11 +141,11 @@ cifs_inet_pton(const int address_family, const char *cp, void *dst)
         int ret = 0;
 
         /* calculate length by finding first slash or NULL */
-        if (address_family == AF_INET) {
+        if (address_family == AF_INET)
                 ret = in4_pton(cp, -1 /* len */, dst, '\\', NULL);
-        } else if (address_family == AF_INET6) {
+        else if (address_family == AF_INET6)
                 ret = in6_pton(cp, -1 /* len */, dst , '\\', NULL);
-        }
+
         cFYI(DBG2, ("address conversion returned %d for %s", ret, cp));
         if (ret > 0)
                 ret = 1;
diff --git a/fs/cifs/ntlmssp.h b/fs/cifs/ntlmssp.h
index 7170a9b70f1e..c377d8065d99 100644
--- a/fs/cifs/ntlmssp.h
+++ b/fs/cifs/ntlmssp.h
@@ -64,7 +64,7 @@ typedef struct _SECURITY_BUFFER {
 } __attribute__((packed)) SECURITY_BUFFER;
 
 typedef struct _NEGOTIATE_MESSAGE {
-        __u8 Signature[sizeof (NTLMSSP_SIGNATURE)];
+        __u8 Signature[sizeof(NTLMSSP_SIGNATURE)];
         __le32 MessageType;     /* 1 */
         __le32 NegotiateFlags;
         SECURITY_BUFFER DomainName;     /* RFC 1001 style and ASCII */
@@ -74,7 +74,7 @@ typedef struct _NEGOTIATE_MESSAGE {
 } __attribute__((packed)) NEGOTIATE_MESSAGE, *PNEGOTIATE_MESSAGE;
 
 typedef struct _CHALLENGE_MESSAGE {
-        __u8 Signature[sizeof (NTLMSSP_SIGNATURE)];
+        __u8 Signature[sizeof(NTLMSSP_SIGNATURE)];
         __le32 MessageType;   /* 2 */
         SECURITY_BUFFER TargetName;
         __le32 NegotiateFlags;
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 34ec32100c72..83f306954883 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -132,6 +132,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
         __u32 attr;
         __u64 allocation_size;
         __u64 end_of_file;
+        umode_t default_mode;
 
         /* save mtime and size */
         local_mtime = tmp_inode->i_mtime;
@@ -187,48 +188,54 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
         if (atomic_read(&cifsInfo->inUse) == 0) {
                 tmp_inode->i_uid = cifs_sb->mnt_uid;
                 tmp_inode->i_gid = cifs_sb->mnt_gid;
-                /* set default mode. will override for dirs below */
-                tmp_inode->i_mode = cifs_sb->mnt_file_mode;
-        } else {
-                /* mask off the type bits since it gets set
-                below and we do not want to get two type
-                bits set */
+        }
+
+        if (attr & ATTR_DIRECTORY)
+                default_mode = cifs_sb->mnt_dir_mode;
+        else
+                default_mode = cifs_sb->mnt_file_mode;
+
+        /* set initial permissions */
+        if ((atomic_read(&cifsInfo->inUse) == 0) ||
+            (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DYNPERM) == 0)
+                tmp_inode->i_mode = default_mode;
+        else {
+                /* just reenable write bits if !ATTR_READONLY */
+                if ((tmp_inode->i_mode & S_IWUGO) == 0 &&
+                    (attr & ATTR_READONLY) == 0)
+                        tmp_inode->i_mode |= (S_IWUGO & default_mode);
+
                 tmp_inode->i_mode &= ~S_IFMT;
         }
 
-        if (attr & ATTR_DIRECTORY) {
-                *pobject_type = DT_DIR;
-                /* override default perms since we do not lock dirs */
-                if (atomic_read(&cifsInfo->inUse) == 0)
-                        tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
-                tmp_inode->i_mode |= S_IFDIR;
-        } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
-                   (attr & ATTR_SYSTEM)) {
+        /* clear write bits if ATTR_READONLY is set */
+        if (attr & ATTR_READONLY)
+                tmp_inode->i_mode &= ~S_IWUGO;
+
+        /* set inode type */
+        if ((attr & ATTR_SYSTEM) &&
+            (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL)) {
                 if (end_of_file == 0)  {
-                        *pobject_type = DT_FIFO;
                         tmp_inode->i_mode |= S_IFIFO;
+                        *pobject_type = DT_FIFO;
                 } else {
-                        /* rather than get the type here, we mark the
-                        inode as needing revalidate and get the real type
-                        (blk vs chr vs. symlink) later ie in lookup */
-                        *pobject_type = DT_REG;
+                        /*
+                         * trying to get the type can be slow, so just call
+                         * this a regular file for now, and mark for reval
+                         */
                         tmp_inode->i_mode |= S_IFREG;
+                        *pobject_type = DT_REG;
                         cifsInfo->time = 0;
                 }
-/* we no longer mark these because we could not follow them */
-/*        } else if (attr & ATTR_REPARSE) {
-                *pobject_type = DT_LNK;
-                tmp_inode->i_mode |= S_IFLNK; */
         } else {
-                *pobject_type = DT_REG;
-                tmp_inode->i_mode |= S_IFREG;
-                if (attr & ATTR_READONLY)
-                        tmp_inode->i_mode &= ~(S_IWUGO);
-                else if ((tmp_inode->i_mode & S_IWUGO) == 0)
-                        /* the ATTR_READONLY flag may have been changed on   */
-                        /* server -- set any w bits allowed by mnt_file_mode */
-                        tmp_inode->i_mode |= (S_IWUGO & cifs_sb->mnt_file_mode);
-        } /* could add code here - to validate if device or weird share type? */
+                if (attr & ATTR_DIRECTORY) {
+                        tmp_inode->i_mode |= S_IFDIR;
+                        *pobject_type = DT_DIR;
+                } else {
+                        tmp_inode->i_mode |= S_IFREG;
+                        *pobject_type = DT_REG;
+                }
+        }
 
         /* can not fill in nlink here as in qpathinfo version and Unx search */
         if (atomic_read(&cifsInfo->inUse) == 0)
@@ -670,10 +677,11 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
            (index_to_find < first_entry_in_buffer)) {
                 /* close and restart search */
                 cFYI(1, ("search backing up - close and restart search"));
-                cifsFile->invalidHandle = true;
-                CIFSFindClose(xid, pTcon, cifsFile->netfid);
-                kfree(cifsFile->search_resume_name);
-                cifsFile->search_resume_name = NULL;
+                if (!cifsFile->srch_inf.endOfSearch &&
+                    !cifsFile->invalidHandle) {
+                        cifsFile->invalidHandle = true;
+                        CIFSFindClose(xid, pTcon, cifsFile->netfid);
+                }
                 if (cifsFile->srch_inf.ntwrk_buf_start) {
                         cFYI(1, ("freeing SMB ff cache buf on search rewind"));
                         if (cifsFile->srch_inf.smallBuf)
@@ -1040,9 +1048,7 @@ int cifs_readdir(struct file *file, void *direntry, filldir_t filldir)
                 } /* else {
                         cifsFile->invalidHandle = true;
                         CIFSFindClose(xid, pTcon, cifsFile->netfid);
-                }
-                kfree(cifsFile->search_resume_name);
-                cifsFile->search_resume_name = NULL; */
+                } */
 
                 rc = find_cifs_entry(xid, pTcon, file,
                                 &current_entry, &num_to_fill);
diff --git a/fs/compat.c b/fs/compat.c
index 332a869d2c53..ed43e17a5dc6 100644
--- a/fs/compat.c
+++ b/fs/compat.c
@@ -1405,7 +1405,7 @@ int compat_do_execve(char * filename,
                 /* execve success */
                 security_bprm_free(bprm);
                 acct_update_integrals(current);
-                kfree(bprm);
+                free_bprm(bprm);
                 return retval;
         }
 
@@ -1424,7 +1424,7 @@ out_file:
         }
 
 out_kfree:
-        kfree(bprm);
+        free_bprm(bprm);
 
 out_ret:
         return retval;
diff --git a/fs/dcache.c b/fs/dcache.c
index 3ee588d5f585..6068c25b393c 100644
--- a/fs/dcache.c
+++ b/fs/dcache.c
@@ -17,6 +17,7 @@
 #include <linux/syscalls.h>
 #include <linux/string.h>
 #include <linux/mm.h>
+#include <linux/fdtable.h>
 #include <linux/fs.h>
 #include <linux/fsnotify.h>
 #include <linux/slab.h>
@@ -106,9 +107,10 @@ static void dentry_lru_remove(struct dentry *dentry)
 /*
  * Release the dentry's inode, using the filesystem
  * d_iput() operation if defined.
- * Called with dcache_lock and per dentry lock held, drops both.
  */
 static void dentry_iput(struct dentry * dentry)
+        __releases(dentry->d_lock)
+        __releases(dcache_lock)
 {
         struct inode *inode = dentry->d_inode;
         if (inode) {
@@ -132,12 +134,13 @@ 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.
+ * 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)
+        __releases(dentry->d_lock)
+        __releases(dcache_lock)
 {
         struct dentry *parent;
 
@@ -383,11 +386,11 @@ restart:
  * Try to prune ancestors as well.  This is necessary to prevent
  * quadratic behavior of shrink_dcache_parent(), but is also expected
  * to be beneficial in reducing dentry cache fragmentation.
- *
- * 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)
+        __releases(dentry->d_lock)
+        __releases(dcache_lock)
+        __acquires(dcache_lock)
 {
         __d_drop(dentry);
         dentry = d_kill(dentry);
@@ -1604,10 +1607,9 @@ static int d_isparent(struct dentry *p1, struct dentry *p2)
  *
  * Note: If ever the locking in lock_rename() changes, then please
  * remember to update this too...
- *
- * On return, dcache_lock will have been unlocked.
  */
 static struct dentry *__d_unalias(struct dentry *dentry, struct dentry *alias)
+        __releases(dcache_lock)
 {
         struct mutex *m1 = NULL, *m2 = NULL;
         struct dentry *ret;
@@ -1743,11 +1745,9 @@ out_nolock:
 shouldnt_be_hashed:
         spin_unlock(&dcache_lock);
         BUG();
-        goto shouldnt_be_hashed;
 }
 
-static int prepend(char **buffer, int *buflen, const char *str,
-                          int namelen)
+static int prepend(char **buffer, int *buflen, const char *str, int namelen)
 {
         *buflen -= namelen;
         if (*buflen < 0)
@@ -1757,8 +1757,13 @@ static int prepend(char **buffer, int *buflen, const char *str,
         return 0;
 }
 
+static int prepend_name(char **buffer, int *buflen, struct qstr *name)
+{
+        return prepend(buffer, buflen, name->name, name->len);
+}
+
 /**
- * d_path - return the path of a dentry
+ * __d_path - return the path of a dentry
  * @path: the dentry/vfsmount to report
  * @root: root vfsmnt/dentry (may be modified by this function)
  * @buffer: buffer to return value in
@@ -1779,9 +1784,10 @@ char *__d_path(const struct path *path, struct path *root,
 {
         struct dentry *dentry = path->dentry;
         struct vfsmount *vfsmnt = path->mnt;
-        char * end = buffer+buflen;
-        char * retval;
+        char *end = buffer + buflen;
+        char *retval;
 
+        spin_lock(&vfsmount_lock);
         prepend(&end, &buflen, "\0", 1);
         if (!IS_ROOT(dentry) && d_unhashed(dentry) &&
                 (prepend(&end, &buflen, " (deleted)", 10) != 0))
@@ -1800,38 +1806,37 @@ char *__d_path(const struct path *path, struct path *root,
                         break;
                 if (dentry == vfsmnt->mnt_root || IS_ROOT(dentry)) {
                         /* Global root? */
-                        spin_lock(&vfsmount_lock);
                         if (vfsmnt->mnt_parent == vfsmnt) {
-                                spin_unlock(&vfsmount_lock);
                                 goto global_root;
                         }
                         dentry = vfsmnt->mnt_mountpoint;
                         vfsmnt = vfsmnt->mnt_parent;
-                        spin_unlock(&vfsmount_lock);
                         continue;
                 }
                 parent = dentry->d_parent;
                 prefetch(parent);
-                if ((prepend(&end, &buflen, dentry->d_name.name,
-                                dentry->d_name.len) != 0) ||
+                if ((prepend_name(&end, &buflen, &dentry->d_name) != 0) ||
                     (prepend(&end, &buflen, "/", 1) != 0))
                         goto Elong;
                 retval = end;
                 dentry = parent;
         }
 
+out:
+        spin_unlock(&vfsmount_lock);
         return retval;
 
 global_root:
         retval += 1;    /* hit the slash */
-        if (prepend(&retval, &buflen, dentry->d_name.name,
-                    dentry->d_name.len) != 0)
+        if (prepend_name(&retval, &buflen, &dentry->d_name) != 0)
                 goto Elong;
         root->mnt = vfsmnt;
         root->dentry = dentry;
-        return retval;
+        goto out;
+
 Elong:
-        return ERR_PTR(-ENAMETOOLONG);
+        retval = ERR_PTR(-ENAMETOOLONG);
+        goto out;
 }
 
 /**
@@ -1845,9 +1850,9 @@ Elong:
  *
  * Returns the buffer or an error code if the path was too long.
  *
- * "buflen" should be positive. Caller holds the dcache_lock.
+ * "buflen" should be positive.
  */
-char *d_path(struct path *path, char *buf, int buflen)
+char *d_path(const struct path *path, char *buf, int buflen)
 {
         char *res;
         struct path root;
@@ -1915,16 +1920,11 @@ char *dentry_path(struct dentry *dentry, char *buf, int buflen)
         retval = end-1;
         *retval = '/';
 
-        for (;;) {
-                struct dentry *parent;
-                if (IS_ROOT(dentry))
-                        break;
+        while (!IS_ROOT(dentry)) {
+                struct dentry *parent = dentry->d_parent;
 
-                parent = dentry->d_parent;
                 prefetch(parent);
-
-                if ((prepend(&end, &buflen, dentry->d_name.name,
-                                dentry->d_name.len) != 0) ||
+                if ((prepend_name(&end, &buflen, &dentry->d_name) != 0) ||
                     (prepend(&end, &buflen, "/", 1) != 0))
                         goto Elong;
 
@@ -1975,7 +1975,7 @@ asmlinkage long sys_getcwd(char __user *buf, unsigned long size)
         error = -ENOENT;
         /* Has the current directory has been unlinked? */
         spin_lock(&dcache_lock);
-        if (pwd.dentry->d_parent == pwd.dentry || !d_unhashed(pwd.dentry)) {
+        if (IS_ROOT(pwd.dentry) || !d_unhashed(pwd.dentry)) {
                 unsigned long len;
                 struct path tmp = root;
                 char * cwd;
diff --git a/fs/dlm/lowcomms.c b/fs/dlm/lowcomms.c
index 7c1e5e5cccd8..637018c891ef 100644
--- a/fs/dlm/lowcomms.c
+++ b/fs/dlm/lowcomms.c
@@ -50,6 +50,7 @@
 #include <linux/pagemap.h>
 #include <linux/idr.h>
 #include <linux/file.h>
+#include <linux/mutex.h>
 #include <linux/sctp.h>
 #include <net/sctp/user.h>
 
@@ -138,7 +139,7 @@ static struct workqueue_struct *recv_workqueue;
 static struct workqueue_struct *send_workqueue;
 
 static DEFINE_IDR(connections_idr);
-static DECLARE_MUTEX(connections_lock);
+static DEFINE_MUTEX(connections_lock);
 static int max_nodeid;
 static struct kmem_cache *con_cache;
 
@@ -205,9 +206,9 @@ static struct connection *nodeid2con(int nodeid, gfp_t allocation)
 {
         struct connection *con;
 
-        down(&connections_lock);
+        mutex_lock(&connections_lock);
         con = __nodeid2con(nodeid, allocation);
-        up(&connections_lock);
+        mutex_unlock(&connections_lock);
 
         return con;
 }
@@ -218,15 +219,15 @@ static struct connection *assoc2con(int assoc_id)
         int i;
         struct connection *con;
 
-        down(&connections_lock);
+        mutex_lock(&connections_lock);
         for (i=0; i<=max_nodeid; i++) {
                 con = __nodeid2con(i, 0);
                 if (con && con->sctp_assoc == assoc_id) {
-                        up(&connections_lock);
+                        mutex_unlock(&connections_lock);
                         return con;
                 }
         }
-        up(&connections_lock);
+        mutex_unlock(&connections_lock);
         return NULL;
 }
 
@@ -381,7 +382,7 @@ static void sctp_init_failed(void)
         int i;
         struct connection *con;
 
-        down(&connections_lock);
+        mutex_lock(&connections_lock);
         for (i=1; i<=max_nodeid; i++) {
                 con = __nodeid2con(i, 0);
                 if (!con)
@@ -393,7 +394,7 @@ static void sctp_init_failed(void)
                         }
                 }
         }
-        up(&connections_lock);
+        mutex_unlock(&connections_lock);
 }
 
 /* Something happened to an association */
@@ -930,7 +931,7 @@ out_err:
          * errors we try again until the max number of retries is reached.
          */
         if (result != -EHOSTUNREACH && result != -ENETUNREACH &&
-            result != -ENETDOWN && result != EINVAL
+            result != -ENETDOWN && result != -EINVAL
             && result != -EPROTONOSUPPORT) {
                 lowcomms_connect_sock(con);
                 result = 0;
@@ -1417,7 +1418,7 @@ void dlm_lowcomms_stop(void)
         /* Set all the flags to prevent any
            socket activity.
         */
-        down(&connections_lock);
+        mutex_lock(&connections_lock);
         for (i = 0; i <= max_nodeid; i++) {
                 con = __nodeid2con(i, 0);
                 if (con) {
@@ -1426,11 +1427,11 @@ void dlm_lowcomms_stop(void)
                                 con->sock->sk->sk_user_data = NULL;
                 }
         }
-        up(&connections_lock);
+        mutex_unlock(&connections_lock);
 
         work_stop();
 
-        down(&connections_lock);
+        mutex_lock(&connections_lock);
         clean_writequeues();
 
         for (i = 0; i <= max_nodeid; i++) {
@@ -1443,7 +1444,7 @@ void dlm_lowcomms_stop(void)
                 }
         }
         max_nodeid = 0;
-        up(&connections_lock);
+        mutex_unlock(&connections_lock);
         kmem_cache_destroy(con_cache);
         idr_init(&connections_idr);
 }
diff --git a/fs/dlm/netlink.c b/fs/dlm/netlink.c
index 714593621f4f..18bda83cc892 100644
--- a/fs/dlm/netlink.c
+++ b/fs/dlm/netlink.c
@@ -95,7 +95,7 @@ int __init dlm_netlink_init(void)
         return rv;
 }
 
-void __exit dlm_netlink_exit(void)
+void dlm_netlink_exit(void)
 {
         genl_unregister_ops(&family, &dlm_nl_ops);
         genl_unregister_family(&family);
diff --git a/fs/dlm/plock.c b/fs/dlm/plock.c
index d6d6e370f89c..78878c5781ca 100644
--- a/fs/dlm/plock.c
+++ b/fs/dlm/plock.c
@@ -379,7 +379,7 @@ static ssize_t dev_write(struct file *file, const char __user *u, size_t count,
                 struct plock_xop *xop;
                 xop = (struct plock_xop *)op;
                 if (xop->callback)
-                        count = dlm_plock_callback(op);
+                        dlm_plock_callback(op);
                 else
                         wake_up(&recv_wq);
         } else
diff --git a/fs/ecryptfs/crypto.c b/fs/ecryptfs/crypto.c
index cd62d75b2cc0..e2832bc7869a 100644
--- a/fs/ecryptfs/crypto.c
+++ b/fs/ecryptfs/crypto.c
@@ -1906,9 +1906,9 @@ int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher **tfm,
                         goto out;
                 }
         }
-        mutex_unlock(&key_tfm_list_mutex);
         (*tfm) = key_tfm->key_tfm;
         (*tfm_mutex) = &key_tfm->key_tfm_mutex;
 out:
+        mutex_unlock(&key_tfm_list_mutex);
         return rc;
 }
diff --git a/fs/ecryptfs/ecryptfs_kernel.h b/fs/ecryptfs/ecryptfs_kernel.h
index 951ee33a022d..c15c25745e05 100644
--- a/fs/ecryptfs/ecryptfs_kernel.h
+++ b/fs/ecryptfs/ecryptfs_kernel.h
@@ -660,8 +660,6 @@ int ecryptfs_get_tfm_and_mutex_for_cipher_name(struct crypto_blkcipher **tfm,
 int ecryptfs_keyring_auth_tok_for_sig(struct key **auth_tok_key,
                                       struct ecryptfs_auth_tok **auth_tok,
                                       char *sig);
-int ecryptfs_write_zeros(struct file *file, pgoff_t index, int start,
-                         int num_zeros);
 int ecryptfs_write_lower(struct inode *ecryptfs_inode, char *data,
                          loff_t offset, size_t size);
 int ecryptfs_write_lower_page_segment(struct inode *ecryptfs_inode,
diff --git a/fs/ecryptfs/miscdev.c b/fs/ecryptfs/miscdev.c
index 6560da1a58ce..50c994a249a5 100644
--- a/fs/ecryptfs/miscdev.c
+++ b/fs/ecryptfs/miscdev.c
@@ -243,7 +243,6 @@ ecryptfs_miscdev_read(struct file *file, char __user *buf, size_t count,
         struct ecryptfs_daemon *daemon;
         struct ecryptfs_msg_ctx *msg_ctx;
         size_t packet_length_size;
-        u32 counter_nbo;
         char packet_length[3];
         size_t i;
         size_t total_length;
@@ -328,20 +327,18 @@ check_list:
                        "pending message\n", __func__, count, total_length);
                 goto out_unlock_msg_ctx;
         }
-        i = 0;
-        buf[i++] = msg_ctx->type;
-        counter_nbo = cpu_to_be32(msg_ctx->counter);
-        memcpy(&buf[i], (char *)&counter_nbo, 4);
-        i += 4;
+        rc = -EFAULT;
+        if (put_user(msg_ctx->type, buf))
+                goto out_unlock_msg_ctx;
+        if (put_user(cpu_to_be32(msg_ctx->counter), (__be32 __user *)(buf + 1)))
+                goto out_unlock_msg_ctx;
+        i = 5;
         if (msg_ctx->msg) {
-                memcpy(&buf[i], packet_length, packet_length_size);
+                if (copy_to_user(&buf[i], packet_length, packet_length_size))
+                        goto out_unlock_msg_ctx;
                 i += packet_length_size;
-                rc = copy_to_user(&buf[i], msg_ctx->msg, msg_ctx->msg_size);
-                if (rc) {
-                        printk(KERN_ERR "%s: copy_to_user returned error "
-                               "[%d]\n", __func__, rc);
+                if (copy_to_user(&buf[i], msg_ctx->msg, msg_ctx->msg_size))
                         goto out_unlock_msg_ctx;
-                }
                 i += msg_ctx->msg_size;
         }
         rc = i;
@@ -452,7 +449,8 @@ static ssize_t
 ecryptfs_miscdev_write(struct file *file, const char __user *buf,
                        size_t count, loff_t *ppos)
 {
-        u32 counter_nbo, seq;
+        __be32 counter_nbo;
+        u32 seq;
         size_t packet_size, packet_size_length, i;
         ssize_t sz = 0;
         char *data;
@@ -485,7 +483,7 @@ ecryptfs_miscdev_write(struct file *file, const char __user *buf,
                                count);
                         goto out_free;
                 }
-                memcpy((char *)&counter_nbo, &data[i], 4);
+                memcpy(&counter_nbo, &data[i], 4);
                 seq = be32_to_cpu(counter_nbo);
                 i += 4;
                 rc = ecryptfs_parse_packet_length(&data[i], &packet_size,
diff --git a/fs/ecryptfs/read_write.c b/fs/ecryptfs/read_write.c
index ebf55150be56..75c2ea9fee35 100644
--- a/fs/ecryptfs/read_write.c
+++ b/fs/ecryptfs/read_write.c
@@ -157,20 +157,6 @@ int ecryptfs_write(struct file *ecryptfs_file, char *data, loff_t offset,
                                ecryptfs_page_idx, rc);
                         goto out;
                 }
-                if (start_offset_in_page) {
-                        /* Read in the page from the lower
-                         * into the eCryptfs inode page cache,
-                         * decrypting */
-                        rc = ecryptfs_decrypt_page(ecryptfs_page);
-                        if (rc) {
-                                printk(KERN_ERR "%s: Error decrypting "
-                                       "page; rc = [%d]\n",
-                                       __func__, rc);
-                                ClearPageUptodate(ecryptfs_page);
-                                page_cache_release(ecryptfs_page);
-                                goto out;
-                        }
-                }
                 ecryptfs_page_virt = kmap_atomic(ecryptfs_page, KM_USER0);
 
                 /*
@@ -349,14 +335,6 @@ int ecryptfs_read(char *data, loff_t offset, size_t size,
                                ecryptfs_page_idx, rc);
                         goto out;
                 }
-                rc = ecryptfs_decrypt_page(ecryptfs_page);
-                if (rc) {
-                        printk(KERN_ERR "%s: Error decrypting "
-                               "page; rc = [%d]\n", __func__, rc);
-                        ClearPageUptodate(ecryptfs_page);
-                        page_cache_release(ecryptfs_page);
-                        goto out;
-                }
                 ecryptfs_page_virt = kmap_atomic(ecryptfs_page, KM_USER0);
                 memcpy((data + data_offset),
                        ((char *)ecryptfs_page_virt + start_offset_in_page),
diff --git a/fs/exec.c b/fs/exec.c
index 1f8a24aa1f8b..da94a6f05df3 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -26,7 +26,6 @@
 #include <linux/file.h>
 #include <linux/fdtable.h>
 #include <linux/mman.h>
-#include <linux/a.out.h>
 #include <linux/stat.h>
 #include <linux/fcntl.h>
 #include <linux/smp_lock.h>
@@ -61,6 +60,11 @@
 #include <linux/kmod.h>
 #endif
 
+#ifdef __alpha__
+/* for /sbin/loader handling in search_binary_handler() */
+#include <linux/a.out.h>
+#endif
+
 int core_uses_pid;
 char core_pattern[CORENAME_MAX_SIZE] = "core";
 int suid_dumpable = 0;
@@ -860,6 +864,7 @@ static int de_thread(struct task_struct *tsk)
 
 no_thread_group:
         exit_itimers(sig);
+        flush_itimer_signals();
         if (leader)
                 release_task(leader);
 
@@ -1154,7 +1159,7 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 {
         int try,retval;
         struct linux_binfmt *fmt;
-#if defined(__alpha__) && defined(CONFIG_ARCH_SUPPORTS_AOUT)
+#ifdef __alpha__
         /* handle /sbin/loader.. */
         {
             struct exec * eh = (struct exec *) bprm->buf;
@@ -1251,6 +1256,12 @@ int search_binary_handler(struct linux_binprm *bprm,struct pt_regs *regs)
 
 EXPORT_SYMBOL(search_binary_handler);
 
+void free_bprm(struct linux_binprm *bprm)
+{
+        free_arg_pages(bprm);
+        kfree(bprm);
+}
+
 /*
  * sys_execve() executes a new program.
  */
@@ -1320,17 +1331,15 @@ int do_execve(char * filename,
         retval = search_binary_handler(bprm,regs);
         if (retval >= 0) {
                 /* execve success */
-                free_arg_pages(bprm);
                 security_bprm_free(bprm);
                 acct_update_integrals(current);
-                kfree(bprm);
+                free_bprm(bprm);
                 if (displaced)
                         put_files_struct(displaced);
                 return retval;
         }
 
 out:
-        free_arg_pages(bprm);
         if (bprm->security)
                 security_bprm_free(bprm);
 
@@ -1344,7 +1353,7 @@ out_file:
                 fput(bprm->file);
         }
 out_kfree:
-        kfree(bprm);
+        free_bprm(bprm);
 
 out_files:
         if (displaced)
diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index 28cfd0b40527..77278e947e94 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -580,7 +580,8 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
         }
 
         blk = EXT3_SB(sb)->s_sbh->b_blocknr + 1 + EXT3_SB(sb)->s_gdb_count;
-        data = (__le32 *)dind->b_data + EXT3_SB(sb)->s_gdb_count;
+        data = (__le32 *)dind->b_data + (EXT3_SB(sb)->s_gdb_count %
+                                         EXT3_ADDR_PER_BLOCK(sb));
         end = (__le32 *)dind->b_data + EXT3_ADDR_PER_BLOCK(sb);
 
         /* Get each reserved primary GDT block and verify it holds backups */
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index 30494c5da843..9cc80b9cc8d8 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -43,6 +43,46 @@ void ext4_get_group_no_and_offset(struct super_block *sb, ext4_fsblk_t blocknr,
 
 }
 
+static int ext4_block_in_group(struct super_block *sb, ext4_fsblk_t block,
+                        ext4_group_t block_group)
+{
+        ext4_group_t actual_group;
+        ext4_get_group_no_and_offset(sb, block, &actual_group, 0);
+        if (actual_group == block_group)
+                return 1;
+        return 0;
+}
+
+static int ext4_group_used_meta_blocks(struct super_block *sb,
+                                ext4_group_t block_group)
+{
+        ext4_fsblk_t tmp;
+        struct ext4_sb_info *sbi = EXT4_SB(sb);
+        /* block bitmap, inode bitmap, and inode table blocks */
+        int used_blocks = sbi->s_itb_per_group + 2;
+
+        if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_FLEX_BG)) {
+                struct ext4_group_desc *gdp;
+                struct buffer_head *bh;
+
+                gdp = ext4_get_group_desc(sb, block_group, &bh);
+                if (!ext4_block_in_group(sb, ext4_block_bitmap(sb, gdp),
+                                        block_group))
+                        used_blocks--;
+
+                if (!ext4_block_in_group(sb, ext4_inode_bitmap(sb, gdp),
+                                        block_group))
+                        used_blocks--;
+
+                tmp = ext4_inode_table(sb, gdp);
+                for (; tmp < ext4_inode_table(sb, gdp) +
+                                sbi->s_itb_per_group; tmp++) {
+                        if (!ext4_block_in_group(sb, tmp, block_group))
+                                used_blocks -= 1;
+                }
+        }
+        return used_blocks;
+}
 /* Initializes an uninitialized block bitmap if given, and returns the
  * number of blocks free in the group. */
 unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
@@ -105,20 +145,34 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
         free_blocks = group_blocks - bit_max;
 
         if (bh) {
-                ext4_fsblk_t start;
+                ext4_fsblk_t start, tmp;
+                int flex_bg = 0;
 
                 for (bit = 0; bit < bit_max; bit++)
                         ext4_set_bit(bit, bh->b_data);
 
                 start = ext4_group_first_block_no(sb, block_group);
 
-                /* Set bits for block and inode bitmaps, and inode table */
-                ext4_set_bit(ext4_block_bitmap(sb, gdp) - start, bh->b_data);
-                ext4_set_bit(ext4_inode_bitmap(sb, gdp) - start, bh->b_data);
-                for (bit = (ext4_inode_table(sb, gdp) - start),
-                     bit_max = bit + sbi->s_itb_per_group; bit < bit_max; bit++)
-                        ext4_set_bit(bit, bh->b_data);
+                if (EXT4_HAS_INCOMPAT_FEATURE(sb,
+                                              EXT4_FEATURE_INCOMPAT_FLEX_BG))
+                        flex_bg = 1;
 
+                /* Set bits for block and inode bitmaps, and inode table */
+                tmp = ext4_block_bitmap(sb, gdp);
+                if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
+                        ext4_set_bit(tmp - start, bh->b_data);
+
+                tmp = ext4_inode_bitmap(sb, gdp);
+                if (!flex_bg || ext4_block_in_group(sb, tmp, block_group))
+                        ext4_set_bit(tmp - start, bh->b_data);
+
+                tmp = ext4_inode_table(sb, gdp);
+                for (; tmp < ext4_inode_table(sb, gdp) +
+                                sbi->s_itb_per_group; tmp++) {
+                        if (!flex_bg ||
+                                ext4_block_in_group(sb, tmp, block_group))
+                                ext4_set_bit(tmp - start, bh->b_data);
+                }
                 /*
                  * Also if the number of blocks within the group is
                  * less than the blocksize * 8 ( which is the size
@@ -126,8 +180,7 @@ unsigned ext4_init_block_bitmap(struct super_block *sb, struct buffer_head *bh,
                  */
                 mark_bitmap_end(group_blocks, sb->s_blocksize * 8, bh->b_data);
         }
-
-        return free_blocks - sbi->s_itb_per_group - 2;
+        return free_blocks - ext4_group_used_meta_blocks(sb, block_group);
 }
 
 
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index 873ad9b3418c..c9900aade150 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -2745,8 +2745,6 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
         sbi = EXT4_SB(sb);
         es = sbi->s_es;
 
-        ext4_debug("using block group %lu(%d)\n", ac->ac_b_ex.fe_group,
-                        gdp->bg_free_blocks_count);
 
         err = -EIO;
         bitmap_bh = read_block_bitmap(sb, ac->ac_b_ex.fe_group);
@@ -2762,6 +2760,9 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
         if (!gdp)
                 goto out_err;
 
+        ext4_debug("using block group %lu(%d)\n", ac->ac_b_ex.fe_group,
+                        gdp->bg_free_blocks_count);
+
         err = ext4_journal_get_write_access(handle, gdp_bh);
         if (err)
                 goto out_err;
@@ -3094,8 +3095,7 @@ static void ext4_mb_use_inode_pa(struct ext4_allocation_context *ac,
 static void ext4_mb_use_group_pa(struct ext4_allocation_context *ac,
                                 struct ext4_prealloc_space *pa)
 {
-        unsigned len = ac->ac_o_ex.fe_len;
-
+        unsigned int len = ac->ac_o_ex.fe_len;
         ext4_get_group_no_and_offset(ac->ac_sb, pa->pa_pstart,
                                         &ac->ac_b_ex.fe_group,
                                         &ac->ac_b_ex.fe_start);
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 9f086a6a472b..9ff7b1c04239 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -563,7 +563,8 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
         }
 
         blk = EXT4_SB(sb)->s_sbh->b_blocknr + 1 + EXT4_SB(sb)->s_gdb_count;
-        data = (__le32 *)dind->b_data + EXT4_SB(sb)->s_gdb_count;
+        data = (__le32 *)dind->b_data + (EXT4_SB(sb)->s_gdb_count %
+                                         EXT4_ADDR_PER_BLOCK(sb));
         end = (__le32 *)dind->b_data + EXT4_ADDR_PER_BLOCK(sb);
 
         /* Get each reserved primary GDT block and verify it holds backups */
@@ -854,7 +855,8 @@ int ext4_group_add(struct super_block *sb, struct ext4_new_group_data *input)
          */
 
         /* Update group descriptor block for new group */
-        gdp = (struct ext4_group_desc *)primary->b_data + gdb_off;
+        gdp = (struct ext4_group_desc *)((char *)primary->b_data +
+                                         gdb_off * EXT4_DESC_SIZE(sb));
 
         ext4_block_bitmap_set(sb, gdp, input->block_bitmap); /* LV FIXME */
         ext4_inode_bitmap_set(sb, gdp, input->inode_bitmap); /* LV FIXME */
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 09d9359c8055..cb96f127c366 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -671,6 +671,7 @@ static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
         unsigned long def_mount_opts;
         struct super_block *sb = vfs->mnt_sb;
         struct ext4_sb_info *sbi = EXT4_SB(sb);
+        journal_t *journal = sbi->s_journal;
         struct ext4_super_block *es = sbi->s_es;
 
         def_mount_opts = le32_to_cpu(es->s_default_mount_opts);
@@ -729,8 +730,15 @@ static int ext4_show_options(struct seq_file *seq, struct vfsmount *vfs)
                 seq_printf(seq, ",commit=%u",
                            (unsigned) (sbi->s_commit_interval / HZ));
         }
-        if (test_opt(sb, BARRIER))
-                seq_puts(seq, ",barrier=1");
+        /*
+         * We're changing the default of barrier mount option, so
+         * let's always display its mount state so it's clear what its
+         * status is.
+         */
+        seq_puts(seq, ",barrier=");
+        seq_puts(seq, test_opt(sb, BARRIER) ? "1" : "0");
+        if (test_opt(sb, JOURNAL_ASYNC_COMMIT))
+                seq_puts(seq, ",journal_async_commit");
         if (test_opt(sb, NOBH))
                 seq_puts(seq, ",nobh");
         if (!test_opt(sb, EXTENTS))
@@ -1907,6 +1915,7 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
         sbi->s_resgid = le16_to_cpu(es->s_def_resgid);
 
         set_opt(sbi->s_mount_opt, RESERVATION);
+        set_opt(sbi->s_mount_opt, BARRIER);
 
         /*
          * turn on extents feature by default in ext4 filesystem
@@ -2189,6 +2198,29 @@ static int ext4_fill_super (struct super_block *sb, void *data, int silent)
             EXT4_HAS_COMPAT_FEATURE(sb, EXT4_FEATURE_COMPAT_HAS_JOURNAL)) {
                 if (ext4_load_journal(sb, es, journal_devnum))
                         goto failed_mount3;
+                if (!(sb->s_flags & MS_RDONLY) &&
+                    EXT4_SB(sb)->s_journal->j_failed_commit) {
+                        printk(KERN_CRIT "EXT4-fs error (device %s): "
+                               "ext4_fill_super: Journal transaction "
+                               "%u is corrupt\n", sb->s_id, 
+                               EXT4_SB(sb)->s_journal->j_failed_commit);
+                        if (test_opt (sb, ERRORS_RO)) {
+                                printk (KERN_CRIT
+                                        "Mounting filesystem read-only\n");
+                                sb->s_flags |= MS_RDONLY;
+                                EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
+                                es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
+                        }
+                        if (test_opt(sb, ERRORS_PANIC)) {
+                                EXT4_SB(sb)->s_mount_state |= EXT4_ERROR_FS;
+                                es->s_state |= cpu_to_le16(EXT4_ERROR_FS);
+                                ext4_commit_super(sb, es, 1);
+                                printk(KERN_CRIT
+                                       "EXT4-fs (device %s): mount failed\n",
+                                      sb->s_id);
+                                goto failed_mount4;
+                        }
+                }
         } else if (journal_inum) {
                 if (ext4_create_journal(sb, es, journal_inum))
                         goto failed_mount3;
diff --git a/fs/fat/file.c b/fs/fat/file.c
index 27cc1164ec36..771326b8047e 100644
--- a/fs/fat/file.c
+++ b/fs/fat/file.c
@@ -257,26 +257,34 @@ int fat_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 }
 EXPORT_SYMBOL_GPL(fat_getattr);
 
-static int fat_check_mode(const struct msdos_sb_info *sbi, struct inode *inode,
-                          mode_t mode)
+static int fat_sanitize_mode(const struct msdos_sb_info *sbi,
+                             struct inode *inode, umode_t *mode_ptr)
 {
-        mode_t mask, req = mode & ~S_IFMT;
+        mode_t mask, perm;
 
-        if (S_ISREG(mode))
+        /*
+         * Note, the basic check is already done by a caller of
+         * (attr->ia_mode & ~MSDOS_VALID_MODE)
+         */
+
+        if (S_ISREG(inode->i_mode))
                 mask = sbi->options.fs_fmask;
         else
                 mask = sbi->options.fs_dmask;
 
+        perm = *mode_ptr & ~(S_IFMT | mask);
+
         /*
          * Of the r and x bits, all (subject to umask) must be present. Of the
          * w bits, either all (subject to umask) or none must be present.
          */
-        req &= ~mask;
-        if ((req & (S_IRUGO | S_IXUGO)) != (inode->i_mode & (S_IRUGO|S_IXUGO)))
+        if ((perm & (S_IRUGO | S_IXUGO)) != (inode->i_mode & (S_IRUGO|S_IXUGO)))
                 return -EPERM;
-        if ((req & S_IWUGO) && ((req & S_IWUGO) != (S_IWUGO & ~mask)))
+        if ((perm & S_IWUGO) && ((perm & S_IWUGO) != (S_IWUGO & ~mask)))
                 return -EPERM;
 
+        *mode_ptr &= S_IFMT | perm;
+
         return 0;
 }
 
@@ -299,7 +307,7 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
 {
         struct msdos_sb_info *sbi = MSDOS_SB(dentry->d_sb);
         struct inode *inode = dentry->d_inode;
-        int mask, error = 0;
+        int error = 0;
         unsigned int ia_valid;
 
         lock_kernel();
@@ -332,12 +340,13 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
                         error = 0;
                 goto out;
         }
+
         if (((attr->ia_valid & ATTR_UID) &&
              (attr->ia_uid != sbi->options.fs_uid)) ||
             ((attr->ia_valid & ATTR_GID) &&
              (attr->ia_gid != sbi->options.fs_gid)) ||
             ((attr->ia_valid & ATTR_MODE) &&
-             fat_check_mode(sbi, inode, attr->ia_mode) < 0))
+             (attr->ia_mode & ~MSDOS_VALID_MODE)))
                 error = -EPERM;
 
         if (error) {
@@ -346,15 +355,16 @@ int fat_setattr(struct dentry *dentry, struct iattr *attr)
                 goto out;
         }
 
-        error = inode_setattr(inode, attr);
-        if (error)
-                goto out;
+        /*
+         * We don't return -EPERM here. Yes, strange, but this is too
+         * old behavior.
+         */
+        if (attr->ia_valid & ATTR_MODE) {
+                if (fat_sanitize_mode(sbi, inode, &attr->ia_mode) < 0)
+                        attr->ia_valid &= ~ATTR_MODE;
+        }
 
-        if (S_ISDIR(inode->i_mode))
-                mask = sbi->options.fs_dmask;
-        else
-                mask = sbi->options.fs_fmask;
-        inode->i_mode &= S_IFMT | (S_IRWXUGO & ~mask);
+        error = inode_setattr(inode, attr);
 out:
         unlock_kernel();
         return error;
diff --git a/fs/file.c b/fs/file.c
index 4c6f0ea12c41..7b3887e054d0 100644
--- a/fs/file.c
+++ b/fs/file.c
@@ -26,6 +26,8 @@ struct fdtable_defer {
 };
 
 int sysctl_nr_open __read_mostly = 1024*1024;
+int sysctl_nr_open_min = BITS_PER_LONG;
+int sysctl_nr_open_max = 1024 * 1024; /* raised later */
 
 /*
  * We use this list to defer free fdtables that have vmalloced
@@ -119,8 +121,6 @@ static void copy_fdtable(struct fdtable *nfdt, struct fdtable *ofdt)
         unsigned int cpy, set;
 
         BUG_ON(nfdt->max_fds < ofdt->max_fds);
-        if (ofdt->max_fds == 0)
-                return;
 
         cpy = ofdt->max_fds * sizeof(struct file *);
         set = (nfdt->max_fds - ofdt->max_fds) * sizeof(struct file *);
@@ -261,6 +261,139 @@ int expand_files(struct files_struct *files, int nr)
         return expand_fdtable(files, nr);
 }
 
+static int count_open_files(struct fdtable *fdt)
+{
+        int size = fdt->max_fds;
+        int i;
+
+        /* Find the last open fd */
+        for (i = size/(8*sizeof(long)); i > 0; ) {
+                if (fdt->open_fds->fds_bits[--i])
+                        break;
+        }
+        i = (i+1) * 8 * sizeof(long);
+        return i;
+}
+
+/*
+ * Allocate a new files structure and copy contents from the
+ * passed in files structure.
+ * errorp will be valid only when the returned files_struct is NULL.
+ */
+struct files_struct *dup_fd(struct files_struct *oldf, int *errorp)
+{
+        struct files_struct *newf;
+        struct file **old_fds, **new_fds;
+        int open_files, size, i;
+        struct fdtable *old_fdt, *new_fdt;
+
+        *errorp = -ENOMEM;
+        newf = kmem_cache_alloc(files_cachep, GFP_KERNEL);
+        if (!newf)
+                goto out;
+
+        atomic_set(&newf->count, 1);
+
+        spin_lock_init(&newf->file_lock);
+        newf->next_fd = 0;
+        new_fdt = &newf->fdtab;
+        new_fdt->max_fds = NR_OPEN_DEFAULT;
+        new_fdt->close_on_exec = (fd_set *)&newf->close_on_exec_init;
+        new_fdt->open_fds = (fd_set *)&newf->open_fds_init;
+        new_fdt->fd = &newf->fd_array[0];
+        INIT_RCU_HEAD(&new_fdt->rcu);
+        new_fdt->next = NULL;
+
+        spin_lock(&oldf->file_lock);
+        old_fdt = files_fdtable(oldf);
+        open_files = count_open_files(old_fdt);
+
+        /*
+         * Check whether we need to allocate a larger fd array and fd set.
+         */
+        while (unlikely(open_files > new_fdt->max_fds)) {
+                spin_unlock(&oldf->file_lock);
+
+                if (new_fdt != &newf->fdtab) {
+                        free_fdarr(new_fdt);
+                        free_fdset(new_fdt);
+                        kfree(new_fdt);
+                }
+
+                new_fdt = alloc_fdtable(open_files - 1);
+                if (!new_fdt) {
+                        *errorp = -ENOMEM;
+                        goto out_release;
+                }
+
+                /* beyond sysctl_nr_open; nothing to do */
+                if (unlikely(new_fdt->max_fds < open_files)) {
+                        free_fdarr(new_fdt);
+                        free_fdset(new_fdt);
+                        kfree(new_fdt);
+                        *errorp = -EMFILE;
+                        goto out_release;
+                }
+
+                /*
+                 * Reacquire the oldf lock and a pointer to its fd table
+                 * who knows it may have a new bigger fd table. We need
+                 * the latest pointer.
+                 */
+                spin_lock(&oldf->file_lock);
+                old_fdt = files_fdtable(oldf);
+                open_files = count_open_files(old_fdt);
+        }
+
+        old_fds = old_fdt->fd;
+        new_fds = new_fdt->fd;
+
+        memcpy(new_fdt->open_fds->fds_bits,
+                old_fdt->open_fds->fds_bits, open_files/8);
+        memcpy(new_fdt->close_on_exec->fds_bits,
+                old_fdt->close_on_exec->fds_bits, open_files/8);
+
+        for (i = open_files; i != 0; i--) {
+                struct file *f = *old_fds++;
+                if (f) {
+                        get_file(f);
+                } else {
+                        /*
+                         * The fd may be claimed in the fd bitmap but not yet
+                         * instantiated in the files array if a sibling thread
+                         * is partway through open().  So make sure that this
+                         * fd is available to the new process.
+                         */
+                        FD_CLR(open_files - i, new_fdt->open_fds);
+                }
+                rcu_assign_pointer(*new_fds++, f);
+        }
+        spin_unlock(&oldf->file_lock);
+
+        /* compute the remainder to be cleared */
+        size = (new_fdt->max_fds - open_files) * sizeof(struct file *);
+
+        /* This is long word aligned thus could use a optimized version */
+        memset(new_fds, 0, size);
+
+        if (new_fdt->max_fds > open_files) {
+                int left = (new_fdt->max_fds-open_files)/8;
+                int start = open_files / (8 * sizeof(unsigned long));
+
+                memset(&new_fdt->open_fds->fds_bits[start], 0, left);
+                memset(&new_fdt->close_on_exec->fds_bits[start], 0, left);
+        }
+
+        rcu_assign_pointer(newf->fdt, new_fdt);
+
+        return newf;
+
+out_release:
+        kmem_cache_free(files_cachep, newf);
+out:
+        return NULL;
+}
+
 static void __devinit fdtable_defer_list_init(int cpu)
 {
         struct fdtable_defer *fddef = &per_cpu(fdtable_defer_list, cpu);
@@ -274,4 +407,19 @@ void __init files_defer_init(void)
         int i;
         for_each_possible_cpu(i)
                 fdtable_defer_list_init(i);
+        sysctl_nr_open_max = min((size_t)INT_MAX, ~(size_t)0/sizeof(void *)) &
+                             -BITS_PER_LONG;
 }
+
+struct files_struct init_files = {
+        .count          = ATOMIC_INIT(1),
+        .fdt            = &init_files.fdtab,
+        .fdtab          = {
+                .max_fds        = NR_OPEN_DEFAULT,
+                .fd             = &init_files.fd_array[0],
+                .close_on_exec  = (fd_set *)&init_files.close_on_exec_init,
+                .open_fds       = (fd_set *)&init_files.open_fds_init,
+                .rcu            = RCU_HEAD_INIT,
+        },
+        .file_lock      = __SPIN_LOCK_UNLOCKED(init_task.file_lock),
+};
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index fb77e0962132..3141690558c8 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -488,7 +488,12 @@ static struct fuse_conn *new_conn(struct super_block *sb)
                 err = bdi_init(&fc->bdi);
                 if (err)
                         goto error_kfree;
-                err = bdi_register_dev(&fc->bdi, fc->dev);
+                if (sb->s_bdev) {
+                        err = bdi_register(&fc->bdi, NULL, "%u:%u-fuseblk",
+                                           MAJOR(fc->dev), MINOR(fc->dev));
+                } else {
+                        err = bdi_register_dev(&fc->bdi, fc->dev);
+                }
                 if (err)
                         goto error_bdi_destroy;
                 /*
@@ -586,7 +591,7 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
                 fc->bdi.ra_pages = min(fc->bdi.ra_pages, ra_pages);
                 fc->minor = arg->minor;
                 fc->max_write = arg->minor < 5 ? 4096 : arg->max_write;
-                fc->max_write = min_t(unsigned, 4096, fc->max_write);
+                fc->max_write = max_t(unsigned, 4096, fc->max_write);
                 fc->conn_init = 1;
         }
         fuse_put_request(fc, req);
@@ -662,7 +667,7 @@ static int fuse_fill_super(struct super_block *sb, void *data, int silent)
         fc->flags = d.flags;
         fc->user_id = d.user_id;
         fc->group_id = d.group_id;
-        fc->max_read = min_t(unsigned, 4096, d.max_read);
+        fc->max_read = max_t(unsigned, 4096, d.max_read);
 
         /* Used by get_root_inode() */
         sb->s_fs_info = fc;
diff --git a/fs/gfs2/bmap.c b/fs/gfs2/bmap.c
index c19184f2e70e..bec76b1c2bb0 100644
--- a/fs/gfs2/bmap.c
+++ b/fs/gfs2/bmap.c
@@ -246,15 +246,11 @@ static void find_metapath(const struct gfs2_sbd *sdp, u64 block,
 
 }
 
-static inline unsigned int zero_metapath_length(const struct metapath *mp,
-                                                unsigned height)
+static inline unsigned int metapath_branch_start(const struct metapath *mp)
 {
-        unsigned int i;
-        for (i = 0; i < height - 1; i++) {
-                if (mp->mp_list[i] != 0)
-                        return i;
-        }
-        return height;
+        if (mp->mp_list[0] == 0)
+                return 2;
+        return 1;
 }
 
 /**
@@ -436,7 +432,7 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
         struct gfs2_sbd *sdp = GFS2_SB(inode);
         struct buffer_head *dibh = mp->mp_bh[0];
         u64 bn, dblock = 0;
-        unsigned n, i, blks, alloced = 0, iblks = 0, zmpl = 0;
+        unsigned n, i, blks, alloced = 0, iblks = 0, branch_start = 0;
         unsigned dblks = 0;
         unsigned ptrs_per_blk;
         const unsigned end_of_metadata = height - 1;
@@ -471,9 +467,8 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
                         /* Building up tree height */
                         state = ALLOC_GROW_HEIGHT;
                         iblks = height - ip->i_height;
-                        zmpl = zero_metapath_length(mp, height);
-                        iblks -= zmpl;
-                        iblks += height;
+                        branch_start = metapath_branch_start(mp);
+                        iblks += (height - branch_start);
                 }
         }
 
@@ -509,13 +504,13 @@ static int gfs2_bmap_alloc(struct inode *inode, const sector_t lblock,
                                         sizeof(struct gfs2_meta_header));
                                 *ptr = zero_bn;
                                 state = ALLOC_GROW_DEPTH;
-                                for(i = zmpl; i < height; i++) {
+                                for(i = branch_start; i < height; i++) {
                                         if (mp->mp_bh[i] == NULL)
                                                 break;
                                         brelse(mp->mp_bh[i]);
                                         mp->mp_bh[i] = NULL;
                                 }
-                                i = zmpl;
+                                i = branch_start;
                         }
                         if (n == 0)
                                 break;
diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index d31badadef8f..07d84d16cda4 100644
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -249,7 +249,7 @@ static int inode_go_lock(struct gfs2_holder *gh)
         struct gfs2_inode *ip = gl->gl_object;
         int error = 0;
 
-        if (!ip)
+        if (!ip || (gh->gh_flags & GL_SKIP))
                 return 0;
 
         if (test_bit(GIF_INVALID, &ip->i_flags)) {
diff --git a/fs/gfs2/incore.h b/fs/gfs2/incore.h
index 9c2c0b90b22a..eabe5eac41da 100644
--- a/fs/gfs2/incore.h
+++ b/fs/gfs2/incore.h
@@ -236,6 +236,7 @@ enum {
         GIF_INVALID             = 0,
         GIF_QD_LOCKED           = 1,
         GIF_SW_PAGED            = 3,
+        GIF_USER                = 4, /* user inode, not metadata addr space */
 };
 
 struct gfs2_dinode_host {
diff --git a/fs/gfs2/inode.c b/fs/gfs2/inode.c
index 3a9ef526c308..09453d057e41 100644
--- a/fs/gfs2/inode.c
+++ b/fs/gfs2/inode.c
@@ -47,8 +47,7 @@ static int iget_test(struct inode *inode, void *opaque)
         struct gfs2_inode *ip = GFS2_I(inode);
         u64 *no_addr = opaque;
 
-        if (ip->i_no_addr == *no_addr &&
-            inode->i_private != NULL)
+        if (ip->i_no_addr == *no_addr && test_bit(GIF_USER, &ip->i_flags))
                 return 1;
 
         return 0;
@@ -61,6 +60,7 @@ static int iget_set(struct inode *inode, void *opaque)
 
         inode->i_ino = (unsigned long)*no_addr;
         ip->i_no_addr = *no_addr;
+        set_bit(GIF_USER, &ip->i_flags);
         return 0;
 }
 
@@ -86,7 +86,7 @@ static int iget_skip_test(struct inode *inode, void *opaque)
         struct gfs2_inode *ip = GFS2_I(inode);
         struct gfs2_skip_data *data = opaque;
 
-        if (ip->i_no_addr == data->no_addr && inode->i_private != NULL){
+        if (ip->i_no_addr == data->no_addr && test_bit(GIF_USER, &ip->i_flags)){
                 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE)){
                         data->skipped = 1;
                         return 0;
@@ -105,6 +105,7 @@ static int iget_skip_set(struct inode *inode, void *opaque)
                 return 1;
         inode->i_ino = (unsigned long)(data->no_addr);
         ip->i_no_addr = data->no_addr;
+        set_bit(GIF_USER, &ip->i_flags);
         return 0;
 }
 
@@ -166,7 +167,7 @@ void gfs2_set_iop(struct inode *inode)
  * Returns: A VFS inode, or an error
  */
 
-struct inode *gfs2_inode_lookup(struct super_block *sb, 
+struct inode *gfs2_inode_lookup(struct super_block *sb,
                                 unsigned int type,
                                 u64 no_addr,
                                 u64 no_formal_ino, int skip_freeing)
@@ -187,7 +188,6 @@ struct inode *gfs2_inode_lookup(struct super_block *sb,
 
         if (inode->i_state & I_NEW) {
                 struct gfs2_sbd *sdp = GFS2_SB(inode);
-                inode->i_private = ip;
                 ip->i_no_formal_ino = no_formal_ino;
 
                 error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
diff --git a/fs/gfs2/meta_io.c b/fs/gfs2/meta_io.c
index 85aea27b4a86..78d75f892f82 100644
--- a/fs/gfs2/meta_io.c
+++ b/fs/gfs2/meta_io.c
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
+ * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
@@ -69,13 +69,15 @@ static const struct address_space_operations aspace_aops = {
 struct inode *gfs2_aspace_get(struct gfs2_sbd *sdp)
 {
         struct inode *aspace;
+        struct gfs2_inode *ip;
 
         aspace = new_inode(sdp->sd_vfs);
         if (aspace) {
                 mapping_set_gfp_mask(aspace->i_mapping, GFP_NOFS);
                 aspace->i_mapping->a_ops = &aspace_aops;
                 aspace->i_size = ~0ULL;
-                aspace->i_private = NULL;
+                ip = GFS2_I(aspace);
+                clear_bit(GIF_USER, &ip->i_flags);
                 insert_inode_hash(aspace);
         }
         return aspace;
diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index ef9c6c4f80f6..b2028c82e8d1 100644
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -142,8 +142,8 @@ static int init_names(struct gfs2_sbd *sdp, int silent)
         if (!table[0])
                 table = sdp->sd_vfs->s_id;
 
-        snprintf(sdp->sd_proto_name, GFS2_FSNAME_LEN, "%s", proto);
-        snprintf(sdp->sd_table_name, GFS2_FSNAME_LEN, "%s", table);
+        strlcpy(sdp->sd_proto_name, proto, GFS2_FSNAME_LEN);
+        strlcpy(sdp->sd_table_name, table, GFS2_FSNAME_LEN);
 
         table = sdp->sd_table_name;
         while ((table = strchr(table, '/')))
diff --git a/fs/gfs2/ops_super.c b/fs/gfs2/ops_super.c
index 2278c68b7e35..0b7cc920eb89 100644
--- a/fs/gfs2/ops_super.c
+++ b/fs/gfs2/ops_super.c
@@ -1,6 +1,6 @@
 /*
  * Copyright (C) Sistina Software, Inc.  1997-2003 All rights reserved.
- * Copyright (C) 2004-2006 Red Hat, Inc.  All rights reserved.
+ * Copyright (C) 2004-2008 Red Hat, Inc.  All rights reserved.
  *
  * This copyrighted material is made available to anyone wishing to use,
  * modify, copy, or redistribute it subject to the terms and conditions
@@ -52,7 +52,7 @@ static int gfs2_write_inode(struct inode *inode, int sync)
         struct gfs2_inode *ip = GFS2_I(inode);
 
         /* Check this is a "normal" inode */
-        if (inode->i_private) {
+        if (test_bit(GIF_USER, &ip->i_flags)) {
                 if (current->flags & PF_MEMALLOC)
                         return 0;
                 if (sync)
@@ -297,8 +297,9 @@ static int gfs2_remount_fs(struct super_block *sb, int *flags, char *data)
  */
 static void gfs2_drop_inode(struct inode *inode)
 {
-        if (inode->i_private && inode->i_nlink) {
-                struct gfs2_inode *ip = GFS2_I(inode);
+        struct gfs2_inode *ip = GFS2_I(inode);
+
+        if (test_bit(GIF_USER, &ip->i_flags) && inode->i_nlink) {
                 struct gfs2_glock *gl = ip->i_iopen_gh.gh_gl;
                 if (gl && test_bit(GLF_DEMOTE, &gl->gl_flags))
                         clear_nlink(inode);
@@ -314,12 +315,13 @@ static void gfs2_drop_inode(struct inode *inode)
 
 static void gfs2_clear_inode(struct inode *inode)
 {
+        struct gfs2_inode *ip = GFS2_I(inode);
+
         /* This tells us its a "real" inode and not one which only
          * serves to contain an address space (see rgrp.c, meta_io.c)
          * which therefore doesn't have its own glocks.
          */
-        if (inode->i_private) {
-                struct gfs2_inode *ip = GFS2_I(inode);
+        if (test_bit(GIF_USER, &ip->i_flags)) {
                 ip->i_gl->gl_object = NULL;
                 gfs2_glock_schedule_for_reclaim(ip->i_gl);
                 gfs2_glock_put(ip->i_gl);
@@ -419,7 +421,7 @@ static void gfs2_delete_inode(struct inode *inode)
         struct gfs2_holder gh;
         int error;
 
-        if (!inode->i_private)
+        if (!test_bit(GIF_USER, &ip->i_flags))
                 goto out;
 
         error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, 0, &gh);
diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 7e8f0b1d6c6e..3401628d742b 100644
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -195,7 +195,7 @@ ulong_aligned:
            depending on architecture.  I've experimented with several ways
            of writing this section such as using an else before the goto
            but this one seems to be the fastest. */
-        while ((unsigned char *)plong < end - 1) {
+        while ((unsigned char *)plong < end - sizeof(unsigned long)) {
                 prefetch(plong + 1);
                 if (((*plong) & LBITMASK) != lskipval)
                         break;
@@ -1495,7 +1495,7 @@ u64 gfs2_alloc_block(struct gfs2_inode *ip, unsigned int *n)
 
         al->al_alloced += *n;
 
-        gfs2_statfs_change(sdp, 0, -*n, 0);
+        gfs2_statfs_change(sdp, 0, -(s64)*n, 0);
         gfs2_quota_change(ip, *n, ip->i_inode.i_uid, ip->i_inode.i_gid);
 
         spin_lock(&sdp->sd_rindex_spin);
diff --git a/fs/hppfs/Makefile b/fs/hppfs/Makefile
index 8a1f50344368..3a982bd975d2 100644
--- a/fs/hppfs/Makefile
+++ b/fs/hppfs/Makefile
@@ -3,7 +3,4 @@
 # Licensed under the GPL
 #
 
-hppfs-objs := hppfs.o
-
-obj-y =
-obj-$(CONFIG_HPPFS) += $(hppfs-objs)
+obj-$(CONFIG_HPPFS) += hppfs.o
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index 4d99685fdce4..a2ed72f7ceee 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -168,6 +168,7 @@ static int journal_submit_commit_record(journal_t *journal,
                 spin_unlock(&journal->j_state_lock);
 
                 /* And try again, without the barrier */
+                lock_buffer(bh);
                 set_buffer_uptodate(bh);
                 set_buffer_dirty(bh);
                 ret = submit_bh(WRITE, bh);
diff --git a/fs/jbd2/recovery.c b/fs/jbd2/recovery.c
index 5d0405a9e7ca..058f50f65b76 100644
--- a/fs/jbd2/recovery.c
+++ b/fs/jbd2/recovery.c
@@ -344,6 +344,7 @@ static int calc_chksums(journal_t *journal, struct buffer_head *bh,
                         *crc32_sum = crc32_be(*crc32_sum, (void *)obh->b_data,
                                      obh->b_size);
                 }
+                put_bh(obh);
         }
         return 0;
 }
@@ -610,9 +611,8 @@ static int do_one_pass(journal_t *journal,
                                 chksum_err = chksum_seen = 0;
 
                                 if (info->end_transaction) {
-                                        printk(KERN_ERR "JBD: Transaction %u "
-                                                "found to be corrupt.\n",
-                                                next_commit_ID - 1);
+                                        journal->j_failed_commit =
+                                                info->end_transaction;
                                         brelse(bh);
                                         break;
                                 }
@@ -643,10 +643,8 @@ static int do_one_pass(journal_t *journal,
 
                                         if (!JBD2_HAS_INCOMPAT_FEATURE(journal,
                                            JBD2_FEATURE_INCOMPAT_ASYNC_COMMIT)){
-                                                printk(KERN_ERR
-                                                       "JBD: Transaction %u "
-                                                       "found to be corrupt.\n",
-                                                       next_commit_ID);
+                                                journal->j_failed_commit =
+                                                        next_commit_ID;
                                                 brelse(bh);
                                                 break;
                                         }
diff --git a/fs/libfs.c b/fs/libfs.c
index b004dfadd891..892d41cb3382 100644
--- a/fs/libfs.c
+++ b/fs/libfs.c
@@ -528,6 +528,23 @@ ssize_t simple_read_from_buffer(void __user *to, size_t count, loff_t *ppos,
         return count;
 }
 
+ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
+                                const void *from, size_t available)
+{
+        loff_t pos = *ppos;
+
+        if (pos < 0)
+                return -EINVAL;
+        if (pos >= available)
+                return 0;
+        if (count > available - pos)
+                count = available - pos;
+        memcpy(to, from + pos, count);
+        *ppos = pos + count;
+
+        return count;
+}
+
 /*
  * Transaction based IO.
  * The file expects a single write which triggers the transaction, and then
@@ -800,6 +817,7 @@ EXPORT_SYMBOL(simple_statfs);
 EXPORT_SYMBOL(simple_sync_file);
 EXPORT_SYMBOL(simple_unlink);
 EXPORT_SYMBOL(simple_read_from_buffer);
+EXPORT_SYMBOL(memory_read_from_buffer);
 EXPORT_SYMBOL(simple_transaction_get);
 EXPORT_SYMBOL(simple_transaction_read);
 EXPORT_SYMBOL(simple_transaction_release);
diff --git a/fs/locks.c b/fs/locks.c
index 11dbf08651b7..dce8c747371c 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -561,9 +561,6 @@ static void locks_insert_lock(struct file_lock **pos, struct file_lock *fl)
         /* insert into file's list */
         fl->fl_next = *pos;
         *pos = fl;
-
-        if (fl->fl_ops && fl->fl_ops->fl_insert)
-                fl->fl_ops->fl_insert(fl);
 }
 
 /*
@@ -586,9 +583,6 @@ static void locks_delete_lock(struct file_lock **thisfl_p)
                 fl->fl_fasync = NULL;
         }
 
-        if (fl->fl_ops && fl->fl_ops->fl_remove)
-                fl->fl_ops->fl_remove(fl);
-
         if (fl->fl_nspid) {
                 put_pid(fl->fl_nspid);
                 fl->fl_nspid = NULL;
diff --git a/fs/namei.c b/fs/namei.c
index 32fd9655485b..01e67dddcc3d 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -581,15 +581,13 @@ static __always_inline int link_path_walk(const char *name, struct nameidata *nd
         int result;
 
         /* make sure the stuff we saved doesn't go away */
-        dget(save.dentry);
-        mntget(save.mnt);
+        path_get(&save);
 
         result = __link_path_walk(name, nd);
         if (result == -ESTALE) {
                 /* nd->path had been dropped */
                 nd->path = save;
-                dget(nd->path.dentry);
-                mntget(nd->path.mnt);
+                path_get(&nd->path);
                 nd->flags |= LOOKUP_REVAL;
                 result = __link_path_walk(name, nd);
         }
@@ -1216,8 +1214,9 @@ int vfs_path_lookup(struct dentry *dentry, struct vfsmount *mnt,
         nd->flags = flags;
         nd->depth = 0;
 
-        nd->path.mnt = mntget(mnt);
-        nd->path.dentry = dget(dentry);
+        nd->path.dentry = dentry;
+        nd->path.mnt = mnt;
+        path_get(&nd->path);
 
         retval = path_walk(name, nd);
         if (unlikely(!retval && !audit_dummy_context() && nd->path.dentry &&
@@ -2003,18 +2002,22 @@ struct dentry *lookup_create(struct nameidata *nd, int is_dir)
         if (IS_ERR(dentry))
                 goto fail;
 
+        if (dentry->d_inode)
+                goto eexist;
         /*
          * Special case - lookup gave negative, but... we had foo/bar/
          * From the vfs_mknod() POV we just have a negative dentry -
          * all is fine. Let's be bastards - you had / on the end, you've
          * been asking for (non-existent) directory. -ENOENT for you.
          */
-        if (!is_dir && nd->last.name[nd->last.len] && !dentry->d_inode)
-                goto enoent;
+        if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
+                dput(dentry);
+                dentry = ERR_PTR(-ENOENT);
+        }
         return dentry;
-enoent:
+eexist:
         dput(dentry);
-        dentry = ERR_PTR(-ENOENT);
+        dentry = ERR_PTR(-EEXIST);
 fail:
         return dentry;
 }
@@ -2853,16 +2856,17 @@ int generic_readlink(struct dentry *dentry, char __user *buffer, int buflen)
 {
         struct nameidata nd;
         void *cookie;
+        int res;
 
         nd.depth = 0;
         cookie = dentry->d_inode->i_op->follow_link(dentry, &nd);
-        if (!IS_ERR(cookie)) {
-                int res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
-                if (dentry->d_inode->i_op->put_link)
-                        dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
-                cookie = ERR_PTR(res);
-        }
-        return PTR_ERR(cookie);
+        if (IS_ERR(cookie))
+                return PTR_ERR(cookie);
+
+        res = vfs_readlink(dentry, buffer, buflen, nd_get_link(&nd));
+        if (dentry->d_inode->i_op->put_link)
+                dentry->d_inode->i_op->put_link(dentry, &nd, cookie);
+        return res;
 }
 
 int vfs_follow_link(struct nameidata *nd, const char *link)
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 5606ae3d72d3..c1e7c8300629 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -182,7 +182,7 @@ static int nfs_callback_authenticate(struct svc_rqst *rqstp)
         if (clp == NULL)
                 return SVC_DROP;
 
-        dprintk("%s: %s NFSv4 callback!\n", __FUNCTION__,
+        dprintk("%s: %s NFSv4 callback!\n", __func__,
                         svc_print_addr(rqstp, buf, sizeof(buf)));
         nfs_put_client(clp);
 
diff --git a/fs/nfs/callback_proc.c b/fs/nfs/callback_proc.c
index 15f7785048d3..f7e83e23cf9f 100644
--- a/fs/nfs/callback_proc.c
+++ b/fs/nfs/callback_proc.c
@@ -57,7 +57,7 @@ out_iput:
 out_putclient:
         nfs_put_client(clp);
 out:
-        dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(res->status));
+        dprintk("%s: exit with status = %d\n", __func__, ntohl(res->status));
         return res->status;
 }
 
@@ -98,6 +98,6 @@ __be32 nfs4_callback_recall(struct cb_recallargs *args, void *dummy)
                 nfs_put_client(prev);
         } while (clp != NULL);
 out:
-        dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(res));
+        dprintk("%s: exit with status = %d\n", __func__, ntohl(res));
         return res;
 }
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index 13619d24f023..dd0ef34b5845 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -141,7 +141,7 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
         /* We do not like overly long tags! */
         if (hdr->taglen > CB_OP_TAGLEN_MAXSZ - 12) {
                 printk("NFSv4 CALLBACK %s: client sent tag of length %u\n",
-                                __FUNCTION__, hdr->taglen);
+                                __func__, hdr->taglen);
                 return htonl(NFS4ERR_RESOURCE);
         }
         p = read_buf(xdr, 12);
@@ -151,7 +151,7 @@ static __be32 decode_compound_hdr_arg(struct xdr_stream *xdr, struct cb_compound
         /* Check minor version is zero. */
         if (minor_version != 0) {
                 printk(KERN_WARNING "%s: NFSv4 server callback with illegal minor version %u!\n",
-                                __FUNCTION__, minor_version);
+                                __func__, minor_version);
                 return htonl(NFS4ERR_MINOR_VERS_MISMATCH);
         }
         hdr->callback_ident = ntohl(*p++);
@@ -179,7 +179,7 @@ static __be32 decode_getattr_args(struct svc_rqst *rqstp, struct xdr_stream *xdr
         args->addr = svc_addr(rqstp);
         status = decode_bitmap(xdr, args->bitmap);
 out:
-        dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(status));
+        dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
         return status;
 }
 
@@ -200,7 +200,7 @@ static __be32 decode_recall_args(struct svc_rqst *rqstp, struct xdr_stream *xdr,
         args->truncate = ntohl(*p);
         status = decode_fh(xdr, &args->fh);
 out:
-        dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(status));
+        dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
         return status;
 }
 
@@ -349,7 +349,7 @@ static __be32 encode_getattr_res(struct svc_rqst *rqstp, struct xdr_stream *xdr,
         status = encode_attr_mtime(xdr, res->bitmap, &res->mtime);
         *savep = htonl((unsigned int)((char *)xdr->p - (char *)(savep+1)));
 out:
-        dprintk("%s: exit with status = %d\n", __FUNCTION__, ntohl(status));
+        dprintk("%s: exit with status = %d\n", __func__, ntohl(status));
         return status;
 }
 
@@ -363,7 +363,7 @@ static __be32 process_op(struct svc_rqst *rqstp,
         long maxlen;
         __be32 res;
 
-        dprintk("%s: start\n", __FUNCTION__);
+        dprintk("%s: start\n", __func__);
         status = decode_op_hdr(xdr_in, &op_nr);
         if (likely(status == 0)) {
                 switch (op_nr) {
@@ -392,7 +392,7 @@ static __be32 process_op(struct svc_rqst *rqstp,
                 status = res;
         if (op->encode_res != NULL && status == 0)
                 status = op->encode_res(rqstp, xdr_out, resp);
-        dprintk("%s: done, status = %d\n", __FUNCTION__, ntohl(status));
+        dprintk("%s: done, status = %d\n", __func__, ntohl(status));
         return status;
 }
 
@@ -401,37 +401,37 @@ static __be32 process_op(struct svc_rqst *rqstp,
  */
 static __be32 nfs4_callback_compound(struct svc_rqst *rqstp, void *argp, void *resp)
 {
-        struct cb_compound_hdr_arg hdr_arg;
-        struct cb_compound_hdr_res hdr_res;
+        struct cb_compound_hdr_arg hdr_arg = { 0 };
+        struct cb_compound_hdr_res hdr_res = { NULL };
         struct xdr_stream xdr_in, xdr_out;
         __be32 *p;
         __be32 status;
-        unsigned int nops = 1;
+        unsigned int nops = 0;
 
-        dprintk("%s: start\n", __FUNCTION__);
+        dprintk("%s: start\n", __func__);
 
         xdr_init_decode(&xdr_in, &rqstp->rq_arg, rqstp->rq_arg.head[0].iov_base);
 
         p = (__be32*)((char *)rqstp->rq_res.head[0].iov_base + rqstp->rq_res.head[0].iov_len);
         xdr_init_encode(&xdr_out, &rqstp->rq_res, p);
 
-        decode_compound_hdr_arg(&xdr_in, &hdr_arg);
+        status = decode_compound_hdr_arg(&xdr_in, &hdr_arg);
+        if (status == __constant_htonl(NFS4ERR_RESOURCE))
+                return rpc_garbage_args;
+
         hdr_res.taglen = hdr_arg.taglen;
         hdr_res.tag = hdr_arg.tag;
-        hdr_res.nops = NULL;
-        encode_compound_hdr_res(&xdr_out, &hdr_res);
+        if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
+                return rpc_system_err;
 
-        for (;;) {
+        while (status == 0 && nops != hdr_arg.nops) {
                 status = process_op(rqstp, &xdr_in, argp, &xdr_out, resp);
-                if (status != 0)
-                        break;
-                if (nops == hdr_arg.nops)
-                        break;
                 nops++;
         }
+
         *hdr_res.status = status;
         *hdr_res.nops = htonl(nops);
-        dprintk("%s: done, status = %u\n", __FUNCTION__, ntohl(status));
+        dprintk("%s: done, status = %u\n", __func__, ntohl(status));
         return rpc_success;
 }
 
diff --git a/fs/nfs/client.c b/fs/nfs/client.c
index 89ac5bb0401c..f2a092ca69b5 100644
--- a/fs/nfs/client.c
+++ b/fs/nfs/client.c
@@ -488,7 +488,7 @@ static int nfs_create_rpc_client(struct nfs_client *clp,
         clnt = rpc_create(&args);
         if (IS_ERR(clnt)) {
                 dprintk("%s: cannot create RPC client. Error = %ld\n",
-                                __FUNCTION__, PTR_ERR(clnt));
+                                __func__, PTR_ERR(clnt));
                 return PTR_ERR(clnt);
         }
 
@@ -576,7 +576,7 @@ static int nfs_init_server_rpcclient(struct nfs_server *server,
 
         server->client = rpc_clone_client(clp->cl_rpcclient);
         if (IS_ERR(server->client)) {
-                dprintk("%s: couldn't create rpc_client!\n", __FUNCTION__);
+                dprintk("%s: couldn't create rpc_client!\n", __func__);
                 return PTR_ERR(server->client);
         }
 
@@ -590,7 +590,7 @@ static int nfs_init_server_rpcclient(struct nfs_server *server,
 
                 auth = rpcauth_create(pseudoflavour, server->client);
                 if (IS_ERR(auth)) {
-                        dprintk("%s: couldn't create credcache!\n", __FUNCTION__);
+                        dprintk("%s: couldn't create credcache!\n", __func__);
                         return PTR_ERR(auth);
                 }
         }
@@ -985,7 +985,7 @@ static int nfs4_init_client(struct nfs_client *clp,
         error = nfs_idmap_new(clp);
         if (error < 0) {
                 dprintk("%s: failed to create idmapper. Error = %d\n",
-                        __FUNCTION__, error);
+                        __func__, error);
                 goto error;
         }
         __set_bit(NFS_CS_IDMAP, &clp->cl_res_state);
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index 00a5e4405e16..cc563cfa6940 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -60,7 +60,7 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_
                 switch (status) {
                         default:
                                 printk(KERN_ERR "%s: unhandled error %d.\n",
-                                                __FUNCTION__, status);
+                                                __func__, status);
                         case -NFS4ERR_EXPIRED:
                                 /* kill_proc(fl->fl_pid, SIGLOST, 1); */
                         case -NFS4ERR_STALE_CLIENTID:
@@ -186,7 +186,7 @@ int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct
                  */
                 dfprintk(FILE, "%s: server %s handed out "
                                 "a duplicate delegation!\n",
-                                __FUNCTION__, clp->cl_hostname);
+                                __func__, clp->cl_hostname);
                 if (delegation->type <= nfsi->delegation->type) {
                         freeme = delegation;
                         delegation = NULL;
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index f288b3ecab4a..58d43daec084 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -180,7 +180,7 @@ int nfs_readdir_filler(nfs_readdir_descriptor_t *desc, struct page *page)
         int             error;
 
         dfprintk(DIRCACHE, "NFS: %s: reading cookie %Lu into page %lu\n",
-                        __FUNCTION__, (long long)desc->entry->cookie,
+                        __func__, (long long)desc->entry->cookie,
                         page->index);
 
  again:
@@ -256,7 +256,7 @@ int find_dirent(nfs_readdir_descriptor_t *desc)
 
         while((status = dir_decode(desc)) == 0) {
                 dfprintk(DIRCACHE, "NFS: %s: examining cookie %Lu\n",
-                                __FUNCTION__, (unsigned long long)entry->cookie);
+                                __func__, (unsigned long long)entry->cookie);
                 if (entry->prev_cookie == *desc->dir_cookie)
                         break;
                 if (loop_count++ > 200) {
@@ -315,7 +315,7 @@ int find_dirent_page(nfs_readdir_descriptor_t *desc)
         int             status;
 
         dfprintk(DIRCACHE, "NFS: %s: searching page %ld for target %Lu\n",
-                        __FUNCTION__, desc->page_index,
+                        __func__, desc->page_index,
                         (long long) *desc->dir_cookie);
 
         /* If we find the page in the page_cache, we cannot be sure
@@ -339,7 +339,7 @@ int find_dirent_page(nfs_readdir_descriptor_t *desc)
         if (status < 0)
                 dir_page_release(desc);
  out:
-        dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, status);
+        dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, status);
         return status;
 }
 
@@ -380,7 +380,7 @@ int readdir_search_pagecache(nfs_readdir_descriptor_t *desc)
                 }
         }
 
-        dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __FUNCTION__, res);
+        dfprintk(DIRCACHE, "NFS: %s: returns %d\n", __func__, res);
         return res;
 }
 
@@ -506,7 +506,7 @@ int uncached_readdir(nfs_readdir_descriptor_t *desc, void *dirent,
         desc->entry->eof = 0;
  out:
         dfprintk(DIRCACHE, "NFS: %s: returns %d\n",
-                        __FUNCTION__, status);
+                        __func__, status);
         return status;
  out_release:
         dir_page_release(desc);
@@ -780,7 +780,7 @@ static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
 
         if (is_bad_inode(inode)) {
                 dfprintk(LOOKUPCACHE, "%s: %s/%s has dud inode\n",
-                                __FUNCTION__, dentry->d_parent->d_name.name,
+                                __func__, dentry->d_parent->d_name.name,
                                 dentry->d_name.name);
                 goto out_bad;
         }
@@ -808,7 +808,7 @@ static int nfs_lookup_revalidate(struct dentry * dentry, struct nameidata *nd)
         unlock_kernel();
         dput(parent);
         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is valid\n",
-                        __FUNCTION__, dentry->d_parent->d_name.name,
+                        __func__, dentry->d_parent->d_name.name,
                         dentry->d_name.name);
         return 1;
 out_zap_parent:
@@ -827,7 +827,7 @@ out_zap_parent:
         unlock_kernel();
         dput(parent);
         dfprintk(LOOKUPCACHE, "NFS: %s(%s/%s) is invalid\n",
-                        __FUNCTION__, dentry->d_parent->d_name.name,
+                        __func__, dentry->d_parent->d_name.name,
                         dentry->d_name.name);
         return 0;
 }
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index 3536b01164f9..d84a3d8f32af 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -526,7 +526,7 @@ static int do_vfs_lock(struct file *file, struct file_lock *fl)
         if (res < 0)
                 dprintk(KERN_WARNING "%s: VFS is out of sync with lock manager"
                         " - error %d!\n",
-                                __FUNCTION__, res);
+                                __func__, res);
         return res;
 }
 
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 5cb3345eb694..596c5d8e86f4 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -541,8 +541,7 @@ static void __put_nfs_open_context(struct nfs_open_context *ctx, int wait)
         }
         if (ctx->cred != NULL)
                 put_rpccred(ctx->cred);
-        dput(ctx->path.dentry);
-        mntput(ctx->path.mnt);
+        path_put(&ctx->path);
         kfree(ctx);
 }
 
@@ -707,6 +706,13 @@ int nfs_attribute_timeout(struct inode *inode)
 
         if (nfs_have_delegation(inode, FMODE_READ))
                 return 0;
+        /*
+         * Special case: if the attribute timeout is set to 0, then always
+         *               treat the cache as having expired (unless holding
+         *               a delegation).
+         */
+        if (nfsi->attrtimeo == 0)
+                return 1;
         return !time_in_range(jiffies, nfsi->read_cache_jiffies, nfsi->read_cache_jiffies + nfsi->attrtimeo);
 }
 
@@ -995,7 +1001,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
         unsigned long now = jiffies;
 
         dfprintk(VFS, "NFS: %s(%s/%ld ct=%d info=0x%x)\n",
-                        __FUNCTION__, inode->i_sb->s_id, inode->i_ino,
+                        __func__, inode->i_sb->s_id, inode->i_ino,
                         atomic_read(&inode->i_count), fattr->valid);
 
         if (nfsi->fileid != fattr->fileid)
@@ -1119,7 +1125,7 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
          * Big trouble! The inode has become a different object.
          */
         printk(KERN_DEBUG "%s: inode %ld mode changed, %07o to %07o\n",
-                        __FUNCTION__, inode->i_ino, inode->i_mode, fattr->mode);
+                        __func__, inode->i_ino, inode->i_mode, fattr->mode);
  out_err:
         /*
          * No need to worry about unhashing the dentry, as the
diff --git a/fs/nfs/mount_clnt.c b/fs/nfs/mount_clnt.c
index 49c7cd0502cc..779d2eb649c5 100644
--- a/fs/nfs/mount_clnt.c
+++ b/fs/nfs/mount_clnt.c
@@ -130,10 +130,11 @@ static int xdr_decode_fhstatus3(struct rpc_rqst *req, __be32 *p,
                                 struct mnt_fhstatus *res)
 {
         struct nfs_fh *fh = res->fh;
+        unsigned size;
 
         if ((res->status = ntohl(*p++)) == 0) {
-                int size = ntohl(*p++);
-                if (size <= NFS3_FHSIZE) {
+                size = ntohl(*p++);
+                if (size <= NFS3_FHSIZE && size != 0) {
                         fh->size = size;
                         memcpy(fh->data, p, size);
                 } else
diff --git a/fs/nfs/namespace.c b/fs/nfs/namespace.c
index af4d0f1e402c..2f285ef76399 100644
--- a/fs/nfs/namespace.c
+++ b/fs/nfs/namespace.c
@@ -106,7 +106,7 @@ static void * nfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
         dprintk("--> nfs_follow_mountpoint()\n");
 
         BUG_ON(IS_ROOT(dentry));
-        dprintk("%s: enter\n", __FUNCTION__);
+        dprintk("%s: enter\n", __func__);
         dput(nd->path.dentry);
         nd->path.dentry = dget(dentry);
 
@@ -137,13 +137,12 @@ static void * nfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
                         goto out_follow;
                 goto out_err;
         }
-        mntput(nd->path.mnt);
-        dput(nd->path.dentry);
+        path_put(&nd->path);
         nd->path.mnt = mnt;
         nd->path.dentry = dget(mnt->mnt_root);
         schedule_delayed_work(&nfs_automount_task, nfs_mountpoint_expiry_timeout);
 out:
-        dprintk("%s: done, returned %d\n", __FUNCTION__, err);
+        dprintk("%s: done, returned %d\n", __func__, err);
 
         dprintk("<-- nfs_follow_mountpoint() = %d\n", err);
         return ERR_PTR(err);
@@ -230,7 +229,7 @@ static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
 
         dprintk("--> nfs_do_submount()\n");
 
-        dprintk("%s: submounting on %s/%s\n", __FUNCTION__,
+        dprintk("%s: submounting on %s/%s\n", __func__,
                         dentry->d_parent->d_name.name,
                         dentry->d_name.name);
         if (page == NULL)
@@ -243,7 +242,7 @@ static struct vfsmount *nfs_do_submount(const struct vfsmount *mnt_parent,
 free_page:
         free_page((unsigned long)page);
 out:
-        dprintk("%s: done\n", __FUNCTION__);
+        dprintk("%s: done\n", __func__);
 
         dprintk("<-- nfs_do_submount() = %p\n", mnt);
         return mnt;
diff --git a/fs/nfs/nfs3proc.c b/fs/nfs/nfs3proc.c
index 549dbce714a4..c3523ad03ed1 100644
--- a/fs/nfs/nfs3proc.c
+++ b/fs/nfs/nfs3proc.c
@@ -63,15 +63,15 @@ do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
         };
         int     status;
 
-        dprintk("%s: call  fsinfo\n", __FUNCTION__);
+        dprintk("%s: call  fsinfo\n", __func__);
         nfs_fattr_init(info->fattr);
         status = rpc_call_sync(client, &msg, 0);
-        dprintk("%s: reply fsinfo: %d\n", __FUNCTION__, status);
+        dprintk("%s: reply fsinfo: %d\n", __func__, status);
         if (!(info->fattr->valid & NFS_ATTR_FATTR)) {
                 msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
                 msg.rpc_resp = info->fattr;
                 status = rpc_call_sync(client, &msg, 0);
-                dprintk("%s: reply getattr: %d\n", __FUNCTION__, status);
+                dprintk("%s: reply getattr: %d\n", __func__, status);
         }
         return status;
 }
diff --git a/fs/nfs/nfs4_fs.h b/fs/nfs/nfs4_fs.h
index bd1b9d663fb9..ea790645fda6 100644
--- a/fs/nfs/nfs4_fs.h
+++ b/fs/nfs/nfs4_fs.h
@@ -206,7 +206,6 @@ struct rpc_cred *nfs4_get_renew_cred(struct nfs_client *clp);
 
 extern struct nfs4_state_owner * nfs4_get_state_owner(struct nfs_server *, struct rpc_cred *);
 extern void nfs4_put_state_owner(struct nfs4_state_owner *);
-extern void nfs4_drop_state_owner(struct nfs4_state_owner *);
 extern struct nfs4_state * nfs4_get_open_state(struct inode *, struct nfs4_state_owner *);
 extern void nfs4_put_open_state(struct nfs4_state *);
 extern void nfs4_close_state(struct path *, struct nfs4_state *, mode_t);
diff --git a/fs/nfs/nfs4namespace.c b/fs/nfs/nfs4namespace.c
index 5f9ba41ed5bf..b112857301f7 100644
--- a/fs/nfs/nfs4namespace.c
+++ b/fs/nfs/nfs4namespace.c
@@ -86,7 +86,7 @@ static int nfs4_validate_fspath(const struct vfsmount *mnt_parent,
 
         if (strncmp(path, fs_path, strlen(fs_path)) != 0) {
                 dprintk("%s: path %s does not begin with fsroot %s\n",
-                        __FUNCTION__, path, fs_path);
+                        __func__, path, fs_path);
                 return -ENOENT;
         }
 
@@ -134,7 +134,7 @@ static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
         if (locations == NULL || locations->nlocations <= 0)
                 goto out;
 
-        dprintk("%s: referral at %s/%s\n", __FUNCTION__,
+        dprintk("%s: referral at %s/%s\n", __func__,
                 dentry->d_parent->d_name.name, dentry->d_name.name);
 
         page = (char *) __get_free_page(GFP_USER);
@@ -204,7 +204,7 @@ static struct vfsmount *nfs_follow_referral(const struct vfsmount *mnt_parent,
 out:
         free_page((unsigned long) page);
         free_page((unsigned long) page2);
-        dprintk("%s: done\n", __FUNCTION__);
+        dprintk("%s: done\n", __func__);
         return mnt;
 }
 
@@ -223,7 +223,7 @@ struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentr
         int err;
 
         /* BUG_ON(IS_ROOT(dentry)); */
-        dprintk("%s: enter\n", __FUNCTION__);
+        dprintk("%s: enter\n", __func__);
 
         page = alloc_page(GFP_KERNEL);
         if (page == NULL)
@@ -238,7 +238,7 @@ struct vfsmount *nfs_do_refmount(const struct vfsmount *mnt_parent, struct dentr
 
         parent = dget_parent(dentry);
         dprintk("%s: getting locations for %s/%s\n",
-                __FUNCTION__, parent->d_name.name, dentry->d_name.name);
+                __func__, parent->d_name.name, dentry->d_name.name);
 
         err = nfs4_proc_fs_locations(parent->d_inode, &dentry->d_name, fs_locations, page);
         dput(parent);
@@ -252,6 +252,6 @@ out_free:
         __free_page(page);
         kfree(fs_locations);
 out:
-        dprintk("%s: done\n", __FUNCTION__);
+        dprintk("%s: done\n", __func__);
         return mnt;
 }
diff --git a/fs/nfs/nfs4proc.c b/fs/nfs/nfs4proc.c
index dbc09271af02..1293e0acd82b 100644
--- a/fs/nfs/nfs4proc.c
+++ b/fs/nfs/nfs4proc.c
@@ -73,7 +73,7 @@ int nfs4_map_errors(int err)
 {
         if (err < -1000) {
                 dprintk("%s could not handle NFSv4 error %d\n",
-                                __FUNCTION__, -err);
+                                __func__, -err);
                 return -EIO;
         }
         return err;
@@ -306,8 +306,7 @@ static void nfs4_opendata_free(struct kref *kref)
                 nfs4_put_open_state(p->state);
         nfs4_put_state_owner(p->owner);
         dput(p->dir);
-        dput(p->path.dentry);
-        mntput(p->path.mnt);
+        path_put(&p->path);
         kfree(p);
 }
 
@@ -1210,8 +1209,7 @@ static void nfs4_free_closedata(void *data)
         nfs4_put_open_state(calldata->state);
         nfs_free_seqid(calldata->arg.seqid);
         nfs4_put_state_owner(sp);
-        dput(calldata->path.dentry);
-        mntput(calldata->path.mnt);
+        path_put(&calldata->path);
         kfree(calldata);
 }
 
@@ -1578,7 +1576,7 @@ static int nfs4_get_referral(struct inode *dir, const struct qstr *name, struct
                 goto out;
         /* Make sure server returned a different fsid for the referral */
         if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
-                dprintk("%s: server did not return a different fsid for a referral at %s\n", __FUNCTION__, name->name);
+                dprintk("%s: server did not return a different fsid for a referral at %s\n", __func__, name->name);
                 status = -EIO;
                 goto out;
         }
@@ -2211,7 +2209,7 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
         };
         int                     status;
 
-        dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __FUNCTION__,
+        dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,
                         dentry->d_parent->d_name.name,
                         dentry->d_name.name,
                         (unsigned long long)cookie);
@@ -2223,7 +2221,7 @@ static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
 
         nfs_invalidate_atime(dir);
 
-        dprintk("%s: returns %d\n", __FUNCTION__, status);
+        dprintk("%s: returns %d\n", __func__, status);
         return status;
 }
 
@@ -3342,7 +3340,7 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
         struct nfs4_lockdata *data = calldata;
         struct nfs4_state *state = data->lsp->ls_state;
 
-        dprintk("%s: begin!\n", __FUNCTION__);
+        dprintk("%s: begin!\n", __func__);
         if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
                 return;
         /* Do we need to do an open_to_lock_owner? */
@@ -3356,14 +3354,14 @@ static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
                 data->arg.new_lock_owner = 0;
         data->timestamp = jiffies;
         rpc_call_start(task);
-        dprintk("%s: done!, ret = %d\n", __FUNCTION__, data->rpc_status);
+        dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
 }
 
 static void nfs4_lock_done(struct rpc_task *task, void *calldata)
 {
         struct nfs4_lockdata *data = calldata;
 
-        dprintk("%s: begin!\n", __FUNCTION__);
+        dprintk("%s: begin!\n", __func__);
 
         data->rpc_status = task->tk_status;
         if (RPC_ASSASSINATED(task))
@@ -3381,14 +3379,14 @@ static void nfs4_lock_done(struct rpc_task *task, void *calldata)
                 renew_lease(NFS_SERVER(data->ctx->path.dentry->d_inode), data->timestamp);
         }
 out:
-        dprintk("%s: done, ret = %d!\n", __FUNCTION__, data->rpc_status);
+        dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
 }
 
 static void nfs4_lock_release(void *calldata)
 {
         struct nfs4_lockdata *data = calldata;
 
-        dprintk("%s: begin!\n", __FUNCTION__);
+        dprintk("%s: begin!\n", __func__);
         nfs_free_seqid(data->arg.open_seqid);
         if (data->cancelled != 0) {
                 struct rpc_task *task;
@@ -3396,13 +3394,13 @@ static void nfs4_lock_release(void *calldata)
                                 data->arg.lock_seqid);
                 if (!IS_ERR(task))
                         rpc_put_task(task);
-                dprintk("%s: cancelling lock!\n", __FUNCTION__);
+                dprintk("%s: cancelling lock!\n", __func__);
         } else
                 nfs_free_seqid(data->arg.lock_seqid);
         nfs4_put_lock_state(data->lsp);
         put_nfs_open_context(data->ctx);
         kfree(data);
-        dprintk("%s: done!\n", __FUNCTION__);
+        dprintk("%s: done!\n", __func__);
 }
 
 static const struct rpc_call_ops nfs4_lock_ops = {
@@ -3428,7 +3426,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
         };
         int ret;
 
-        dprintk("%s: begin!\n", __FUNCTION__);
+        dprintk("%s: begin!\n", __func__);
         data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
                         fl->fl_u.nfs4_fl.owner);
         if (data == NULL)
@@ -3451,7 +3449,7 @@ static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *f
         } else
                 data->cancelled = 1;
         rpc_put_task(task);
-        dprintk("%s: done, ret = %d!\n", __FUNCTION__, ret);
+        dprintk("%s: done, ret = %d!\n", __func__, ret);
         return ret;
 }
 
@@ -3527,7 +3525,7 @@ static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock
         /* Note: we always want to sleep here! */
         request->fl_flags = fl_flags | FL_SLEEP;
         if (do_vfs_lock(request->fl_file, request) < 0)
-                printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __FUNCTION__);
+                printk(KERN_WARNING "%s: VFS is out of sync with lock manager!\n", __func__);
 out_unlock:
         up_read(&clp->cl_sem);
 out:
@@ -3665,12 +3663,12 @@ int nfs4_proc_fs_locations(struct inode *dir, const struct qstr *name,
         };
         int status;
 
-        dprintk("%s: start\n", __FUNCTION__);
+        dprintk("%s: start\n", __func__);
         nfs_fattr_init(&fs_locations->fattr);
         fs_locations->server = server;
         fs_locations->nlocations = 0;
         status = rpc_call_sync(server->client, &msg, 0);
-        dprintk("%s: returned status = %d\n", __FUNCTION__, status);
+        dprintk("%s: returned status = %d\n", __func__, status);
         return status;
 }
 
diff --git a/fs/nfs/nfs4renewd.c b/fs/nfs/nfs4renewd.c
index 5e2e4af1a0e6..3305acbbe2ae 100644
--- a/fs/nfs/nfs4renewd.c
+++ b/fs/nfs/nfs4renewd.c
@@ -66,7 +66,7 @@ nfs4_renew_state(struct work_struct *work)
         unsigned long last, now;
 
         down_read(&clp->cl_sem);
-        dprintk("%s: start\n", __FUNCTION__);
+        dprintk("%s: start\n", __func__);
         /* Are there any active superblocks? */
         if (list_empty(&clp->cl_superblocks))
                 goto out;
@@ -92,17 +92,17 @@ nfs4_renew_state(struct work_struct *work)
                 spin_lock(&clp->cl_lock);
         } else
                 dprintk("%s: failed to call renewd. Reason: lease not expired \n",
-                                __FUNCTION__);
+                                __func__);
         if (timeout < 5 * HZ)    /* safeguard */
                 timeout = 5 * HZ;
         dprintk("%s: requeueing work. Lease period = %ld\n",
-                        __FUNCTION__, (timeout + HZ - 1) / HZ);
+                        __func__, (timeout + HZ - 1) / HZ);
         cancel_delayed_work(&clp->cl_renewd);
         schedule_delayed_work(&clp->cl_renewd, timeout);
         spin_unlock(&clp->cl_lock);
 out:
         up_read(&clp->cl_sem);
-        dprintk("%s: done\n", __FUNCTION__);
+        dprintk("%s: done\n", __func__);
 }
 
 /* Must be called with clp->cl_sem locked for writes */
@@ -117,7 +117,7 @@ nfs4_schedule_state_renewal(struct nfs_client *clp)
         if (timeout < 5 * HZ)
                 timeout = 5 * HZ;
         dprintk("%s: requeueing work. Lease period = %ld\n",
-                        __FUNCTION__, (timeout + HZ - 1) / HZ);
+                        __func__, (timeout + HZ - 1) / HZ);
         cancel_delayed_work(&clp->cl_renewd);
         schedule_delayed_work(&clp->cl_renewd, timeout);
         set_bit(NFS_CS_RENEWD, &clp->cl_res_state);
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 46eb624e4f16..856a8934f610 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -282,7 +282,7 @@ nfs4_alloc_state_owner(void)
         return sp;
 }
 
-void
+static void
 nfs4_drop_state_owner(struct nfs4_state_owner *sp)
 {
         if (!RB_EMPTY_NODE(&sp->so_client_node)) {
@@ -828,7 +828,7 @@ static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_s
                 switch (status) {
                         default:
                                 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
-                                                __FUNCTION__, status);
+                                                __func__, status);
                         case -NFS4ERR_EXPIRED:
                         case -NFS4ERR_NO_GRACE:
                         case -NFS4ERR_RECLAIM_BAD:
@@ -869,14 +869,14 @@ static int nfs4_reclaim_open_state(struct nfs4_state_recovery_ops *ops, struct n
                         list_for_each_entry(lock, &state->lock_states, ls_locks) {
                                 if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
                                         printk("%s: Lock reclaim failed!\n",
-                                                        __FUNCTION__);
+                                                        __func__);
                         }
                         continue;
                 }
                 switch (status) {
                         default:
                                 printk(KERN_ERR "%s: unhandled error %d. Zeroing state\n",
-                                                __FUNCTION__, status);
+                                                __func__, status);
                         case -ENOENT:
                         case -NFS4ERR_RECLAIM_BAD:
                         case -NFS4ERR_RECLAIM_CONFLICT:
diff --git a/fs/nfs/nfs4xdr.c b/fs/nfs/nfs4xdr.c
index 5a2d64927b35..b916297d2334 100644
--- a/fs/nfs/nfs4xdr.c
+++ b/fs/nfs/nfs4xdr.c
@@ -1831,7 +1831,7 @@ static int nfs4_xdr_enc_readdir(struct rpc_rqst *req, __be32 *p, const struct nf
         xdr_inline_pages(&req->rq_rcv_buf, replen, args->pages,
                          args->pgbase, args->count);
         dprintk("%s: inlined page args = (%u, %p, %u, %u)\n",
-                        __FUNCTION__, replen, args->pages,
+                        __func__, replen, args->pages,
                         args->pgbase, args->count);
 
 out:
@@ -2192,9 +2192,9 @@ out:
         p = xdr_inline_decode(xdr, nbytes); \
         if (unlikely(!p)) { \
                 dprintk("nfs: %s: prematurely hit end of receive" \
-                                " buffer\n", __FUNCTION__); \
+                                " buffer\n", __func__); \
                 dprintk("nfs: %s: xdr->p=%p, bytes=%u, xdr->end=%p\n", \
-                                __FUNCTION__, xdr->p, nbytes, xdr->end); \
+                                __func__, xdr->p, nbytes, xdr->end); \
                 return -EIO; \
         } \
 } while (0)
@@ -2306,12 +2306,12 @@ static int decode_attr_type(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *
                 READ_BUF(4);
                 READ32(*type);
                 if (*type < NF4REG || *type > NF4NAMEDATTR) {
-                        dprintk("%s: bad type %d\n", __FUNCTION__, *type);
+                        dprintk("%s: bad type %d\n", __func__, *type);
                         return -EIO;
                 }
                 bitmap[0] &= ~FATTR4_WORD0_TYPE;
         }
-        dprintk("%s: type=0%o\n", __FUNCTION__, nfs_type2fmt[*type].nfs2type);
+        dprintk("%s: type=0%o\n", __func__, nfs_type2fmt[*type].nfs2type);
         return 0;
 }
 
@@ -2327,7 +2327,7 @@ static int decode_attr_change(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t
                 READ64(*change);
                 bitmap[0] &= ~FATTR4_WORD0_CHANGE;
         }
-        dprintk("%s: change attribute=%Lu\n", __FUNCTION__,
+        dprintk("%s: change attribute=%Lu\n", __func__,
                         (unsigned long long)*change);
         return 0;
 }
@@ -2344,7 +2344,7 @@ static int decode_attr_size(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t *
                 READ64(*size);
                 bitmap[0] &= ~FATTR4_WORD0_SIZE;
         }
-        dprintk("%s: file size=%Lu\n", __FUNCTION__, (unsigned long long)*size);
+        dprintk("%s: file size=%Lu\n", __func__, (unsigned long long)*size);
         return 0;
 }
 
@@ -2360,7 +2360,7 @@ static int decode_attr_link_support(struct xdr_stream *xdr, uint32_t *bitmap, ui
                 READ32(*res);
                 bitmap[0] &= ~FATTR4_WORD0_LINK_SUPPORT;
         }
-        dprintk("%s: link support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true");
+        dprintk("%s: link support=%s\n", __func__, *res == 0 ? "false" : "true");
         return 0;
 }
 
@@ -2376,7 +2376,7 @@ static int decode_attr_symlink_support(struct xdr_stream *xdr, uint32_t *bitmap,
                 READ32(*res);
                 bitmap[0] &= ~FATTR4_WORD0_SYMLINK_SUPPORT;
         }
-        dprintk("%s: symlink support=%s\n", __FUNCTION__, *res == 0 ? "false" : "true");
+        dprintk("%s: symlink support=%s\n", __func__, *res == 0 ? "false" : "true");
         return 0;
 }
 
@@ -2394,7 +2394,7 @@ static int decode_attr_fsid(struct xdr_stream *xdr, uint32_t *bitmap, struct nfs
                 READ64(fsid->minor);
                 bitmap[0] &= ~FATTR4_WORD0_FSID;
         }
-        dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __FUNCTION__,
+        dprintk("%s: fsid=(0x%Lx/0x%Lx)\n", __func__,
                         (unsigned long long)fsid->major,
                         (unsigned long long)fsid->minor);
         return 0;
@@ -2412,7 +2412,7 @@ static int decode_attr_lease_time(struct xdr_stream *xdr, uint32_t *bitmap, uint
                 READ32(*res);
                 bitmap[0] &= ~FATTR4_WORD0_LEASE_TIME;
         }
-        dprintk("%s: file size=%u\n", __FUNCTION__, (unsigned int)*res);
+        dprintk("%s: file size=%u\n", __func__, (unsigned int)*res);
         return 0;
 }
 
@@ -2428,7 +2428,7 @@ static int decode_attr_aclsupport(struct xdr_stream *xdr, uint32_t *bitmap, uint
                 READ32(*res);
                 bitmap[0] &= ~FATTR4_WORD0_ACLSUPPORT;
         }
-        dprintk("%s: ACLs supported=%u\n", __FUNCTION__, (unsigned int)*res);
+        dprintk("%s: ACLs supported=%u\n", __func__, (unsigned int)*res);
         return 0;
 }
 
@@ -2444,7 +2444,7 @@ static int decode_attr_fileid(struct xdr_stream *xdr, uint32_t *bitmap, uint64_t
                 READ64(*fileid);
                 bitmap[0] &= ~FATTR4_WORD0_FILEID;
         }
-        dprintk("%s: fileid=%Lu\n", __FUNCTION__, (unsigned long long)*fileid);
+        dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
         return 0;
 }
 
@@ -2460,7 +2460,7 @@ static int decode_attr_mounted_on_fileid(struct xdr_stream *xdr, uint32_t *bitma
                 READ64(*fileid);
                 bitmap[1] &= ~FATTR4_WORD1_MOUNTED_ON_FILEID;
         }
-        dprintk("%s: fileid=%Lu\n", __FUNCTION__, (unsigned long long)*fileid);
+        dprintk("%s: fileid=%Lu\n", __func__, (unsigned long long)*fileid);
         return 0;
 }
 
@@ -2477,7 +2477,7 @@ static int decode_attr_files_avail(struct xdr_stream *xdr, uint32_t *bitmap, uin
                 READ64(*res);
                 bitmap[0] &= ~FATTR4_WORD0_FILES_AVAIL;
         }
-        dprintk("%s: files avail=%Lu\n", __FUNCTION__, (unsigned long long)*res);
+        dprintk("%s: files avail=%Lu\n", __func__, (unsigned long long)*res);
         return status;
 }
 
@@ -2494,7 +2494,7 @@ static int decode_attr_files_free(struct xdr_stream *xdr, uint32_t *bitmap, uint
                 READ64(*res);
                 bitmap[0] &= ~FATTR4_WORD0_FILES_FREE;
         }
-        dprintk("%s: files free=%Lu\n", __FUNCTION__, (unsigned long long)*res);
+        dprintk("%s: files free=%Lu\n", __func__, (unsigned long long)*res);
         return status;
 }
 
@@ -2511,7 +2511,7 @@ static int decode_attr_files_total(struct xdr_stream *xdr, uint32_t *bitmap, uin
                 READ64(*res);
                 bitmap[0] &= ~FATTR4_WORD0_FILES_TOTAL;
         }
-        dprintk("%s: files total=%Lu\n", __FUNCTION__, (unsigned long long)*res);
+        dprintk("%s: files total=%Lu\n", __func__, (unsigned long long)*res);
         return status;
 }
 
@@ -2569,7 +2569,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
         status = 0;
         if (unlikely(!(bitmap[0] & FATTR4_WORD0_FS_LOCATIONS)))
                 goto out;
-        dprintk("%s: fsroot ", __FUNCTION__);
+        dprintk("%s: fsroot ", __func__);
         status = decode_pathname(xdr, &res->fs_path);
         if (unlikely(status != 0))
                 goto out;
@@ -2586,7 +2586,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
                 READ32(m);
 
                 loc->nservers = 0;
-                dprintk("%s: servers ", __FUNCTION__);
+                dprintk("%s: servers ", __func__);
                 while (loc->nservers < m) {
                         struct nfs4_string *server = &loc->servers[loc->nservers];
                         status = decode_opaque_inline(xdr, &server->len, &server->data);
@@ -2599,7 +2599,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
                                 unsigned int i;
                                 dprintk("%s: using first %u of %u servers "
                                         "returned for location %u\n",
-                                                __FUNCTION__,
+                                                __func__,
                                                 NFS4_FS_LOCATION_MAXSERVERS,
                                                 m, res->nlocations);
                                 for (i = loc->nservers; i < m; i++) {
@@ -2618,7 +2618,7 @@ static int decode_attr_fs_locations(struct xdr_stream *xdr, uint32_t *bitmap, st
                         res->nlocations++;
         }
 out:
-        dprintk("%s: fs_locations done, error = %d\n", __FUNCTION__, status);
+        dprintk("%s: fs_locations done, error = %d\n", __func__, status);
         return status;
 out_eio:
         status = -EIO;
@@ -2638,7 +2638,7 @@ static int decode_attr_maxfilesize(struct xdr_stream *xdr, uint32_t *bitmap, uin
                 READ64(*res);
                 bitmap[0] &= ~FATTR4_WORD0_MAXFILESIZE;
         }
-        dprintk("%s: maxfilesize=%Lu\n", __FUNCTION__, (unsigned long long)*res);
+        dprintk("%s: maxfilesize=%Lu\n", __func__, (unsigned long long)*res);
         return status;
 }
 
@@ -2655,7 +2655,7 @@ static int decode_attr_maxlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_
                 READ32(*maxlink);
                 bitmap[0] &= ~FATTR4_WORD0_MAXLINK;
         }
-        dprintk("%s: maxlink=%u\n", __FUNCTION__, *maxlink);
+        dprintk("%s: maxlink=%u\n", __func__, *maxlink);
         return status;
 }
 
@@ -2672,7 +2672,7 @@ static int decode_attr_maxname(struct xdr_stream *xdr, uint32_t *bitmap, uint32_
                 READ32(*maxname);
                 bitmap[0] &= ~FATTR4_WORD0_MAXNAME;
         }
-        dprintk("%s: maxname=%u\n", __FUNCTION__, *maxname);
+        dprintk("%s: maxname=%u\n", __func__, *maxname);
         return status;
 }
 
@@ -2693,7 +2693,7 @@ static int decode_attr_maxread(struct xdr_stream *xdr, uint32_t *bitmap, uint32_
                 *res = (uint32_t)maxread;
                 bitmap[0] &= ~FATTR4_WORD0_MAXREAD;
         }
-        dprintk("%s: maxread=%lu\n", __FUNCTION__, (unsigned long)*res);
+        dprintk("%s: maxread=%lu\n", __func__, (unsigned long)*res);
         return status;
 }
 
@@ -2714,7 +2714,7 @@ static int decode_attr_maxwrite(struct xdr_stream *xdr, uint32_t *bitmap, uint32
                 *res = (uint32_t)maxwrite;
                 bitmap[0] &= ~FATTR4_WORD0_MAXWRITE;
         }
-        dprintk("%s: maxwrite=%lu\n", __FUNCTION__, (unsigned long)*res);
+        dprintk("%s: maxwrite=%lu\n", __func__, (unsigned long)*res);
         return status;
 }
 
@@ -2731,7 +2731,7 @@ static int decode_attr_mode(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t *
                 *mode &= ~S_IFMT;
                 bitmap[1] &= ~FATTR4_WORD1_MODE;
         }
-        dprintk("%s: file mode=0%o\n", __FUNCTION__, (unsigned int)*mode);
+        dprintk("%s: file mode=0%o\n", __func__, (unsigned int)*mode);
         return 0;
 }
 
@@ -2747,7 +2747,7 @@ static int decode_attr_nlink(struct xdr_stream *xdr, uint32_t *bitmap, uint32_t
                 READ32(*nlink);
                 bitmap[1] &= ~FATTR4_WORD1_NUMLINKS;
         }
-        dprintk("%s: nlink=%u\n", __FUNCTION__, (unsigned int)*nlink);
+        dprintk("%s: nlink=%u\n", __func__, (unsigned int)*nlink);
         return 0;
 }
 
@@ -2766,13 +2766,13 @@ static int decode_attr_owner(struct xdr_stream *xdr, uint32_t *bitmap, struct nf
                 if (len < XDR_MAX_NETOBJ) {
                         if (nfs_map_name_to_uid(clp, (char *)p, len, uid) != 0)
                                 dprintk("%s: nfs_map_name_to_uid failed!\n",
-                                                __FUNCTION__);
+                                                __func__);
                 } else
                         dprintk("%s: name too long (%u)!\n",
-                                        __FUNCTION__, len);
+                                        __func__, len);
                 bitmap[1] &= ~FATTR4_WORD1_OWNER;
         }
-        dprintk("%s: uid=%d\n", __FUNCTION__, (int)*uid);
+        dprintk("%s: uid=%d\n", __func__, (int)*uid);
         return 0;
 }
 
@@ -2791,13 +2791,13 @@ static int decode_attr_group(struct xdr_stream *xdr, uint32_t *bitmap, struct nf
                 if (len < XDR_MAX_NETOBJ) {
                         if (nfs_map_group_to_gid(clp, (char *)p, len, gid) != 0)
                                 dprintk("%s: nfs_map_group_to_gid failed!\n",
-                                                __FUNCTION__);
+                                                __func__);
                 } else
                         dprintk("%s: name too long (%u)!\n",
-                                        __FUNCTION__, len);
+                                        __func__, len);
                 bitmap[1] &= ~FATTR4_WORD1_OWNER_GROUP;
         }
-        dprintk("%s: gid=%d\n", __FUNCTION__, (int)*gid);
+        dprintk("%s: gid=%d\n", __func__, (int)*gid);
         return 0;
 }
 
@@ -2820,7 +2820,7 @@ static int decode_attr_rdev(struct xdr_stream *xdr, uint32_t *bitmap, dev_t *rde
                         *rdev = tmp;
                 bitmap[1] &= ~ FATTR4_WORD1_RAWDEV;
         }
-        dprintk("%s: rdev=(0x%x:0x%x)\n", __FUNCTION__, major, minor);
+        dprintk("%s: rdev=(0x%x:0x%x)\n", __func__, major, minor);
         return 0;
 }
 
@@ -2837,7 +2837,7 @@ static int decode_attr_space_avail(struct xdr_stream *xdr, uint32_t *bitmap, uin
                 READ64(*res);
                 bitmap[1] &= ~FATTR4_WORD1_SPACE_AVAIL;
         }
-        dprintk("%s: space avail=%Lu\n", __FUNCTION__, (unsigned long long)*res);
+        dprintk("%s: space avail=%Lu\n", __func__, (unsigned long long)*res);
         return status;
 }
 
@@ -2854,7 +2854,7 @@ static int decode_attr_space_free(struct xdr_stream *xdr, uint32_t *bitmap, uint
                 READ64(*res);
                 bitmap[1] &= ~FATTR4_WORD1_SPACE_FREE;
         }
-        dprintk("%s: space free=%Lu\n", __FUNCTION__, (unsigned long long)*res);
+        dprintk("%s: space free=%Lu\n", __func__, (unsigned long long)*res);
         return status;
 }
 
@@ -2871,7 +2871,7 @@ static int decode_attr_space_total(struct xdr_stream *xdr, uint32_t *bitmap, uin
                 READ64(*res);
                 bitmap[1] &= ~FATTR4_WORD1_SPACE_TOTAL;
         }
-        dprintk("%s: space total=%Lu\n", __FUNCTION__, (unsigned long long)*res);
+        dprintk("%s: space total=%Lu\n", __func__, (unsigned long long)*res);
         return status;
 }
 
@@ -2887,7 +2887,7 @@ static int decode_attr_space_used(struct xdr_stream *xdr, uint32_t *bitmap, uint
                 READ64(*used);
                 bitmap[1] &= ~FATTR4_WORD1_SPACE_USED;
         }
-        dprintk("%s: space used=%Lu\n", __FUNCTION__,
+        dprintk("%s: space used=%Lu\n", __func__,
                         (unsigned long long)*used);
         return 0;
 }
@@ -2918,7 +2918,7 @@ static int decode_attr_time_access(struct xdr_stream *xdr, uint32_t *bitmap, str
                 status = decode_attr_time(xdr, time);
                 bitmap[1] &= ~FATTR4_WORD1_TIME_ACCESS;
         }
-        dprintk("%s: atime=%ld\n", __FUNCTION__, (long)time->tv_sec);
+        dprintk("%s: atime=%ld\n", __func__, (long)time->tv_sec);
         return status;
 }
 
@@ -2934,7 +2934,7 @@ static int decode_attr_time_metadata(struct xdr_stream *xdr, uint32_t *bitmap, s
                 status = decode_attr_time(xdr, time);
                 bitmap[1] &= ~FATTR4_WORD1_TIME_METADATA;
         }
-        dprintk("%s: ctime=%ld\n", __FUNCTION__, (long)time->tv_sec);
+        dprintk("%s: ctime=%ld\n", __func__, (long)time->tv_sec);
         return status;
 }
 
@@ -2950,7 +2950,7 @@ static int decode_attr_time_modify(struct xdr_stream *xdr, uint32_t *bitmap, str
                 status = decode_attr_time(xdr, time);
                 bitmap[1] &= ~FATTR4_WORD1_TIME_MODIFY;
         }
-        dprintk("%s: mtime=%ld\n", __FUNCTION__, (long)time->tv_sec);
+        dprintk("%s: mtime=%ld\n", __func__, (long)time->tv_sec);
         return status;
 }
 
@@ -2962,7 +2962,7 @@ static int verify_attr_len(struct xdr_stream *xdr, __be32 *savep, uint32_t attrl
         if (unlikely(attrwords != nwords)) {
                 dprintk("%s: server returned incorrect attribute length: "
                         "%u %c %u\n",
-                                __FUNCTION__,
+                                __func__,
                                 attrwords << 2,
                                 (attrwords < nwords) ? '<' : '>',
                                 nwords << 2);
@@ -3067,7 +3067,7 @@ static int decode_server_caps(struct xdr_stream *xdr, struct nfs4_server_caps_re
                 goto xdr_error;
         status = verify_attr_len(xdr, savep, attrlen);
 xdr_error:
-        dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status);
+        dprintk("%s: xdr returned %d!\n", __func__, -status);
         return status;
 }
         
@@ -3100,7 +3100,7 @@ static int decode_statfs(struct xdr_stream *xdr, struct nfs_fsstat *fsstat)
 
         status = verify_attr_len(xdr, savep, attrlen);
 xdr_error:
-        dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status);
+        dprintk("%s: xdr returned %d!\n", __func__, -status);
         return status;
 }
 
@@ -3125,7 +3125,7 @@ static int decode_pathconf(struct xdr_stream *xdr, struct nfs_pathconf *pathconf
 
         status = verify_attr_len(xdr, savep, attrlen);
 xdr_error:
-        dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status);
+        dprintk("%s: xdr returned %d!\n", __func__, -status);
         return status;
 }
 
@@ -3193,7 +3193,7 @@ static int decode_getfattr(struct xdr_stream *xdr, struct nfs_fattr *fattr, cons
         if ((status = verify_attr_len(xdr, savep, attrlen)) == 0)
                 fattr->valid = NFS_ATTR_FATTR | NFS_ATTR_FATTR_V3 | NFS_ATTR_FATTR_V4;
 xdr_error:
-        dprintk("%s: xdr returned %d\n", __FUNCTION__, -status);
+        dprintk("%s: xdr returned %d\n", __func__, -status);
         return status;
 }
 
@@ -3226,7 +3226,7 @@ static int decode_fsinfo(struct xdr_stream *xdr, struct nfs_fsinfo *fsinfo)
 
         status = verify_attr_len(xdr, savep, attrlen);
 xdr_error:
-        dprintk("%s: xdr returned %d!\n", __FUNCTION__, -status);
+        dprintk("%s: xdr returned %d!\n", __func__, -status);
         return status;
 }
 
@@ -3418,7 +3418,7 @@ static int decode_open(struct xdr_stream *xdr, struct nfs_openres *res)
 
         return decode_delegation(xdr, res);
 xdr_error:
-        dprintk("%s: Bitmap too large! Length = %u\n", __FUNCTION__, bmlen);
+        dprintk("%s: Bitmap too large! Length = %u\n", __func__, bmlen);
         return -EIO;
 }
 
@@ -3575,7 +3575,7 @@ short_pkt:
          * the call was successful, but incomplete. The caller can retry the
          * readdir starting at the last cookie.
          */
-        dprintk("%s: short packet at entry %d\n", __FUNCTION__, nr);
+        dprintk("%s: short packet at entry %d\n", __func__, nr);
         entry[0] = entry[1] = 0;
         if (nr)
                 goto out;
diff --git a/fs/nfs/proc.c b/fs/nfs/proc.c
index 5ccf7faee19c..03599bfe81cf 100644
--- a/fs/nfs/proc.c
+++ b/fs/nfs/proc.c
@@ -63,17 +63,17 @@ nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
         };
         int status;
 
-        dprintk("%s: call getattr\n", __FUNCTION__);
+        dprintk("%s: call getattr\n", __func__);
         nfs_fattr_init(fattr);
         status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
-        dprintk("%s: reply getattr: %d\n", __FUNCTION__, status);
+        dprintk("%s: reply getattr: %d\n", __func__, status);
         if (status)
                 return status;
-        dprintk("%s: call statfs\n", __FUNCTION__);
+        dprintk("%s: call statfs\n", __func__);
         msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
         msg.rpc_resp = &fsinfo;
         status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
-        dprintk("%s: reply statfs: %d\n", __FUNCTION__, status);
+        dprintk("%s: reply statfs: %d\n", __func__, status);
         if (status)
                 return status;
         info->rtmax  = NFS_MAXDATA;
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 16f57e0af999..40d17987d0e8 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -329,7 +329,7 @@ int nfs_readpage_result(struct rpc_task *task, struct nfs_read_data *data)
 {
         int status;
 
-        dprintk("NFS: %s: %5u, (status %d)\n", __FUNCTION__, task->tk_pid,
+        dprintk("NFS: %s: %5u, (status %d)\n", __func__, task->tk_pid,
                         task->tk_status);
 
         status = NFS_PROTO(data->inode)->read_done(task, data);
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 7226a506f3ca..614efeed5437 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -405,7 +405,7 @@ static int nfs_statfs(struct dentry *dentry, struct kstatfs *buf)
         return 0;
 
  out_err:
-        dprintk("%s: statfs error = %d\n", __FUNCTION__, -error);
+        dprintk("%s: statfs error = %d\n", __func__, -error);
         unlock_kernel();
         return error;
 }
@@ -1216,8 +1216,6 @@ static int nfs_validate_mount_data(void *options,
 {
         struct nfs_mount_data *data = (struct nfs_mount_data *)options;
 
-        memset(args, 0, sizeof(*args));
-
         if (data == NULL)
                 goto out_no_data;
 
@@ -1251,13 +1249,13 @@ static int nfs_validate_mount_data(void *options,
         case 5:
                 memset(data->context, 0, sizeof(data->context));
         case 6:
-                if (data->flags & NFS_MOUNT_VER3)
+                if (data->flags & NFS_MOUNT_VER3) {
+                        if (data->root.size > NFS3_FHSIZE || data->root.size == 0)
+                                goto out_invalid_fh;
                         mntfh->size = data->root.size;
-                else
+                } else
                         mntfh->size = NFS2_FHSIZE;
 
-                if (mntfh->size > sizeof(mntfh->data))
-                        goto out_invalid_fh;
 
                 memcpy(mntfh->data, data->root.data, mntfh->size);
                 if (mntfh->size < sizeof(mntfh->data))
@@ -1585,24 +1583,29 @@ static int nfs_get_sb(struct file_system_type *fs_type,
 {
         struct nfs_server *server = NULL;
         struct super_block *s;
-        struct nfs_fh mntfh;
-        struct nfs_parsed_mount_data data;
+        struct nfs_parsed_mount_data *data;
+        struct nfs_fh *mntfh;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
         struct nfs_sb_mountdata sb_mntdata = {
                 .mntflags = flags,
         };
-        int error;
+        int error = -ENOMEM;
 
-        security_init_mnt_opts(&data.lsm_opts);
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        mntfh = kzalloc(sizeof(*mntfh), GFP_KERNEL);
+        if (data == NULL || mntfh == NULL)
+                goto out_free_fh;
+
+        security_init_mnt_opts(&data->lsm_opts);
 
         /* Validate the mount data */
-        error = nfs_validate_mount_data(raw_data, &data, &mntfh, dev_name);
+        error = nfs_validate_mount_data(raw_data, data, mntfh, dev_name);
         if (error < 0)
                 goto out;
 
         /* Get a volume representation */
-        server = nfs_create_server(&data, &mntfh);
+        server = nfs_create_server(data, mntfh);
         if (IS_ERR(server)) {
                 error = PTR_ERR(server);
                 goto out;
@@ -1630,16 +1633,16 @@ static int nfs_get_sb(struct file_system_type *fs_type,
 
         if (!s->s_root) {
                 /* initial superblock/root creation */
-                nfs_fill_super(s, &data);
+                nfs_fill_super(s, data);
         }
 
-        mntroot = nfs_get_root(s, &mntfh);
+        mntroot = nfs_get_root(s, mntfh);
         if (IS_ERR(mntroot)) {
                 error = PTR_ERR(mntroot);
                 goto error_splat_super;
         }
 
-        error = security_sb_set_mnt_opts(s, &data.lsm_opts);
+        error = security_sb_set_mnt_opts(s, &data->lsm_opts);
         if (error)
                 goto error_splat_root;
 
@@ -1649,9 +1652,12 @@ static int nfs_get_sb(struct file_system_type *fs_type,
         error = 0;
 
 out:
-        kfree(data.nfs_server.hostname);
-        kfree(data.mount_server.hostname);
-        security_free_mnt_opts(&data.lsm_opts);
+        kfree(data->nfs_server.hostname);
+        kfree(data->mount_server.hostname);
+        security_free_mnt_opts(&data->lsm_opts);
+out_free_fh:
+        kfree(mntfh);
+        kfree(data);
         return error;
 
 out_err_nosb:
@@ -1800,8 +1806,6 @@ static int nfs4_validate_mount_data(void *options,
         struct nfs4_mount_data *data = (struct nfs4_mount_data *)options;
         char *c;
 
-        memset(args, 0, sizeof(*args));
-
         if (data == NULL)
                 goto out_no_data;
 
@@ -1959,26 +1963,31 @@ out_no_client_address:
 static int nfs4_get_sb(struct file_system_type *fs_type,
         int flags, const char *dev_name, void *raw_data, struct vfsmount *mnt)
 {
-        struct nfs_parsed_mount_data data;
+        struct nfs_parsed_mount_data *data;
         struct super_block *s;
         struct nfs_server *server;
-        struct nfs_fh mntfh;
+        struct nfs_fh *mntfh;
         struct dentry *mntroot;
         int (*compare_super)(struct super_block *, void *) = nfs_compare_super;
         struct nfs_sb_mountdata sb_mntdata = {
                 .mntflags = flags,
         };
-        int error;
+        int error = -ENOMEM;
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        mntfh = kzalloc(sizeof(*mntfh), GFP_KERNEL);
+        if (data == NULL || mntfh == NULL)
+                goto out_free_fh;
 
-        security_init_mnt_opts(&data.lsm_opts);
+        security_init_mnt_opts(&data->lsm_opts);
 
         /* Validate the mount data */
-        error = nfs4_validate_mount_data(raw_data, &data, dev_name);
+        error = nfs4_validate_mount_data(raw_data, data, dev_name);
         if (error < 0)
                 goto out;
 
         /* Get a volume representation */
-        server = nfs4_create_server(&data, &mntfh);
+        server = nfs4_create_server(data, mntfh);
         if (IS_ERR(server)) {
                 error = PTR_ERR(server);
                 goto out;
@@ -2009,28 +2018,37 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
                 nfs4_fill_super(s);
         }
 
-        mntroot = nfs4_get_root(s, &mntfh);
+        mntroot = nfs4_get_root(s, mntfh);
         if (IS_ERR(mntroot)) {
                 error = PTR_ERR(mntroot);
                 goto error_splat_super;
         }
 
+        error = security_sb_set_mnt_opts(s, &data->lsm_opts);
+        if (error)
+                goto error_splat_root;
+
         s->s_flags |= MS_ACTIVE;
         mnt->mnt_sb = s;
         mnt->mnt_root = mntroot;
         error = 0;
 
 out:
-        kfree(data.client_address);
-        kfree(data.nfs_server.export_path);
-        kfree(data.nfs_server.hostname);
-        security_free_mnt_opts(&data.lsm_opts);
+        kfree(data->client_address);
+        kfree(data->nfs_server.export_path);
+        kfree(data->nfs_server.hostname);
+        security_free_mnt_opts(&data->lsm_opts);
+out_free_fh:
+        kfree(mntfh);
+        kfree(data);
         return error;
 
 out_free:
         nfs_free_server(server);
         goto out;
 
+error_splat_root:
+        dput(mntroot);
 error_splat_super:
         up_write(&s->s_umount);
         deactivate_super(s);
@@ -2114,6 +2132,8 @@ static int nfs4_xdev_get_sb(struct file_system_type *fs_type, int flags,
         mnt->mnt_sb = s;
         mnt->mnt_root = mntroot;
 
+        security_sb_clone_mnt_opts(data->sb, s);
+
         dprintk("<-- nfs4_xdev_get_sb() = 0\n");
         return 0;
 
@@ -2197,6 +2217,8 @@ static int nfs4_referral_get_sb(struct file_system_type *fs_type, int flags,
         mnt->mnt_sb = s;
         mnt->mnt_root = mntroot;
 
+        security_sb_clone_mnt_opts(data->sb, s);
+
         dprintk("<-- nfs4_referral_get_sb() = 0\n");
         return 0;
 
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index 1ade11d1ba07..f333848fd3be 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -415,7 +415,7 @@ nfs_dirty_request(struct nfs_page *req)
 
         if (page == NULL || test_bit(PG_NEED_COMMIT, &req->wb_flags))
                 return 0;
-        return !PageWriteback(req->wb_page);
+        return !PageWriteback(page);
 }
 
 #if defined(CONFIG_NFS_V3) || defined(CONFIG_NFS_V4)
@@ -739,12 +739,13 @@ int nfs_updatepage(struct file *file, struct page *page,
         }
 
         status = nfs_writepage_setup(ctx, page, offset, count);
-        __set_page_dirty_nobuffers(page);
+        if (status < 0)
+                nfs_set_pageerror(page);
+        else
+                __set_page_dirty_nobuffers(page);
 
         dprintk("NFS:      nfs_updatepage returns %d (isize %Ld)\n",
                         status, (long long)i_size_read(inode));
-        if (status < 0)
-                nfs_set_pageerror(page);
         return status;
 }
 
diff --git a/fs/nfsd/nfs4callback.c b/fs/nfsd/nfs4callback.c
index 0b3ffa9840c2..4d4760e687c3 100644
--- a/fs/nfsd/nfs4callback.c
+++ b/fs/nfsd/nfs4callback.c
@@ -419,9 +419,9 @@ static int do_probe_callback(void *data)
 out_release_client:
         rpc_shutdown_client(client);
 out_err:
-        put_nfs4_client(clp);
         dprintk("NFSD: warning: no callback path to client %.*s\n",
                 (int)clp->cl_name.len, clp->cl_name.data);
+        put_nfs4_client(clp);
         return status;
 }
 
diff --git a/fs/ntfs/upcase.c b/fs/ntfs/upcase.c
index 9101807dc81a..e2f72ca98037 100644
--- a/fs/ntfs/upcase.c
+++ b/fs/ntfs/upcase.c
@@ -77,11 +77,10 @@ ntfschar *generate_default_upcase(void)
                 uc[i] = cpu_to_le16(i);
         for (r = 0; uc_run_table[r][0]; r++)
                 for (i = uc_run_table[r][0]; i < uc_run_table[r][1]; i++)
-                        uc[i] = cpu_to_le16(le16_to_cpu(uc[i]) +
-                                        uc_run_table[r][2]);
+                        le16_add_cpu(&uc[i], uc_run_table[r][2]);
         for (r = 0; uc_dup_table[r][0]; r++)
                 for (i = uc_dup_table[r][0]; i < uc_dup_table[r][1]; i += 2)
-                        uc[i + 1] = cpu_to_le16(le16_to_cpu(uc[i + 1]) - 1);
+                        le16_add_cpu(&uc[i + 1], -1);
         for (r = 0; uc_word_table[r][0]; r++)
                 uc[uc_word_table[r][0]] = cpu_to_le16(uc_word_table[r][1]);
         return uc;
diff --git a/fs/ocfs2/alloc.c b/fs/ocfs2/alloc.c
index 41f84c92094f..10bfb466e068 100644
--- a/fs/ocfs2/alloc.c
+++ b/fs/ocfs2/alloc.c
@@ -2788,7 +2788,7 @@ static int ocfs2_merge_rec_right(struct inode *inode,
         BUG_ON(index >= le16_to_cpu(el->l_next_free_rec));
         left_rec = &el->l_recs[index];
 
-        if (index == le16_to_cpu(el->l_next_free_rec - 1) &&
+        if (index == le16_to_cpu(el->l_next_free_rec) - 1 &&
             le16_to_cpu(el->l_next_free_rec) == le16_to_cpu(el->l_count)) {
                 /* we meet with a cross extent block merge. */
                 ret = ocfs2_get_right_path(inode, left_path, &right_path);
@@ -2802,7 +2802,7 @@ static int ocfs2_merge_rec_right(struct inode *inode,
                 BUG_ON(next_free <= 0);
                 right_rec = &right_el->l_recs[0];
                 if (ocfs2_is_empty_extent(right_rec)) {
-                        BUG_ON(le16_to_cpu(next_free) <= 1);
+                        BUG_ON(next_free <= 1);
                         right_rec = &right_el->l_recs[1];
                 }
 
diff --git a/fs/ocfs2/cluster/nodemanager.c b/fs/ocfs2/cluster/nodemanager.c
index cf9401e8cd0b..cfdb08b484ed 100644
--- a/fs/ocfs2/cluster/nodemanager.c
+++ b/fs/ocfs2/cluster/nodemanager.c
@@ -21,7 +21,6 @@
 
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/sysctl.h>
 #include <linux/configfs.h>
 
 #include "tcp.h"
@@ -36,65 +35,6 @@
  * cluster references throughout where nodes are looked up */
 struct o2nm_cluster *o2nm_single_cluster = NULL;
 
-#define OCFS2_MAX_HB_CTL_PATH 256
-static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
-
-static ctl_table ocfs2_nm_table[] = {
-        {
-                .ctl_name       = 1,
-                .procname       = "hb_ctl_path",
-                .data           = ocfs2_hb_ctl_path,
-                .maxlen         = OCFS2_MAX_HB_CTL_PATH,
-                .mode           = 0644,
-                .proc_handler   = &proc_dostring,
-                .strategy       = &sysctl_string,
-        },
-        { .ctl_name = 0 }
-};
-
-static ctl_table ocfs2_mod_table[] = {
-        {
-                .ctl_name       = FS_OCFS2_NM,
-                .procname       = "nm",
-                .data           = NULL,
-                .maxlen         = 0,
-                .mode           = 0555,
-                .child          = ocfs2_nm_table
-        },
-        { .ctl_name = 0}
-};
-
-static ctl_table ocfs2_kern_table[] = {
-        {
-                .ctl_name       = FS_OCFS2,
-                .procname       = "ocfs2",
-                .data           = NULL,
-                .maxlen         = 0,
-                .mode           = 0555,
-                .child          = ocfs2_mod_table
-        },
-        { .ctl_name = 0}
-};
-
-static ctl_table ocfs2_root_table[] = {
-        {
-                .ctl_name       = CTL_FS,
-                .procname       = "fs",
-                .data           = NULL,
-                .maxlen         = 0,
-                .mode           = 0555,
-                .child          = ocfs2_kern_table
-        },
-        { .ctl_name = 0 }
-};
-
-static struct ctl_table_header *ocfs2_table_header = NULL;
-
-const char *o2nm_get_hb_ctl_path(void)
-{
-        return ocfs2_hb_ctl_path;
-}
-EXPORT_SYMBOL_GPL(o2nm_get_hb_ctl_path);
 
 struct o2nm_node *o2nm_get_node_by_num(u8 node_num)
 {
@@ -941,9 +881,6 @@ void o2nm_undepend_this_node(void)
 
 static void __exit exit_o2nm(void)
 {
-        if (ocfs2_table_header)
-                unregister_sysctl_table(ocfs2_table_header);
-
         /* XXX sync with hb callbacks and shut down hb? */
         o2net_unregister_hb_callbacks();
         configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
@@ -964,16 +901,9 @@ static int __init init_o2nm(void)
         if (ret)
                 goto out;
 
-        ocfs2_table_header = register_sysctl_table(ocfs2_root_table);
-        if (!ocfs2_table_header) {
-                printk(KERN_ERR "nodemanager: unable to register sysctl\n");
-                ret = -ENOMEM; /* or something. */
-                goto out_o2net;
-        }
-
         ret = o2net_register_hb_callbacks();
         if (ret)
-                goto out_sysctl;
+                goto out_o2net;
 
         config_group_init(&o2nm_cluster_group.cs_subsys.su_group);
         mutex_init(&o2nm_cluster_group.cs_subsys.su_mutex);
@@ -990,8 +920,6 @@ static int __init init_o2nm(void)
         configfs_unregister_subsystem(&o2nm_cluster_group.cs_subsys);
 out_callbacks:
         o2net_unregister_hb_callbacks();
-out_sysctl:
-        unregister_sysctl_table(ocfs2_table_header);
 out_o2net:
         o2net_exit();
 out:
diff --git a/fs/ocfs2/cluster/nodemanager.h b/fs/ocfs2/cluster/nodemanager.h
index 7c860361b8dd..c992ea0da4ad 100644
--- a/fs/ocfs2/cluster/nodemanager.h
+++ b/fs/ocfs2/cluster/nodemanager.h
@@ -33,10 +33,6 @@
 #include <linux/configfs.h>
 #include <linux/rbtree.h>
 
-#define FS_OCFS2_NM             1
-
-const char *o2nm_get_hb_ctl_path(void);
-
 struct o2nm_node {
         spinlock_t              nd_lock;
         struct config_item      nd_item;
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index 1e44ad14881a..a27d61581bd6 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -142,53 +142,43 @@ static void o2net_idle_timer(unsigned long data);
 static void o2net_sc_postpone_idle(struct o2net_sock_container *sc);
 static void o2net_sc_reset_idle_timer(struct o2net_sock_container *sc);
 
-static void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
-                           u32 msgkey, struct task_struct *task, u8 node)
-{
 #ifdef CONFIG_DEBUG_FS
+void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
+                    u32 msgkey, struct task_struct *task, u8 node)
+{
         INIT_LIST_HEAD(&nst->st_net_debug_item);
         nst->st_task = task;
         nst->st_msg_type = msgtype;
         nst->st_msg_key = msgkey;
         nst->st_node = node;
-#endif
 }
 
-static void o2net_set_nst_sock_time(struct o2net_send_tracking *nst)
+void o2net_set_nst_sock_time(struct o2net_send_tracking *nst)
 {
-#ifdef CONFIG_DEBUG_FS
         do_gettimeofday(&nst->st_sock_time);
-#endif
 }
 
-static void o2net_set_nst_send_time(struct o2net_send_tracking *nst)
+void o2net_set_nst_send_time(struct o2net_send_tracking *nst)
 {
-#ifdef CONFIG_DEBUG_FS
         do_gettimeofday(&nst->st_send_time);
-#endif
 }
 
-static void o2net_set_nst_status_time(struct o2net_send_tracking *nst)
+void o2net_set_nst_status_time(struct o2net_send_tracking *nst)
 {
-#ifdef CONFIG_DEBUG_FS
         do_gettimeofday(&nst->st_status_time);
-#endif
 }
 
-static void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
+void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
                                          struct o2net_sock_container *sc)
 {
-#ifdef CONFIG_DEBUG_FS
         nst->st_sc = sc;
-#endif
 }
 
-static void o2net_set_nst_msg_id(struct o2net_send_tracking *nst, u32 msg_id)
+void o2net_set_nst_msg_id(struct o2net_send_tracking *nst, u32 msg_id)
 {
-#ifdef CONFIG_DEBUG_FS
         nst->st_id = msg_id;
-#endif
 }
+#endif /* CONFIG_DEBUG_FS */
 
 static inline int o2net_reconnect_delay(void)
 {
diff --git a/fs/ocfs2/cluster/tcp.h b/fs/ocfs2/cluster/tcp.h
index a705d5d19036..fd6179eb26d4 100644
--- a/fs/ocfs2/cluster/tcp.h
+++ b/fs/ocfs2/cluster/tcp.h
@@ -128,23 +128,23 @@ void o2net_debug_del_nst(struct o2net_send_tracking *nst);
 void o2net_debug_add_sc(struct o2net_sock_container *sc);
 void o2net_debug_del_sc(struct o2net_sock_container *sc);
 #else
-static int o2net_debugfs_init(void)
+static inline int o2net_debugfs_init(void)
 {
         return 0;
 }
-static void o2net_debugfs_exit(void)
+static inline void o2net_debugfs_exit(void)
 {
 }
-static void o2net_debug_add_nst(struct o2net_send_tracking *nst)
+static inline void o2net_debug_add_nst(struct o2net_send_tracking *nst)
 {
 }
-static void o2net_debug_del_nst(struct o2net_send_tracking *nst)
+static inline void o2net_debug_del_nst(struct o2net_send_tracking *nst)
 {
 }
-static void o2net_debug_add_sc(struct o2net_sock_container *sc)
+static inline void o2net_debug_add_sc(struct o2net_sock_container *sc)
 {
 }
-static void o2net_debug_del_sc(struct o2net_sock_container *sc)
+static inline void o2net_debug_del_sc(struct o2net_sock_container *sc)
 {
 }
 #endif  /* CONFIG_DEBUG_FS */
diff --git a/fs/ocfs2/cluster/tcp_internal.h b/fs/ocfs2/cluster/tcp_internal.h
index 8d58cfe410b1..18307ff81b77 100644
--- a/fs/ocfs2/cluster/tcp_internal.h
+++ b/fs/ocfs2/cluster/tcp_internal.h
@@ -224,10 +224,42 @@ struct o2net_send_tracking {
         struct timeval                  st_send_time;
         struct timeval                  st_status_time;
 };
+
+void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
+                    u32 msgkey, struct task_struct *task, u8 node);
+void o2net_set_nst_sock_time(struct o2net_send_tracking *nst);
+void o2net_set_nst_send_time(struct o2net_send_tracking *nst);
+void o2net_set_nst_status_time(struct o2net_send_tracking *nst);
+void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
+                                  struct o2net_sock_container *sc);
+void o2net_set_nst_msg_id(struct o2net_send_tracking *nst, u32 msg_id);
+
 #else
 struct o2net_send_tracking {
         u32     dummy;
 };
+
+static inline void o2net_init_nst(struct o2net_send_tracking *nst, u32 msgtype,
+                                  u32 msgkey, struct task_struct *task, u8 node)
+{
+}
+static inline void o2net_set_nst_sock_time(struct o2net_send_tracking *nst)
+{
+}
+static inline void o2net_set_nst_send_time(struct o2net_send_tracking *nst)
+{
+}
+static inline void o2net_set_nst_status_time(struct o2net_send_tracking *nst)
+{
+}
+static inline void o2net_set_nst_sock_container(struct o2net_send_tracking *nst,
+                                                struct o2net_sock_container *sc)
+{
+}
+static inline void o2net_set_nst_msg_id(struct o2net_send_tracking *nst,
+                                        u32 msg_id)
+{
+}
 #endif  /* CONFIG_DEBUG_FS */
 
 #endif /* O2CLUSTER_TCP_INTERNAL_H */
diff --git a/fs/ocfs2/dlm/dlmdebug.h b/fs/ocfs2/dlm/dlmdebug.h
index d34a62a3a625..8c686d22f9c7 100644
--- a/fs/ocfs2/dlm/dlmdebug.h
+++ b/fs/ocfs2/dlm/dlmdebug.h
@@ -60,25 +60,25 @@ void dlm_destroy_debugfs_root(void);
 
 #else
 
-static int dlm_debug_init(struct dlm_ctxt *dlm)
+static inline int dlm_debug_init(struct dlm_ctxt *dlm)
 {
         return 0;
 }
-static void dlm_debug_shutdown(struct dlm_ctxt *dlm)
+static inline void dlm_debug_shutdown(struct dlm_ctxt *dlm)
 {
 }
-static int dlm_create_debugfs_subroot(struct dlm_ctxt *dlm)
+static inline int dlm_create_debugfs_subroot(struct dlm_ctxt *dlm)
 {
         return 0;
 }
-static void dlm_destroy_debugfs_subroot(struct dlm_ctxt *dlm)
+static inline void dlm_destroy_debugfs_subroot(struct dlm_ctxt *dlm)
 {
 }
-static int dlm_create_debugfs_root(void)
+static inline int dlm_create_debugfs_root(void)
 {
         return 0;
 }
-static void dlm_destroy_debugfs_root(void)
+static inline void dlm_destroy_debugfs_root(void)
 {
 }
 
diff --git a/fs/ocfs2/stack_o2cb.c b/fs/ocfs2/stack_o2cb.c
index bbd1667aa7d3..fcd120f1493a 100644
--- a/fs/ocfs2/stack_o2cb.c
+++ b/fs/ocfs2/stack_o2cb.c
@@ -317,8 +317,7 @@ out:
         return rc;
 }
 
-static int o2cb_cluster_disconnect(struct ocfs2_cluster_connection *conn,
-                                   int hangup_pending)
+static int o2cb_cluster_disconnect(struct ocfs2_cluster_connection *conn)
 {
         struct dlm_ctxt *dlm = conn->cc_lockspace;
         struct o2dlm_private *priv = conn->cc_private;
@@ -333,43 +332,6 @@ static int o2cb_cluster_disconnect(struct ocfs2_cluster_connection *conn,
         return 0;
 }
 
-static void o2hb_stop(const char *group)
-{
-        int ret;
-        char *argv[5], *envp[3];
-
-        argv[0] = (char *)o2nm_get_hb_ctl_path();
-        argv[1] = "-K";
-        argv[2] = "-u";
-        argv[3] = (char *)group;
-        argv[4] = NULL;
-
-        mlog(0, "Run: %s %s %s %s\n", argv[0], argv[1], argv[2], argv[3]);
-
-        /* minimal command environment taken from cpu_run_sbin_hotplug */
-        envp[0] = "HOME=/";
-        envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
-        envp[2] = NULL;
-
-        ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
-        if (ret < 0)
-                mlog_errno(ret);
-}
-
-/*
- * Hangup is a hack for tools compatibility.  Older ocfs2-tools software
- * expects the filesystem to call "ocfs2_hb_ctl" during unmount.  This
- * happens regardless of whether the DLM got started, so we can't do it
- * in ocfs2_cluster_disconnect().  We bring the o2hb_stop() function into
- * the glue and provide a "hangup" API for super.c to call.
- *
- * Other stacks will eventually provide a NULL ->hangup() pointer.
- */
-static void o2cb_cluster_hangup(const char *group, int grouplen)
-{
-        o2hb_stop(group);
-}
-
 static int o2cb_cluster_this_node(unsigned int *node)
 {
         int node_num;
@@ -388,7 +350,6 @@ static int o2cb_cluster_this_node(unsigned int *node)
 static struct ocfs2_stack_operations o2cb_stack_ops = {
         .connect        = o2cb_cluster_connect,
         .disconnect     = o2cb_cluster_disconnect,
-        .hangup         = o2cb_cluster_hangup,
         .this_node      = o2cb_cluster_this_node,
         .dlm_lock       = o2cb_dlm_lock,
         .dlm_unlock     = o2cb_dlm_unlock,
diff --git a/fs/ocfs2/stack_user.c b/fs/ocfs2/stack_user.c
index b503772cd0ec..c021280dd462 100644
--- a/fs/ocfs2/stack_user.c
+++ b/fs/ocfs2/stack_user.c
@@ -61,7 +61,7 @@
  * negotiated by the client.  The client negotiates based on the maximum
  * version advertised in /sys/fs/ocfs2/max_locking_protocol.  The major
  * number from the "SETV" message must match
- * user_stack.sp_proto->lp_max_version.pv_major, and the minor number
+ * ocfs2_user_plugin.sp_proto->lp_max_version.pv_major, and the minor number
  * must be less than or equal to ...->lp_max_version.pv_minor.
  *
  * Once this information has been set, mounts will be allowed.  From this
@@ -153,7 +153,7 @@ union ocfs2_control_message {
         struct ocfs2_control_message_down       u_down;
 };
 
-static struct ocfs2_stack_plugin user_stack;
+static struct ocfs2_stack_plugin ocfs2_user_plugin;
 
 static atomic_t ocfs2_control_opened;
 static int ocfs2_control_this_node = -1;
@@ -399,7 +399,7 @@ static int ocfs2_control_do_setversion_msg(struct file *file,
         char *ptr = NULL;
         struct ocfs2_control_private *p = file->private_data;
         struct ocfs2_protocol_version *max =
-                &user_stack.sp_proto->lp_max_version;
+                &ocfs2_user_plugin.sp_proto->lp_max_version;
 
         if (ocfs2_control_get_handshake_state(file) !=
             OCFS2_CONTROL_HANDSHAKE_PROTOCOL)
@@ -680,7 +680,7 @@ static void fsdlm_lock_ast_wrapper(void *astarg)
         struct dlm_lksb *lksb = fsdlm_astarg_to_lksb(astarg);
         int status = lksb->sb_status;
 
-        BUG_ON(user_stack.sp_proto == NULL);
+        BUG_ON(ocfs2_user_plugin.sp_proto == NULL);
 
         /*
          * For now we're punting on the issue of other non-standard errors
@@ -693,16 +693,16 @@ static void fsdlm_lock_ast_wrapper(void *astarg)
          */
 
         if (status == -DLM_EUNLOCK || status == -DLM_ECANCEL)
-                user_stack.sp_proto->lp_unlock_ast(astarg, 0);
+                ocfs2_user_plugin.sp_proto->lp_unlock_ast(astarg, 0);
         else
-                user_stack.sp_proto->lp_lock_ast(astarg);
+                ocfs2_user_plugin.sp_proto->lp_lock_ast(astarg);
 }
 
 static void fsdlm_blocking_ast_wrapper(void *astarg, int level)
 {
-        BUG_ON(user_stack.sp_proto == NULL);
+        BUG_ON(ocfs2_user_plugin.sp_proto == NULL);
 
-        user_stack.sp_proto->lp_blocking_ast(astarg, level);
+        ocfs2_user_plugin.sp_proto->lp_blocking_ast(astarg, level);
 }
 
 static int user_dlm_lock(struct ocfs2_cluster_connection *conn,
@@ -816,8 +816,7 @@ out:
         return rc;
 }
 
-static int user_cluster_disconnect(struct ocfs2_cluster_connection *conn,
-                                   int hangup_pending)
+static int user_cluster_disconnect(struct ocfs2_cluster_connection *conn)
 {
         dlm_release_lockspace(conn->cc_lockspace, 2);
         conn->cc_lockspace = NULL;
@@ -838,7 +837,7 @@ static int user_cluster_this_node(unsigned int *this_node)
         return 0;
 }
 
-static struct ocfs2_stack_operations user_stack_ops = {
+static struct ocfs2_stack_operations ocfs2_user_plugin_ops = {
         .connect        = user_cluster_connect,
         .disconnect     = user_cluster_disconnect,
         .this_node      = user_cluster_this_node,
@@ -849,20 +848,20 @@ static struct ocfs2_stack_operations user_stack_ops = {
         .dump_lksb      = user_dlm_dump_lksb,
 };
 
-static struct ocfs2_stack_plugin user_stack = {
+static struct ocfs2_stack_plugin ocfs2_user_plugin = {
         .sp_name        = "user",
-        .sp_ops         = &user_stack_ops,
+        .sp_ops         = &ocfs2_user_plugin_ops,
         .sp_owner       = THIS_MODULE,
 };
 
 
-static int __init user_stack_init(void)
+static int __init ocfs2_user_plugin_init(void)
 {
         int rc;
 
         rc = ocfs2_control_init();
         if (!rc) {
-                rc = ocfs2_stack_glue_register(&user_stack);
+                rc = ocfs2_stack_glue_register(&ocfs2_user_plugin);
                 if (rc)
                         ocfs2_control_exit();
         }
@@ -870,14 +869,14 @@ static int __init user_stack_init(void)
         return rc;
 }
 
-static void __exit user_stack_exit(void)
+static void __exit ocfs2_user_plugin_exit(void)
 {
-        ocfs2_stack_glue_unregister(&user_stack);
+        ocfs2_stack_glue_unregister(&ocfs2_user_plugin);
         ocfs2_control_exit();
 }
 
 MODULE_AUTHOR("Oracle");
 MODULE_DESCRIPTION("ocfs2 driver for userspace cluster stacks");
 MODULE_LICENSE("GPL");
-module_init(user_stack_init);
-module_exit(user_stack_exit);
+module_init(ocfs2_user_plugin_init);
+module_exit(ocfs2_user_plugin_exit);
diff --git a/fs/ocfs2/stackglue.c b/fs/ocfs2/stackglue.c
index 119f60cea9cc..10e149ae5e3a 100644
--- a/fs/ocfs2/stackglue.c
+++ b/fs/ocfs2/stackglue.c
@@ -26,6 +26,7 @@
 #include <linux/fs.h>
 #include <linux/kobject.h>
 #include <linux/sysfs.h>
+#include <linux/sysctl.h>
 
 #include "ocfs2_fs.h"
 
@@ -33,11 +34,13 @@
 
 #define OCFS2_STACK_PLUGIN_O2CB         "o2cb"
 #define OCFS2_STACK_PLUGIN_USER         "user"
+#define OCFS2_MAX_HB_CTL_PATH           256
 
 static struct ocfs2_locking_protocol *lproto;
 static DEFINE_SPINLOCK(ocfs2_stack_lock);
 static LIST_HEAD(ocfs2_stack_list);
 static char cluster_stack_name[OCFS2_STACK_LABEL_LEN + 1];
+static char ocfs2_hb_ctl_path[OCFS2_MAX_HB_CTL_PATH] = "/sbin/ocfs2_hb_ctl";
 
 /*
  * The stack currently in use.  If not null, active_stack->sp_count > 0,
@@ -349,7 +352,7 @@ int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn,
 
         BUG_ON(conn == NULL);
 
-        ret = active_stack->sp_ops->disconnect(conn, hangup_pending);
+        ret = active_stack->sp_ops->disconnect(conn);
 
         /* XXX Should we free it anyway? */
         if (!ret) {
@@ -362,13 +365,48 @@ int ocfs2_cluster_disconnect(struct ocfs2_cluster_connection *conn,
 }
 EXPORT_SYMBOL_GPL(ocfs2_cluster_disconnect);
 
+/*
+ * Leave the group for this filesystem.  This is executed by a userspace
+ * program (stored in ocfs2_hb_ctl_path).
+ */
+static void ocfs2_leave_group(const char *group)
+{
+        int ret;
+        char *argv[5], *envp[3];
+
+        argv[0] = ocfs2_hb_ctl_path;
+        argv[1] = "-K";
+        argv[2] = "-u";
+        argv[3] = (char *)group;
+        argv[4] = NULL;
+
+        /* minimal command environment taken from cpu_run_sbin_hotplug */
+        envp[0] = "HOME=/";
+        envp[1] = "PATH=/sbin:/bin:/usr/sbin:/usr/bin";
+        envp[2] = NULL;
+
+        ret = call_usermodehelper(argv[0], argv, envp, UMH_WAIT_PROC);
+        if (ret < 0) {
+                printk(KERN_ERR
+                       "ocfs2: Error %d running user helper "
+                       "\"%s %s %s %s\"\n",
+                       ret, argv[0], argv[1], argv[2], argv[3]);
+        }
+}
+
+/*
+ * Hangup is a required post-umount.  ocfs2-tools software expects the
+ * filesystem to call "ocfs2_hb_ctl" during unmount.  This happens
+ * regardless of whether the DLM got started, so we can't do it
+ * in ocfs2_cluster_disconnect().  The ocfs2_leave_group() function does
+ * the actual work.
+ */
 void ocfs2_cluster_hangup(const char *group, int grouplen)
 {
         BUG_ON(group == NULL);
         BUG_ON(group[grouplen] != '\0');
 
-        if (active_stack->sp_ops->hangup)
-                active_stack->sp_ops->hangup(group, grouplen);
+        ocfs2_leave_group(group);
 
         /* cluster_disconnect() was called with hangup_pending==1 */
         ocfs2_stack_driver_put();
@@ -548,10 +586,83 @@ error:
         return ret;
 }
 
+/*
+ * Sysctl bits
+ *
+ * The sysctl lives at /proc/sys/fs/ocfs2/nm/hb_ctl_path.  The 'nm' doesn't
+ * make as much sense in a multiple cluster stack world, but it's safer
+ * and easier to preserve the name.
+ */
+
+#define FS_OCFS2_NM             1
+
+static ctl_table ocfs2_nm_table[] = {
+        {
+                .ctl_name       = 1,
+                .procname       = "hb_ctl_path",
+                .data           = ocfs2_hb_ctl_path,
+                .maxlen         = OCFS2_MAX_HB_CTL_PATH,
+                .mode           = 0644,
+                .proc_handler   = &proc_dostring,
+                .strategy       = &sysctl_string,
+        },
+        { .ctl_name = 0 }
+};
+
+static ctl_table ocfs2_mod_table[] = {
+        {
+                .ctl_name       = FS_OCFS2_NM,
+                .procname       = "nm",
+                .data           = NULL,
+                .maxlen         = 0,
+                .mode           = 0555,
+                .child          = ocfs2_nm_table
+        },
+        { .ctl_name = 0}
+};
+
+static ctl_table ocfs2_kern_table[] = {
+        {
+                .ctl_name       = FS_OCFS2,
+                .procname       = "ocfs2",
+                .data           = NULL,
+                .maxlen         = 0,
+                .mode           = 0555,
+                .child          = ocfs2_mod_table
+        },
+        { .ctl_name = 0}
+};
+
+static ctl_table ocfs2_root_table[] = {
+        {
+                .ctl_name       = CTL_FS,
+                .procname       = "fs",
+                .data           = NULL,
+                .maxlen         = 0,
+                .mode           = 0555,
+                .child          = ocfs2_kern_table
+        },
+        { .ctl_name = 0 }
+};
+
+static struct ctl_table_header *ocfs2_table_header = NULL;
+
+
+/*
+ * Initialization
+ */
+
 static int __init ocfs2_stack_glue_init(void)
 {
         strcpy(cluster_stack_name, OCFS2_STACK_PLUGIN_O2CB);
 
+        ocfs2_table_header = register_sysctl_table(ocfs2_root_table);
+        if (!ocfs2_table_header) {
+                printk(KERN_ERR
+                       "ocfs2 stack glue: unable to register sysctl\n");
+                return -ENOMEM; /* or something. */
+        }
+
         return ocfs2_sysfs_init();
 }
 
@@ -559,6 +670,8 @@ static void __exit ocfs2_stack_glue_exit(void)
 {
         lproto = NULL;
         ocfs2_sysfs_exit();
+        if (ocfs2_table_header)
+                unregister_sysctl_table(ocfs2_table_header);
 }
 
 MODULE_AUTHOR("Oracle");
diff --git a/fs/ocfs2/stackglue.h b/fs/ocfs2/stackglue.h
index 005e4f170e0f..db56281dd1be 100644
--- a/fs/ocfs2/stackglue.h
+++ b/fs/ocfs2/stackglue.h
@@ -134,22 +134,10 @@ struct ocfs2_stack_operations {
          * be freed.  Thus, a stack must not return from ->disconnect()
          * until it will no longer reference the conn pointer.
          *
-         * If hangup_pending is zero, ocfs2_cluster_disconnect() will also
-         * be dropping the reference on the module.
+         * Once this call returns, the stack glue will be dropping this
+         * connection's reference on the module.
          */
-        int (*disconnect)(struct ocfs2_cluster_connection *conn,
-                          int hangup_pending);
-
-        /*
-         * ocfs2_cluster_hangup() exists for compatibility with older
-         * ocfs2 tools.  Only the classic stack really needs it.  As such
-         * ->hangup() is not required of all stacks.  See the comment by
-         * ocfs2_cluster_hangup() for more details.
-         *
-         * Note that ocfs2_cluster_hangup() can only be called if
-         * hangup_pending was passed to ocfs2_cluster_disconnect().
-         */
-        void (*hangup)(const char *group, int grouplen);
+        int (*disconnect)(struct ocfs2_cluster_connection *conn);
 
         /*
          * ->this_node() returns the cluster's unique identifier for the
@@ -258,4 +246,5 @@ void ocfs2_stack_glue_set_locking_protocol(struct ocfs2_locking_protocol *proto)
 /* Used by stack plugins */
 int ocfs2_stack_glue_register(struct ocfs2_stack_plugin *plugin);
 void ocfs2_stack_glue_unregister(struct ocfs2_stack_plugin *plugin);
+
 #endif  /* STACKGLUE_H */
diff --git a/fs/pipe.c b/fs/pipe.c
index ec228bc9f882..700f4e0d9572 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -1003,8 +1003,7 @@ struct file *create_write_pipe(void)
 void free_write_pipe(struct file *f)
 {
         free_pipe_info(f->f_dentry->d_inode);
-        dput(f->f_path.dentry);
-        mntput(f->f_path.mnt);
+        path_put(&f->f_path);
         put_filp(f);
 }
 
@@ -1015,8 +1014,8 @@ struct file *create_read_pipe(struct file *wrf)
                 return ERR_PTR(-ENFILE);
 
         /* Grab pipe from the writer */
-        f->f_path.mnt = mntget(wrf->f_path.mnt);
-        f->f_path.dentry = dget(wrf->f_path.dentry);
+        f->f_path = wrf->f_path;
+        path_get(&wrf->f_path);
         f->f_mapping = wrf->f_path.dentry->d_inode->i_mapping;
 
         f->f_pos = 0;
@@ -1068,8 +1067,7 @@ int do_pipe(int *fd)
  err_fdr:
         put_unused_fd(fdr);
  err_read_pipe:
-        dput(fr->f_dentry);
-        mntput(fr->f_vfsmnt);
+        path_put(&fr->f_path);
         put_filp(fr);
  err_write_pipe:
         free_write_pipe(fw);
diff --git a/fs/proc/array.c b/fs/proc/array.c
index 9e3b8c33c24b..797d775e0354 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -288,7 +288,7 @@ static void render_cap_t(struct seq_file *m, const char *header,
         seq_printf(m, "%s", header);
         CAP_FOR_EACH_U32(__capi) {
                 seq_printf(m, "%08x",
-                           a->cap[(_LINUX_CAPABILITY_U32S-1) - __capi]);
+                           a->cap[(_KERNEL_CAPABILITY_U32S-1) - __capi]);
         }
         seq_printf(m, "\n");
 }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 808cbdc193d3..3b455371e7ff 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -127,6 +127,25 @@ struct pid_entry {
                 NULL, &proc_single_file_operations,     \
                 { .proc_show = &proc_##OTYPE } )
 
+/*
+ * Count the number of hardlinks for the pid_entry table, excluding the .
+ * and .. links.
+ */
+static unsigned int pid_entry_count_dirs(const struct pid_entry *entries,
+        unsigned int n)
+{
+        unsigned int i;
+        unsigned int count;
+
+        count = 0;
+        for (i = 0; i < n; ++i) {
+                if (S_ISDIR(entries[i].mode))
+                        ++count;
+        }
+
+        return count;
+}
+
 int maps_protect;
 EXPORT_SYMBOL(maps_protect);
 
@@ -2441,7 +2460,7 @@ static const struct pid_entry tgid_base_stuff[] = {
         REG("oom_adj",    S_IRUGO|S_IWUSR, oom_adjust),
 #ifdef CONFIG_AUDITSYSCALL
         REG("loginuid",   S_IWUSR|S_IRUGO, loginuid),
-        REG("sessionid",  S_IRUSR, sessionid),
+        REG("sessionid",  S_IRUGO, sessionid),
 #endif
 #ifdef CONFIG_FAULT_INJECTION
         REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
@@ -2585,10 +2604,9 @@ 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 = 5;
-#ifdef CONFIG_SECURITY
-        inode->i_nlink += 1;
-#endif
+
+        inode->i_nlink = 2 + pid_entry_count_dirs(tgid_base_stuff,
+                ARRAY_SIZE(tgid_base_stuff));
 
         dentry->d_op = &pid_dentry_operations;
 
@@ -2816,10 +2834,9 @@ 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 = 4;
-#ifdef CONFIG_SECURITY
-        inode->i_nlink += 1;
-#endif
+
+        inode->i_nlink = 2 + pid_entry_count_dirs(tid_base_stuff,
+                ARRAY_SIZE(tid_base_stuff));
 
         dentry->d_op = &pid_dentry_operations;
 
diff --git a/fs/proc/inode.c b/fs/proc/inode.c
index 6f4e8dc97da1..b08d10017911 100644
--- a/fs/proc/inode.c
+++ b/fs/proc/inode.c
@@ -425,7 +425,8 @@ struct inode *proc_get_inode(struct super_block *sb, unsigned int ino,
                         }
                 }
                 unlock_new_inode(inode);
-        }
+        } else
+               module_put(de->owner);
         return inode;
 
 out_ino:
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 74a323d2b850..7e277f2ad466 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -139,7 +139,7 @@ static int meminfo_read_proc(char *page, char **start, off_t off,
 #define K(x) ((x) << (PAGE_SHIFT - 10))
         si_meminfo(&i);
         si_swapinfo(&i);
-        committed = atomic_read(&vm_committed_space);
+        committed = atomic_long_read(&vm_committed_space);
         allowed = ((totalram_pages - hugetlb_total_pages())
                 * sysctl_overcommit_ratio / 100) + total_swap_pages;
 
@@ -716,7 +716,7 @@ static ssize_t kpagecount_read(struct file *file, char __user *buf,
         pfn = src / KPMSIZE;
         count = min_t(size_t, count, (max_pfn * KPMSIZE) - src);
         if (src & KPMMASK || count & KPMMASK)
-                return -EIO;
+                return -EINVAL;
 
         while (count > 0) {
                 ppage = NULL;
@@ -726,7 +726,7 @@ static ssize_t kpagecount_read(struct file *file, char __user *buf,
                 if (!ppage)
                         pcount = 0;
                 else
-                        pcount = atomic_read(&ppage->_count);
+                        pcount = page_mapcount(ppage);
 
                 if (put_user(pcount, out++)) {
                         ret = -EFAULT;
@@ -782,7 +782,7 @@ static ssize_t kpageflags_read(struct file *file, char __user *buf,
         pfn = src / KPMSIZE;
         count = min_t(unsigned long, count, (max_pfn * KPMSIZE) - src);
         if (src & KPMMASK || count & KPMMASK)
-                return -EIO;
+                return -EINVAL;
 
         while (count > 0) {
                 ppage = NULL;
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 88717c0f941b..ab8ccc9d14ff 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -315,9 +315,9 @@ struct mem_size_stats {
 };
 
 static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
-                           void *private)
+                           struct mm_walk *walk)
 {
-        struct mem_size_stats *mss = private;
+        struct mem_size_stats *mss = walk->private;
         struct vm_area_struct *vma = mss->vma;
         pte_t *pte, ptent;
         spinlock_t *ptl;
@@ -365,19 +365,21 @@ static int smaps_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
         return 0;
 }
 
-static struct mm_walk smaps_walk = { .pmd_entry = smaps_pte_range };
-
 static int show_smap(struct seq_file *m, void *v)
 {
         struct vm_area_struct *vma = v;
         struct mem_size_stats mss;
         int ret;
+        struct mm_walk smaps_walk = {
+                .pmd_entry = smaps_pte_range,
+                .mm = vma->vm_mm,
+                .private = &mss,
+        };
 
         memset(&mss, 0, sizeof mss);
         mss.vma = vma;
         if (vma->vm_mm && !is_vm_hugetlb_page(vma))
-                walk_page_range(vma->vm_mm, vma->vm_start, vma->vm_end,
-                                &smaps_walk, &mss);
+                walk_page_range(vma->vm_start, vma->vm_end, &smaps_walk);
 
         ret = show_map(m, v);
         if (ret)
@@ -426,9 +428,9 @@ const struct file_operations proc_smaps_operations = {
 };
 
 static int clear_refs_pte_range(pmd_t *pmd, unsigned long addr,
-                                unsigned long end, void *private)
+                                unsigned long end, struct mm_walk *walk)
 {
-        struct vm_area_struct *vma = private;
+        struct vm_area_struct *vma = walk->private;
         pte_t *pte, ptent;
         spinlock_t *ptl;
         struct page *page;
@@ -452,8 +454,6 @@ static int clear_refs_pte_range(pmd_t *pmd, unsigned long addr,
         return 0;
 }
 
-static struct mm_walk clear_refs_walk = { .pmd_entry = clear_refs_pte_range };
-
 static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                                 size_t count, loff_t *ppos)
 {
@@ -476,11 +476,17 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                 return -ESRCH;
         mm = get_task_mm(task);
         if (mm) {
+                static struct mm_walk clear_refs_walk;
+                memset(&clear_refs_walk, 0, sizeof(clear_refs_walk));
+                clear_refs_walk.pmd_entry = clear_refs_pte_range;
+                clear_refs_walk.mm = mm;
                 down_read(&mm->mmap_sem);
-                for (vma = mm->mmap; vma; vma = vma->vm_next)
+                for (vma = mm->mmap; vma; vma = vma->vm_next) {
+                        clear_refs_walk.private = vma;
                         if (!is_vm_hugetlb_page(vma))
-                                walk_page_range(mm, vma->vm_start, vma->vm_end,
-                                                &clear_refs_walk, vma);
+                                walk_page_range(vma->vm_start, vma->vm_end,
+                                                &clear_refs_walk);
+                }
                 flush_tlb_mm(mm);
                 up_read(&mm->mmap_sem);
                 mmput(mm);
@@ -496,7 +502,7 @@ const struct file_operations proc_clear_refs_operations = {
 };
 
 struct pagemapread {
-        char __user *out, *end;
+        u64 __user *out, *end;
 };
 
 #define PM_ENTRY_BYTES      sizeof(u64)
@@ -519,28 +525,18 @@ struct pagemapread {
 static int add_to_pagemap(unsigned long addr, u64 pfn,
                           struct pagemapread *pm)
 {
-        /*
-         * Make sure there's room in the buffer for an
-         * entire entry.  Otherwise, only copy part of
-         * the pfn.
-         */
-        if (pm->out + PM_ENTRY_BYTES >= pm->end) {
-                if (copy_to_user(pm->out, &pfn, pm->end - pm->out))
-                        return -EFAULT;
-                pm->out = pm->end;
-                return PM_END_OF_BUFFER;
-        }
-
         if (put_user(pfn, pm->out))
                 return -EFAULT;
-        pm->out += PM_ENTRY_BYTES;
+        pm->out++;
+        if (pm->out >= pm->end)
+                return PM_END_OF_BUFFER;
         return 0;
 }
 
 static int pagemap_pte_hole(unsigned long start, unsigned long end,
-                                void *private)
+                                struct mm_walk *walk)
 {
-        struct pagemapread *pm = private;
+        struct pagemapread *pm = walk->private;
         unsigned long addr;
         int err = 0;
         for (addr = start; addr < end; addr += PAGE_SIZE) {
@@ -557,24 +553,45 @@ static u64 swap_pte_to_pagemap_entry(pte_t pte)
         return swp_type(e) | (swp_offset(e) << MAX_SWAPFILES_SHIFT);
 }
 
+static unsigned long pte_to_pagemap_entry(pte_t pte)
+{
+        unsigned long pme = 0;
+        if (is_swap_pte(pte))
+                pme = PM_PFRAME(swap_pte_to_pagemap_entry(pte))
+                        | PM_PSHIFT(PAGE_SHIFT) | PM_SWAP;
+        else if (pte_present(pte))
+                pme = PM_PFRAME(pte_pfn(pte))
+                        | PM_PSHIFT(PAGE_SHIFT) | PM_PRESENT;
+        return pme;
+}
+
 static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
-                             void *private)
+                             struct mm_walk *walk)
 {
-        struct pagemapread *pm = private;
+        struct vm_area_struct *vma;
+        struct pagemapread *pm = walk->private;
         pte_t *pte;
         int err = 0;
 
+        /* find the first VMA at or above 'addr' */
+        vma = find_vma(walk->mm, addr);
         for (; addr != end; addr += PAGE_SIZE) {
                 u64 pfn = PM_NOT_PRESENT;
-                pte = pte_offset_map(pmd, addr);
-                if (is_swap_pte(*pte))
-                        pfn = PM_PFRAME(swap_pte_to_pagemap_entry(*pte))
-                                | PM_PSHIFT(PAGE_SHIFT) | PM_SWAP;
-                else if (pte_present(*pte))
-                        pfn = PM_PFRAME(pte_pfn(*pte))
-                                | PM_PSHIFT(PAGE_SHIFT) | PM_PRESENT;
-                /* unmap so we're not in atomic when we copy to userspace */
-                pte_unmap(pte);
+
+                /* check to see if we've left 'vma' behind
+                 * and need a new, higher one */
+                if (vma && (addr >= vma->vm_end))
+                        vma = find_vma(walk->mm, addr);
+
+                /* check that 'vma' actually covers this address,
+                 * and that it isn't a huge page vma */
+                if (vma && (vma->vm_start <= addr) &&
+                    !is_vm_hugetlb_page(vma)) {
+                        pte = pte_offset_map(pmd, addr);
+                        pfn = pte_to_pagemap_entry(*pte);
+                        /* unmap before userspace copy */
+                        pte_unmap(pte);
+                }
                 err = add_to_pagemap(addr, pfn, pm);
                 if (err)
                         return err;
@@ -634,7 +651,7 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
 
         ret = -EINVAL;
         /* file position must be aligned */
-        if (*ppos % PM_ENTRY_BYTES)
+        if ((*ppos % PM_ENTRY_BYTES) || (count % PM_ENTRY_BYTES))
                 goto out_task;
 
         ret = 0;
@@ -664,8 +681,8 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
                 goto out_pages;
         }
 
-        pm.out = buf;
-        pm.end = buf + count;
+        pm.out = (u64 *)buf;
+        pm.end = (u64 *)(buf + count);
 
         if (!ptrace_may_attach(task)) {
                 ret = -EIO;
@@ -685,14 +702,14 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
                  * user buffer is tracked in "pm", and the walk
                  * will stop when we hit the end of the buffer.
                  */
-                ret = walk_page_range(mm, start_vaddr, end_vaddr,
-                                        &pagemap_walk, &pm);
+                ret = walk_page_range(start_vaddr, end_vaddr,
+                                        &pagemap_walk);
                 if (ret == PM_END_OF_BUFFER)
                         ret = 0;
                 /* don't need mmap_sem for these, but this looks cleaner */
-                *ppos += pm.out - buf;
+                *ppos += (char *)pm.out - buf;
                 if (!ret)
-                        ret = pm.out - buf;
+                        ret = (char *)pm.out - buf;
         }
 
 out_pages:
diff --git a/fs/select.c b/fs/select.c
index 8dda969614a9..da0e88201c3a 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -249,7 +249,6 @@ int do_select(int n, fd_set_bits *fds, s64 *timeout)
                                                 retval++;
                                         }
                                 }
-                                cond_resched();
                         }
                         if (res_in)
                                 *rinp = res_in;
@@ -257,6 +256,7 @@ int do_select(int n, fd_set_bits *fds, s64 *timeout)
                                 *routp = res_out;
                         if (res_ex)
                                 *rexp = res_ex;
+                        cond_resched();
                 }
                 wait = NULL;
                 if (retval || !*timeout || signal_pending(current))
diff --git a/fs/splice.c b/fs/splice.c
index 78150038b584..aa5f6f60b305 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -58,8 +58,8 @@ static int page_cache_pipe_buf_steal(struct pipe_inode_info *pipe,
                  */
                 wait_on_page_writeback(page);
 
-                if (PagePrivate(page))
-                        try_to_release_page(page, GFP_KERNEL);
+                if (PagePrivate(page) && !try_to_release_page(page, GFP_KERNEL))
+                        goto out_unlock;
 
                 /*
                  * If we succeeded in removing the mapping, set LRU flag
@@ -75,6 +75,7 @@ static int page_cache_pipe_buf_steal(struct pipe_inode_info *pipe,
          * Raced with truncate or failed to remove page from current
          * address space, unlock and return failure.
          */
+out_unlock:
         unlock_page(page);
         return 1;
 }
@@ -983,7 +984,7 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
 
         while (len) {
                 size_t read_len;
-                loff_t pos = sd->pos;
+                loff_t pos = sd->pos, prev_pos = pos;
 
                 ret = do_splice_to(in, &pos, pipe, len, flags);
                 if (unlikely(ret <= 0))
@@ -998,15 +999,19 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,
                  * could get stuck data in the internal pipe:
                  */
                 ret = actor(pipe, sd);
-                if (unlikely(ret <= 0))
+                if (unlikely(ret <= 0)) {
+                        sd->pos = prev_pos;
                         goto out_release;
+                }
 
                 bytes += ret;
                 len -= ret;
                 sd->pos = pos;
 
-                if (ret < read_len)
+                if (ret < read_len) {
+                        sd->pos = prev_pos + ret;
                         goto out_release;
+                }
         }
 
 done:
@@ -1072,7 +1077,7 @@ long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
 
         ret = splice_direct_to_actor(in, &sd, direct_splice_actor);
         if (ret > 0)
-                *ppos += ret;
+                *ppos = sd.pos;
 
         return ret;
 }
diff --git a/fs/sysfs/dir.c b/fs/sysfs/dir.c
index a1c3a1fab7f0..8c0e4b92574f 100644
--- a/fs/sysfs/dir.c
+++ b/fs/sysfs/dir.c
@@ -419,12 +419,8 @@ void sysfs_addrm_start(struct sysfs_addrm_cxt *acxt,
  */
 int sysfs_add_one(struct sysfs_addrm_cxt *acxt, struct sysfs_dirent *sd)
 {
-        if (sysfs_find_dirent(acxt->parent_sd, sd->s_name)) {
-                printk(KERN_WARNING "sysfs: duplicate filename '%s' "
-                       "can not be created\n", sd->s_name);
-                WARN_ON(1);
+        if (sysfs_find_dirent(acxt->parent_sd, sd->s_name))
                 return -EEXIST;
-        }
 
         sd->s_parent = sysfs_get(acxt->parent_sd);
 
diff --git a/fs/udf/super.c b/fs/udf/super.c
index 7a5f69be6ac2..44cc702f96cc 100644
--- a/fs/udf/super.c
+++ b/fs/udf/super.c
@@ -682,38 +682,26 @@ static int udf_vrs(struct super_block *sb, int silent)
 /*
  * Check whether there is an anchor block in the given block
  */
-static int udf_check_anchor_block(struct super_block *sb, sector_t block,
-                                        bool varconv)
+static int udf_check_anchor_block(struct super_block *sb, sector_t block)
 {
-        struct buffer_head *bh = NULL;
-        tag *t;
+        struct buffer_head *bh;
         uint16_t ident;
-        uint32_t location;
 
-        if (varconv) {
-                if (udf_fixed_to_variable(block) >=
-                    sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits)
-                        return 0;
-                bh = sb_bread(sb, udf_fixed_to_variable(block));
-        }
-        else
-                bh = sb_bread(sb, block);
+        if (UDF_QUERY_FLAG(sb, UDF_FLAG_VARCONV) &&
+            udf_fixed_to_variable(block) >=
+            sb->s_bdev->bd_inode->i_size >> sb->s_blocksize_bits)
+                return 0;
 
+        bh = udf_read_tagged(sb, block, block, &ident);
         if (!bh)
                 return 0;
-
-        t = (tag *)bh->b_data;
-        ident = le16_to_cpu(t->tagIdent);
-        location = le32_to_cpu(t->tagLocation);
         brelse(bh);
-        if (ident != TAG_IDENT_AVDP)
-                return 0;
-        return location == block;
+
+        return ident == TAG_IDENT_AVDP;
 }
 
 /* Search for an anchor volume descriptor pointer */
-static sector_t udf_scan_anchors(struct super_block *sb, bool varconv,
-                                        sector_t lastblock)
+static sector_t udf_scan_anchors(struct super_block *sb, sector_t lastblock)
 {
         sector_t last[6];
         int i;
@@ -739,7 +727,7 @@ static sector_t udf_scan_anchors(struct super_block *sb, bool varconv,
                                 sb->s_blocksize_bits)
                         continue;
 
-                if (udf_check_anchor_block(sb, last[i], varconv)) {
+                if (udf_check_anchor_block(sb, last[i])) {
                         sbi->s_anchor[0] = last[i];
                         sbi->s_anchor[1] = last[i] - 256;
                         return last[i];
@@ -748,17 +736,17 @@ static sector_t udf_scan_anchors(struct super_block *sb, bool varconv,
                 if (last[i] < 256)
                         continue;
 
-                if (udf_check_anchor_block(sb, last[i] - 256, varconv)) {
+                if (udf_check_anchor_block(sb, last[i] - 256)) {
                         sbi->s_anchor[1] = last[i] - 256;
                         return last[i];
                 }
         }
 
-        if (udf_check_anchor_block(sb, sbi->s_session + 256, varconv)) {
+        if (udf_check_anchor_block(sb, sbi->s_session + 256)) {
                 sbi->s_anchor[0] = sbi->s_session + 256;
                 return last[0];
         }
-        if (udf_check_anchor_block(sb, sbi->s_session + 512, varconv)) {
+        if (udf_check_anchor_block(sb, sbi->s_session + 512)) {
                 sbi->s_anchor[0] = sbi->s_session + 512;
                 return last[0];
         }
@@ -780,23 +768,24 @@ static void udf_find_anchor(struct super_block *sb)
         int i;
         struct udf_sb_info *sbi = UDF_SB(sb);
 
-        lastblock = udf_scan_anchors(sb, 0, sbi->s_last_block);
+        lastblock = udf_scan_anchors(sb, sbi->s_last_block);
         if (lastblock)
                 goto check_anchor;
 
         /* No anchor found? Try VARCONV conversion of block numbers */
+        UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
         /* Firstly, we try to not convert number of the last block */
-        lastblock = udf_scan_anchors(sb, 1,
+        lastblock = udf_scan_anchors(sb,
                                 udf_variable_to_fixed(sbi->s_last_block));
-        if (lastblock) {
-                UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
+        if (lastblock)
                 goto check_anchor;
-        }
 
         /* Secondly, we try with converted number of the last block */
-        lastblock = udf_scan_anchors(sb, 1, sbi->s_last_block);
-        if (lastblock)
-                UDF_SET_FLAG(sb, UDF_FLAG_VARCONV);
+        lastblock = udf_scan_anchors(sb, sbi->s_last_block);
+        if (!lastblock) {
+                /* VARCONV didn't help. Clear it. */
+                UDF_CLEAR_FLAG(sb, UDF_FLAG_VARCONV);
+        }
 
 check_anchor:
         /*
diff --git a/fs/udf/udfdecl.h b/fs/udf/udfdecl.h
index 8fa9c2d70911..8ec865de5f13 100644
--- a/fs/udf/udfdecl.h
+++ b/fs/udf/udfdecl.h
@@ -16,7 +16,7 @@
 #define UDF_PREALLOCATE
 #define UDF_DEFAULT_PREALLOC_BLOCKS     8
 
-#define UDFFS_DEBUG
+#undef UDFFS_DEBUG
 
 #ifdef UDFFS_DEBUG
 #define udf_debug(f, a...) \
diff --git a/fs/utimes.c b/fs/utimes.c
index af059d5cb485..b6b664e7145e 100644
--- a/fs/utimes.c
+++ b/fs/utimes.c
@@ -40,14 +40,9 @@ asmlinkage long sys_utime(char __user *filename, struct utimbuf __user *times)
 
 #endif
 
-static bool nsec_special(long nsec)
-{
-        return nsec == UTIME_OMIT || nsec == UTIME_NOW;
-}
-
 static bool nsec_valid(long nsec)
 {
-        if (nsec_special(nsec))
+        if (nsec == UTIME_OMIT || nsec == UTIME_NOW)
                 return true;
 
         return nsec >= 0 && nsec <= 999999999;
@@ -102,7 +97,11 @@ long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags
         if (error)
                 goto dput_and_out;
 
-        /* Don't worry, the checks are done in inode_change_ok() */
+        if (times && times[0].tv_nsec == UTIME_NOW &&
+                     times[1].tv_nsec == UTIME_NOW)
+                times = NULL;
+
+        /* In most cases, the checks are done in inode_change_ok() */
         newattrs.ia_valid = ATTR_CTIME | ATTR_MTIME | ATTR_ATIME;
         if (times) {
                 error = -EPERM;
@@ -124,28 +123,34 @@ long do_utimes(int dfd, char __user *filename, struct timespec *times, int flags
                         newattrs.ia_mtime.tv_nsec = times[1].tv_nsec;
                         newattrs.ia_valid |= ATTR_MTIME_SET;
                 }
-        }
 
-        /*
-         * If times is NULL or both times are either UTIME_OMIT or
-         * UTIME_NOW, then need to check permissions, because
-         * inode_change_ok() won't do it.
-         */
-        if (!times || (nsec_special(times[0].tv_nsec) &&
-                       nsec_special(times[1].tv_nsec))) {
+                /*
+                 * For the UTIME_OMIT/UTIME_NOW and UTIME_NOW/UTIME_OMIT
+                 * cases, we need to make an extra check that is not done by
+                 * inode_change_ok().
+                 */
+                if (((times[0].tv_nsec == UTIME_NOW &&
+                            times[1].tv_nsec == UTIME_OMIT)
+                     ||
+                     (times[0].tv_nsec == UTIME_OMIT &&
+                            times[1].tv_nsec == UTIME_NOW))
+                    && !is_owner_or_cap(inode))
+                        goto mnt_drop_write_and_out;
+        } else {
+
+                /*
+                 * If times is NULL (or both times are UTIME_NOW),
+                 * then we need to check permissions, because
+                 * inode_change_ok() won't do it.
+                 */
                 error = -EACCES;
                 if (IS_IMMUTABLE(inode))
                         goto mnt_drop_write_and_out;
 
                 if (!is_owner_or_cap(inode)) {
-                        if (f) {
-                                if (!(f->f_mode & FMODE_WRITE))
-                                        goto mnt_drop_write_and_out;
-                        } else {
-                                error = vfs_permission(&nd, MAY_WRITE);
-                                if (error)
-                                        goto mnt_drop_write_and_out;
-                        }
+                        error = permission(inode, MAY_WRITE, NULL);
+                        if (error)
+                                goto mnt_drop_write_and_out;
                 }
         }
         mutex_lock(&inode->i_mutex);
@@ -169,14 +174,6 @@ asmlinkage long sys_utimensat(int dfd, char __user *filename, struct timespec __
         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 &&
diff --git a/fs/xfs/linux-2.6/xfs_buf.c b/fs/xfs/linux-2.6/xfs_buf.c
index 5105015a75ad..98e0e86093b4 100644
--- a/fs/xfs/linux-2.6/xfs_buf.c
+++ b/fs/xfs/linux-2.6/xfs_buf.c
@@ -387,6 +387,8 @@ _xfs_buf_lookup_pages(
                 if (unlikely(page == NULL)) {
                         if (flags & XBF_READ_AHEAD) {
                                 bp->b_page_count = i;
+                                for (i = 0; i < bp->b_page_count; i++)
+                                        unlock_page(bp->b_pages[i]);
                                 return -ENOMEM;
                         }
 
@@ -416,17 +418,24 @@ _xfs_buf_lookup_pages(
                 ASSERT(!PagePrivate(page));
                 if (!PageUptodate(page)) {
                         page_count--;
-                        if (blocksize < PAGE_CACHE_SIZE && !PagePrivate(page)) {
+                        if (blocksize >= PAGE_CACHE_SIZE) {
+                                if (flags & XBF_READ)
+                                        bp->b_flags |= _XBF_PAGE_LOCKED;
+                        } else if (!PagePrivate(page)) {
                                 if (test_page_region(page, offset, nbytes))
                                         page_count++;
                         }
                 }
 
-                unlock_page(page);
                 bp->b_pages[i] = page;
                 offset = 0;
         }
 
+        if (!(bp->b_flags & _XBF_PAGE_LOCKED)) {
+                for (i = 0; i < bp->b_page_count; i++)
+                        unlock_page(bp->b_pages[i]);
+        }
+
         if (page_count == bp->b_page_count)
                 bp->b_flags |= XBF_DONE;
 
@@ -746,6 +755,7 @@ xfs_buf_associate_memory(
         bp->b_count_desired = len;
         bp->b_buffer_length = buflen;
         bp->b_flags |= XBF_MAPPED;
+        bp->b_flags &= ~_XBF_PAGE_LOCKED;
 
         return 0;
 }
@@ -1093,8 +1103,10 @@ _xfs_buf_ioend(
         xfs_buf_t               *bp,
         int                     schedule)
 {
-        if (atomic_dec_and_test(&bp->b_io_remaining) == 1)
+        if (atomic_dec_and_test(&bp->b_io_remaining) == 1) {
+                bp->b_flags &= ~_XBF_PAGE_LOCKED;
                 xfs_buf_ioend(bp, schedule);
+        }
 }
 
 STATIC void
@@ -1125,6 +1137,9 @@ xfs_buf_bio_end_io(
 
                 if (--bvec >= bio->bi_io_vec)
                         prefetchw(&bvec->bv_page->flags);
+
+                if (bp->b_flags & _XBF_PAGE_LOCKED)
+                        unlock_page(page);
         } while (bvec >= bio->bi_io_vec);
 
         _xfs_buf_ioend(bp, 1);
@@ -1163,7 +1178,8 @@ _xfs_buf_ioapply(
          * filesystem block size is not smaller than the page size.
          */
         if ((bp->b_buffer_length < PAGE_CACHE_SIZE) &&
-            (bp->b_flags & XBF_READ) &&
+            ((bp->b_flags & (XBF_READ|_XBF_PAGE_LOCKED)) ==
+              (XBF_READ|_XBF_PAGE_LOCKED)) &&
             (blocksize >= PAGE_CACHE_SIZE)) {
                 bio = bio_alloc(GFP_NOIO, 1);
 
diff --git a/fs/xfs/linux-2.6/xfs_buf.h b/fs/xfs/linux-2.6/xfs_buf.h
index 841d7883528d..f948ec7ba9a4 100644
--- a/fs/xfs/linux-2.6/xfs_buf.h
+++ b/fs/xfs/linux-2.6/xfs_buf.h
@@ -66,6 +66,25 @@ typedef enum {
         _XBF_PAGES = (1 << 18),     /* backed by refcounted pages          */
         _XBF_RUN_QUEUES = (1 << 19),/* run block device task queue         */
         _XBF_DELWRI_Q = (1 << 21),   /* buffer on delwri queue             */
+
+        /*
+         * Special flag for supporting metadata blocks smaller than a FSB.
+         *
+         * In this case we can have multiple xfs_buf_t on a single page and
+         * need to lock out concurrent xfs_buf_t readers as they only
+         * serialise access to the buffer.
+         *
+         * If the FSB size >= PAGE_CACHE_SIZE case, we have no serialisation
+         * between reads of the page. Hence we can have one thread read the
+         * page and modify it, but then race with another thread that thinks
+         * the page is not up-to-date and hence reads it again.
+         *
+         * The result is that the first modifcation to the page is lost.
+         * This sort of AGF/AGI reading race can happen when unlinking inodes
+         * that require truncation and results in the AGI unlinked list
+         * modifications being lost.
+         */
+        _XBF_PAGE_LOCKED = (1 << 22),
 } xfs_buf_flags_t;
 
 typedef enum {
diff --git a/fs/xfs/linux-2.6/xfs_file.c b/fs/xfs/linux-2.6/xfs_file.c
index 65e78c13d4ae..5f60363b9343 100644
--- a/fs/xfs/linux-2.6/xfs_file.c
+++ b/fs/xfs/linux-2.6/xfs_file.c
@@ -184,19 +184,24 @@ xfs_file_release(
         return -xfs_release(XFS_I(inode));
 }
 
+/*
+ * We ignore the datasync flag here because a datasync is effectively
+ * identical to an fsync. That is, datasync implies that we need to write
+ * only the metadata needed to be able to access the data that is written
+ * if we crash after the call completes. Hence if we are writing beyond
+ * EOF we have to log the inode size change as well, which makes it a
+ * full fsync. If we don't write beyond EOF, the inode core will be
+ * clean in memory and so we don't need to log the inode, just like
+ * fsync.
+ */
 STATIC int
 xfs_file_fsync(
         struct file     *filp,
         struct dentry   *dentry,
         int             datasync)
 {
-        int             flags = FSYNC_WAIT;
-
-        if (datasync)
-                flags |= FSYNC_DATA;
         xfs_iflags_clear(XFS_I(dentry->d_inode), XFS_ITRUNCATED);
-        return -xfs_fsync(XFS_I(dentry->d_inode), flags,
-                        (xfs_off_t)0, (xfs_off_t)-1);
+        return -xfs_fsync(XFS_I(dentry->d_inode));
 }
 
 /*
diff --git a/fs/xfs/linux-2.6/xfs_vnode.h b/fs/xfs/linux-2.6/xfs_vnode.h
index 9d73cb5c0fc7..25eb2a9e8d9b 100644
--- a/fs/xfs/linux-2.6/xfs_vnode.h
+++ b/fs/xfs/linux-2.6/xfs_vnode.h
@@ -230,14 +230,6 @@ static inline void vn_atime_to_time_t(bhv_vnode_t *vp, time_t *tt)
 #define ATTR_NOSIZETOK  0x400   /* Don't get the SIZE token */
 
 /*
- * Flags to vop_fsync/reclaim.
- */
-#define FSYNC_NOWAIT    0       /* asynchronous flush */
-#define FSYNC_WAIT      0x1     /* synchronous fsync or forced reclaim */
-#define FSYNC_INVAL     0x2     /* flush and invalidate cached data */
-#define FSYNC_DATA      0x4     /* synchronous fsync of data only */
-
-/*
  * Tracking vnode activity.
  */
 #if defined(XFS_INODE_TRACE)
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index cf0bb9c1d621..e569bf5d6cf0 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -2974,6 +2974,7 @@ xfs_iflush_cluster(
         xfs_mount_t             *mp = ip->i_mount;
         xfs_perag_t             *pag = xfs_get_perag(mp, ip->i_ino);
         unsigned long           first_index, mask;
+        unsigned long           inodes_per_cluster;
         int                     ilist_size;
         xfs_inode_t             **ilist;
         xfs_inode_t             *iq;
@@ -2985,8 +2986,9 @@ xfs_iflush_cluster(
         ASSERT(pag->pagi_inodeok);
         ASSERT(pag->pag_ici_init);
 
-        ilist_size = XFS_INODE_CLUSTER_SIZE(mp) * sizeof(xfs_inode_t *);
-        ilist = kmem_alloc(ilist_size, KM_MAYFAIL);
+        inodes_per_cluster = XFS_INODE_CLUSTER_SIZE(mp) >> mp->m_sb.sb_inodelog;
+        ilist_size = inodes_per_cluster * sizeof(xfs_inode_t *);
+        ilist = kmem_alloc(ilist_size, KM_MAYFAIL|KM_NOFS);
         if (!ilist)
                 return 0;
 
@@ -2995,8 +2997,7 @@ xfs_iflush_cluster(
         read_lock(&pag->pag_ici_lock);
         /* really need a gang lookup range call here */
         nr_found = radix_tree_gang_lookup(&pag->pag_ici_root, (void**)ilist,
-                                        first_index,
-                                        XFS_INODE_CLUSTER_SIZE(mp));
+                                        first_index, inodes_per_cluster);
         if (nr_found == 0)
                 goto out_free;
 
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 70702a60b4bb..e475e3717eb3 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -856,18 +856,14 @@ xfs_readlink(
 /*
  * xfs_fsync
  *
- * This is called to sync the inode and its data out to disk.
- * We need to hold the I/O lock while flushing the data, and
- * the inode lock while flushing the inode.  The inode lock CANNOT
- * be held while flushing the data, so acquire after we're done
- * with that.
+ * This is called to sync the inode and its data out to disk.  We need to hold
+ * the I/O lock while flushing the data, and the inode lock while flushing the
+ * inode.  The inode lock CANNOT be held while flushing the data, so acquire
+ * after we're done with that.
  */
 int
 xfs_fsync(
-        xfs_inode_t     *ip,
-        int             flag,
-        xfs_off_t       start,
-        xfs_off_t       stop)
+        xfs_inode_t     *ip)
 {
         xfs_trans_t     *tp;
         int             error;
@@ -875,103 +871,79 @@ xfs_fsync(
 
         xfs_itrace_entry(ip);
 
-        ASSERT(start >= 0 && stop >= -1);
-
         if (XFS_FORCED_SHUTDOWN(ip->i_mount))
                 return XFS_ERROR(EIO);
 
-        if (flag & FSYNC_DATA)
-                filemap_fdatawait(vn_to_inode(XFS_ITOV(ip))->i_mapping);
+        /* capture size updates in I/O completion before writing the inode. */
+        error = filemap_fdatawait(vn_to_inode(XFS_ITOV(ip))->i_mapping);
+        if (error)
+                return XFS_ERROR(error);
 
         /*
-         * We always need to make sure that the required inode state
-         * is safe on disk.  The vnode might be clean but because
-         * of committed transactions that haven't hit the disk yet.
-         * Likewise, there could be unflushed non-transactional
-         * changes to the inode core that have to go to disk.
+         * We always need to make sure that the required inode state is safe on
+         * disk.  The vnode might be clean but we still might need to force the
+         * log because of committed transactions that haven't hit the disk yet.
+         * Likewise, there could be unflushed non-transactional changes to the
+         * inode core that have to go to disk and this requires us to issue
+         * a synchronous transaction to capture these changes correctly.
          *
-         * The following code depends on one assumption:  that
-         * any transaction that changes an inode logs the core
-         * because it has to change some field in the inode core
-         * (typically nextents or nblocks).  That assumption
-         * implies that any transactions against an inode will
-         * catch any non-transactional updates.  If inode-altering
-         * transactions exist that violate this assumption, the
-         * code breaks.  Right now, it figures that if the involved
-         * update_* field is clear and the inode is unpinned, the
-         * inode is clean.  Either it's been flushed or it's been
-         * committed and the commit has hit the disk unpinning the inode.
-         * (Note that xfs_inode_item_format() called at commit clears
-         * the update_* fields.)
+         * This code relies on the assumption that if the update_* fields
+         * of the inode are clear and the inode is unpinned then it is clean
+         * and no action is required.
          */
         xfs_ilock(ip, XFS_ILOCK_SHARED);
 
-        /* If we are flushing data then we care about update_size
-         * being set, otherwise we care about update_core
-         */
-        if ((flag & FSYNC_DATA) ?
-                        (ip->i_update_size == 0) :
-                        (ip->i_update_core == 0)) {
+        if (!(ip->i_update_size || ip->i_update_core)) {
                 /*
-                 * Timestamps/size haven't changed since last inode
-                 * flush or inode transaction commit.  That means
-                 * either nothing got written or a transaction
-                 * committed which caught the updates.  If the
-                 * latter happened and the transaction hasn't
-                 * hit the disk yet, the inode will be still
-                 * be pinned.  If it is, force the log.
+                 * Timestamps/size haven't changed since last inode flush or
+                 * inode transaction commit.  That means either nothing got
+                 * written or a transaction committed which caught the updates.
+                 * If the latter happened and the transaction hasn't hit the
+                 * disk yet, the inode will be still be pinned.  If it is,
+                 * force the log.
                  */
 
                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
 
                 if (xfs_ipincount(ip)) {
-                        _xfs_log_force(ip->i_mount, (xfs_lsn_t)0,
-                                      XFS_LOG_FORCE |
-                                      ((flag & FSYNC_WAIT)
-                                       ? XFS_LOG_SYNC : 0),
+                        error = _xfs_log_force(ip->i_mount, (xfs_lsn_t)0,
+                                      XFS_LOG_FORCE | XFS_LOG_SYNC,
                                       &log_flushed);
                 } else {
                         /*
-                         * If the inode is not pinned and nothing
-                         * has changed we don't need to flush the
-                         * cache.
+                         * If the inode is not pinned and nothing has changed
+                         * we don't need to flush the cache.
                          */
                         changed = 0;
                 }
-                error = 0;
         } else  {
                 /*
-                 * Kick off a transaction to log the inode
-                 * core to get the updates.  Make it
-                 * sync if FSYNC_WAIT is passed in (which
-                 * is done by everybody but specfs).  The
-                 * sync transaction will also force the log.
+                 * Kick off a transaction to log the inode core to get the
+                 * updates.  The sync transaction will also force the log.
                  */
                 xfs_iunlock(ip, XFS_ILOCK_SHARED);
                 tp = xfs_trans_alloc(ip->i_mount, XFS_TRANS_FSYNC_TS);
-                if ((error = xfs_trans_reserve(tp, 0,
-                                XFS_FSYNC_TS_LOG_RES(ip->i_mount),
-                                0, 0, 0)))  {
+                error = xfs_trans_reserve(tp, 0,
+                                XFS_FSYNC_TS_LOG_RES(ip->i_mount), 0, 0, 0);
+                if (error) {
                         xfs_trans_cancel(tp, 0);
                         return error;
                 }
                 xfs_ilock(ip, XFS_ILOCK_EXCL);
 
                 /*
-                 * Note - it's possible that we might have pushed
-                 * ourselves out of the way during trans_reserve
-                 * which would flush the inode.  But there's no
-                 * guarantee that the inode buffer has actually
-                 * gone out yet (it's delwri).  Plus the buffer
-                 * could be pinned anyway if it's part of an
-                 * inode in another recent transaction.  So we
-                 * play it safe and fire off the transaction anyway.
+                 * Note - it's possible that we might have pushed ourselves out
+                 * of the way during trans_reserve which would flush the inode.
+                 * But there's no guarantee that the inode buffer has actually
+                 * gone out yet (it's delwri).  Plus the buffer could be pinned
+                 * anyway if it's part of an inode in another recent
+                 * transaction.  So we play it safe and fire off the
+                 * transaction anyway.
                  */
                 xfs_trans_ijoin(tp, ip, XFS_ILOCK_EXCL);
                 xfs_trans_ihold(tp, ip);
                 xfs_trans_log_inode(tp, ip, XFS_ILOG_CORE);
-                if (flag & FSYNC_WAIT)
-                        xfs_trans_set_sync(tp);
+                xfs_trans_set_sync(tp);
                 error = _xfs_trans_commit(tp, 0, &log_flushed);
 
                 xfs_iunlock(ip, XFS_ILOCK_EXCL);
diff --git a/fs/xfs/xfs_vnodeops.h b/fs/xfs/xfs_vnodeops.h
index 8abe8f186e20..57335ba4ce53 100644
--- a/fs/xfs/xfs_vnodeops.h
+++ b/fs/xfs/xfs_vnodeops.h
@@ -18,8 +18,7 @@ int xfs_open(struct xfs_inode *ip);
 int xfs_setattr(struct xfs_inode *ip, struct bhv_vattr *vap, int flags,
                 struct cred *credp);
 int xfs_readlink(struct xfs_inode *ip, char *link);
-int xfs_fsync(struct xfs_inode *ip, int flag, xfs_off_t start,
-                xfs_off_t stop);
+int xfs_fsync(struct xfs_inode *ip);
 int xfs_release(struct xfs_inode *ip);
 int xfs_inactive(struct xfs_inode *ip);
 int xfs_lookup(struct xfs_inode *dp, struct xfs_name *name,