62 files changed, 804 insertions, 442 deletions
diff --git a/fs/9p/fid.h b/fs/9p/fid.h
index 26e07df783b..c3bbd6af996 100644
--- a/fs/9p/fid.h
+++ b/fs/9p/fid.h
@@ -22,6 +22,21 @@
 #include <linux/list.h>
+/**
+ * struct v9fs_dentry - 9p private data stored in dentry d_fsdata
+ * @lock: protects the fidlist
+ * @fidlist: list of FIDs currently associated with this dentry
+ *
+ * This structure defines the 9p private data associated with
+ * a particular dentry.  In particular, this private data is used
+ * to lookup which 9P FID handle should be used for a particular VFS
+ * operation.  FID handles are associated with dentries instead of
+ * inodes in order to more closely map functionality to the Plan 9
+ * expected behavior for FID reclaimation and tracking.
+ *
+ * See Also: Mapping FIDs to Linux VFS model in
+ * Design and Implementation of the Linux 9P File System documentation
+ */
 struct v9fs_dentry {
        spinlock_t lock; /* protect fidlist */
        struct list_head fidlist;
diff --git a/fs/9p/v9fs.c b/fs/9p/v9fs.c
index 9b0f0222e8b..047c791427a 100644
--- a/fs/9p/v9fs.c
+++ b/fs/9p/v9fs.c
@@ -71,19 +71,19 @@ static match_table_t tokens = {
 /**
 * v9fs_parse_options - parse mount options into session structure
- * @options: options string passed from mount
 * @v9ses: existing v9fs session information
 *
+ * Return 0 upon success, -ERRNO upon failure.
 */
-static void v9fs_parse_options(struct v9fs_session_info *v9ses)
+static int v9fs_parse_options(struct v9fs_session_info *v9ses)
 {
        char *options;
        substring_t args[MAX_OPT_ARGS];
        char *p;
        int option = 0;
        char *s, *e;
-        int ret;
+        int ret = 0;
        /* setup defaults */
        v9ses->afid = ~0;
@@ -91,19 +91,26 @@ static void v9fs_parse_options(struct v9fs_session_info *v9ses)
        v9ses->cache = 0;
        if (!v9ses->options)
-                return;
+                return 0;
        options = kstrdup(v9ses->options, GFP_KERNEL);
+        if (!options) {
+                P9_DPRINTK(P9_DEBUG_ERROR,
+                           "failed to allocate copy of option string\n");
+                return -ENOMEM;
+        }
        while ((p = strsep(&options, ",")) != NULL) {
                int token;
                if (!*p)
                        continue;
                token = match_token(p, tokens, args);
                if (token < Opt_uname) {
-                        ret = match_int(&args[0], &option);
+                        int r = match_int(&args[0], &option);
-                        if (ret < 0) {
+                        if (r < 0) {
                                P9_DPRINTK(P9_DEBUG_ERROR,
                                        "integer field, but no integer?\n");
+                                ret = r;
                                continue;
                        }
                }
@@ -125,10 +132,10 @@ static void v9fs_parse_options(struct v9fs_session_info *v9ses)
                        v9ses->afid = option;
                        break;
                case Opt_uname:
-                        match_strcpy(v9ses->uname, &args[0]);
+                        match_strlcpy(v9ses->uname, &args[0], PATH_MAX);
                        break;
                case Opt_remotename:
-                        match_strcpy(v9ses->aname, &args[0]);
+                        match_strlcpy(v9ses->aname, &args[0], PATH_MAX);
                        break;
                case Opt_nodevmap:
                        v9ses->nodev = 1;
@@ -139,6 +146,13 @@ static void v9fs_parse_options(struct v9fs_session_info *v9ses)
                case Opt_access:
                        s = match_strdup(&args[0]);
+                        if (!s) {
+                                P9_DPRINTK(P9_DEBUG_ERROR,
+                                           "failed to allocate copy"
+                                           " of option argument\n");
+                                ret = -ENOMEM;
+                                break;
+                        }
                        v9ses->flags &= ~V9FS_ACCESS_MASK;
                        if (strcmp(s, "user") == 0)
                                v9ses->flags |= V9FS_ACCESS_USER;
@@ -158,6 +172,7 @@ static void v9fs_parse_options(struct v9fs_session_info *v9ses)
                }
        }
        kfree(options);
+        return ret;
 }
 /**
@@ -173,6 +188,7 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
 {
        int retval = -EINVAL;
        struct p9_fid *fid;
+        int rc;
        v9ses->uname = __getname();
        if (!v9ses->uname)
@@ -190,8 +206,21 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
        v9ses->uid = ~0;
        v9ses->dfltuid = V9FS_DEFUID;
        v9ses->dfltgid = V9FS_DEFGID;
-        v9ses->options = kstrdup(data, GFP_KERNEL);
+        if (data) {
-        v9fs_parse_options(v9ses);
+                v9ses->options = kstrdup(data, GFP_KERNEL);
+                if (!v9ses->options) {
+                        P9_DPRINTK(P9_DEBUG_ERROR,
+                           "failed to allocate copy of option string\n");
+                        retval = -ENOMEM;
+                        goto error;
+                }
+        }
+        rc = v9fs_parse_options(v9ses);
+        if (rc < 0) {
+                retval = rc;
+                goto error;
+        }
        v9ses->clnt = p9_client_create(dev_name, v9ses->options);
@@ -233,7 +262,6 @@ struct p9_fid *v9fs_session_init(struct v9fs_session_info *v9ses,
        return fid;
 error:
-        v9fs_session_close(v9ses);
        return ERR_PTR(retval);
 }
@@ -256,9 +284,12 @@ void v9fs_session_close(struct v9fs_session_info *v9ses)
 }
 /**
- * v9fs_session_cancel - mark transport as disconnected
+ * v9fs_session_cancel - terminate a session
- *      and cancel all pending requests.
+ * @v9ses: session to terminate
+ *
+ * mark transport as disconnected and cancel all pending requests.
 */
 void v9fs_session_cancel(struct v9fs_session_info *v9ses) {
        P9_DPRINTK(P9_DEBUG_ERROR, "cancel session %p\n", v9ses);
        p9_client_disconnect(v9ses->clnt);
diff --git a/fs/9p/v9fs.h b/fs/9p/v9fs.h
index 7d3a1018db5..a7d56719299 100644
--- a/fs/9p/v9fs.h
+++ b/fs/9p/v9fs.h
@@ -21,18 +21,69 @@
 *
 */
-/*
+/**
-  * Session structure provides information for an opened session
+ * enum p9_session_flags - option flags for each 9P session
-  *
+ * @V9FS_EXTENDED: whether or not to use 9P2000.u extensions
-  */
+ * @V9FS_ACCESS_SINGLE: only the mounting user can access the hierarchy
+ * @V9FS_ACCESS_USER: a new attach will be issued for every user (default)
+ * @V9FS_ACCESS_ANY: use a single attach for all users
+ * @V9FS_ACCESS_MASK: bit mask of different ACCESS options
+ *
+ * Session flags reflect options selected by users at mount time
+ */
+enum p9_session_flags {
+        V9FS_EXTENDED           = 0x01,
+        V9FS_ACCESS_SINGLE      = 0x02,
+        V9FS_ACCESS_USER        = 0x04,
+        V9FS_ACCESS_ANY         = 0x06,
+        V9FS_ACCESS_MASK        = 0x06,
+};
+/* possible values of ->cache */
+/**
+ * enum p9_cache_modes - user specified cache preferences
+ * @CACHE_NONE: do not cache data, dentries, or directory contents (default)
+ * @CACHE_LOOSE: cache data, dentries, and directory contents w/no consistency
+ *
+ * eventually support loose, tight, time, session, default always none
+ */
+enum p9_cache_modes {
+        CACHE_NONE,
+        CACHE_LOOSE,
+};
+/**
+ * struct v9fs_session_info - per-instance session information
+ * @flags: session options of type &p9_session_flags
+ * @nodev: set to 1 to disable device mapping
+ * @debug: debug level
+ * @afid: authentication handle
+ * @cache: cache mode of type &p9_cache_modes
+ * @options: copy of options string given by user
+ * @uname: string user name to mount hierarchy as
+ * @aname: mount specifier for remote hierarchy
+ * @maxdata: maximum data to be sent/recvd per protocol message
+ * @dfltuid: default numeric userid to mount hierarchy as
+ * @dfltgid: default numeric groupid to mount hierarchy as
+ * @uid: if %V9FS_ACCESS_SINGLE, the numeric uid which mounted the hierarchy
+ * @clnt: reference to 9P network client instantiated for this session
+ * @debugfs_dir: reference to debugfs_dir which can be used for add'l debug
+ *
+ * This structure holds state for each session instance established during
+ * a sys_mount() .
+ *
+ * Bugs: there seems to be a lot of state which could be condensed and/or
+ * removed.
+ */
 struct v9fs_session_info {
        /* options */
-        unsigned char flags;    /* session flags */
+        unsigned char flags;
-        unsigned char nodev;    /* set to 1 if no disable device mapping */
+        unsigned char nodev;
-        unsigned short debug;   /* debug level */
+        unsigned short debug;
-        unsigned int afid;      /* authentication fid */
+        unsigned int afid;
-        unsigned int cache;     /* cache mode */
+        unsigned int cache;
        char *options;          /* copy of mount options */
        char *uname;            /* user name to mount as */
@@ -45,22 +96,6 @@ struct v9fs_session_info {
        struct dentry *debugfs_dir;
 };
-/* session flags */
-enum {
-        V9FS_EXTENDED           = 0x01, /* 9P2000.u */
-        V9FS_ACCESS_MASK        = 0x06, /* access mask */
-        V9FS_ACCESS_SINGLE      = 0x02, /* only one user can access the files */
-        V9FS_ACCESS_USER        = 0x04, /* attache per user */
-        V9FS_ACCESS_ANY         = 0x06, /* use the same attach for all users */
-};
-/* possible values of ->cache */
-/* eventually support loose, tight, time, session, default always none */
-enum {
-        CACHE_NONE,             /* default */
-        CACHE_LOOSE,            /* no consistency */
-};
 extern struct dentry *v9fs_debugfs_root;
 struct p9_fid *v9fs_session_init(struct v9fs_session_info *, const char *,
diff --git a/fs/9p/vfs_addr.c b/fs/9p/vfs_addr.c
index 6248f0e727a..97d3aed5798 100644
--- a/fs/9p/vfs_addr.c
+++ b/fs/9p/vfs_addr.c
@@ -43,7 +43,7 @@
 /**
 * v9fs_vfs_readpage - read an entire page in from 9P
 *
- * @file: file being read
+ * @filp: file being read
 * @page: structure to page
 *
 */
diff --git a/fs/9p/vfs_dir.c b/fs/9p/vfs_dir.c
index 0924d4477da..88e3787c6ea 100644
--- a/fs/9p/vfs_dir.c
+++ b/fs/9p/vfs_dir.c
@@ -60,7 +60,7 @@ static inline int dt_type(struct p9_stat *mistat)
 /**
 * v9fs_dir_readdir - read a directory
- * @filep: opened file structure
+ * @filp: opened file structure
 * @dirent: directory structure ???
 * @filldir: function to populate directory structure ???
 *
diff --git a/fs/9p/vfs_file.c b/fs/9p/vfs_file.c
index a616fff8906..0d55affe37d 100644
--- a/fs/9p/vfs_file.c
+++ b/fs/9p/vfs_file.c
@@ -90,10 +90,11 @@ int v9fs_file_open(struct inode *inode, struct file *file)
 /**
 * v9fs_file_lock - lock a file (or directory)
- * @inode: inode to be opened
+ * @filp: file to be locked
- * @file: file being opened
+ * @cmd: lock command
+ * @fl: file lock structure
 *
- * XXX - this looks like a local only lock, we should extend into 9P
+ * Bugs: this looks like a local only lock, we should extend into 9P
 *       by using open exclusive
 */
@@ -118,7 +119,7 @@ static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 /**
 * v9fs_file_read - read from a file
- * @filep: file pointer to read
+ * @filp: file pointer to read
 * @data: data buffer to read data into
 * @count: size of buffer
 * @offset: offset at which to read data
@@ -142,7 +143,7 @@ v9fs_file_read(struct file *filp, char __user * data, size_t count,
 /**
 * v9fs_file_write - write to a file
- * @filep: file pointer to write
+ * @filp: file pointer to write
 * @data: data buffer to write data from
 * @count: size of buffer
 * @offset: offset at which to write data
diff --git a/fs/9p/vfs_inode.c b/fs/9p/vfs_inode.c
index 6a28842052e..40fa807bd92 100644
--- a/fs/9p/vfs_inode.c
+++ b/fs/9p/vfs_inode.c
@@ -129,6 +129,12 @@ static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
        return res;
 }
+/**
+ * v9fs_uflags2omode- convert posix open flags to plan 9 mode bits
+ * @uflags: flags to convert
+ *
+ */
 int v9fs_uflags2omode(int uflags)
 {
        int ret;
@@ -312,6 +318,14 @@ error:
 }
 */
+/**
+ * v9fs_inode_from_fid - populate an inode by issuing a attribute request
+ * @v9ses: session information
+ * @fid: fid to issue attribute request for
+ * @sb: superblock on which to create inode
+ *
+ */
 static struct inode *
 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, struct p9_fid *fid,
        struct super_block *sb)
@@ -384,9 +398,12 @@ v9fs_open_created(struct inode *inode, struct file *file)
 /**
 * v9fs_create - Create a file
+ * @v9ses: session information
+ * @dir: directory that dentry is being created in
 * @dentry:  dentry that is being created
 * @perm: create permissions
 * @mode: open mode
+ * @extension: 9p2000.u extension string to support devices, etc.
 *
 */
 static struct p9_fid *
@@ -461,7 +478,7 @@ error:
 /**
 * v9fs_vfs_create - VFS hook to create files
- * @inode: directory inode that is being created
+ * @dir: directory inode that is being created
 * @dentry:  dentry that is being deleted
 * @mode: create permissions
 * @nd: path information
@@ -519,7 +536,7 @@ error:
 /**
 * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
- * @inode:  inode that is being unlinked
+ * @dir:  inode that is being unlinked
 * @dentry: dentry that is being unlinked
 * @mode: mode for new directory
 *
@@ -703,9 +720,9 @@ done:
 /**
 * v9fs_vfs_getattr - retrieve file metadata
- * @mnt - mount information
+ * @mnt: mount information
- * @dentry - file to get attributes on
+ * @dentry: file to get attributes on
- * @stat - metadata structure to populate
+ * @stat: metadata structure to populate
 *
 */
@@ -928,7 +945,7 @@ done:
 /**
 * v9fs_vfs_readlink - read a symlink's location
 * @dentry: dentry for symlink
- * @buf: buffer to load symlink location into
+ * @buffer: buffer to load symlink location into
 * @buflen: length of buffer
 *
 */
@@ -996,10 +1013,12 @@ static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 * v9fs_vfs_put_link - release a symlink path
 * @dentry: dentry for symlink
 * @nd: nameidata
+ * @p: unused
 *
 */
-static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
+static void
+v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
 {
        char *s = nd_get_link(nd);
@@ -1008,6 +1027,15 @@ static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void
                __putname(s);
 }
+/**
+ * v9fs_vfs_mkspecial - create a special file
+ * @dir: inode to create special file in
+ * @dentry: dentry to create
+ * @mode: mode to create special file
+ * @extension: 9p2000.u format extension string representing special file
+ *
+ */
 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
        int mode, const char *extension)
 {
@@ -1037,7 +1065,7 @@ static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
 * @dentry: dentry for symlink
 * @symname: symlink data
 *
- * See 9P2000.u RFC for more information
+ * See Also: 9P2000.u RFC for more information
 *
 */
@@ -1058,10 +1086,6 @@ v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
 *
 */
-/* XXX - lots of code dup'd from symlink and creates,
- * figure out a better reuse strategy
- */
 static int
 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
              struct dentry *dentry)
@@ -1098,7 +1122,7 @@ clunk_fid:
 * @dir: inode destination for new link
 * @dentry: dentry for file
 * @mode: mode for creation
- * @dev_t: device associated with special file
+ * @rdev: device associated with special file
 *
 */
diff --git a/fs/9p/vfs_super.c b/fs/9p/vfs_super.c
index a452ac67fc9..bf59c396049 100644
--- a/fs/9p/vfs_super.c
+++ b/fs/9p/vfs_super.c
@@ -75,6 +75,7 @@ static int v9fs_set_super(struct super_block *s, void *data)
 * v9fs_fill_super - populate superblock with info
 * @sb: superblock
 * @v9ses: session information
+ * @flags: flags propagated from v9fs_get_sb()
 *
 */
@@ -127,29 +128,26 @@ static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
        fid = v9fs_session_init(v9ses, dev_name, data);
        if (IS_ERR(fid)) {
                retval = PTR_ERR(fid);
-                fid = NULL;
+                goto close_session;
-                kfree(v9ses);
-                v9ses = NULL;
-                goto error;
        }
        st = p9_client_stat(fid);
        if (IS_ERR(st)) {
                retval = PTR_ERR(st);
-                goto error;
+                goto clunk_fid;
        }
        sb = sget(fs_type, NULL, v9fs_set_super, v9ses);
        if (IS_ERR(sb)) {
                retval = PTR_ERR(sb);
-                goto error;
+                goto free_stat;
        }
        v9fs_fill_super(sb, v9ses, flags);
        inode = v9fs_get_inode(sb, S_IFDIR | mode);
        if (IS_ERR(inode)) {
                retval = PTR_ERR(inode);
-                goto error;
+                goto release_sb;
        }
        inode->i_uid = uid;
@@ -158,7 +156,7 @@ static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
        root = d_alloc_root(inode);
        if (!root) {
                retval = -ENOMEM;
-                goto error;
+                goto release_sb;
        }
        sb->s_root = root;
@@ -169,21 +167,22 @@ static int v9fs_get_sb(struct file_system_type *fs_type, int flags,
        return simple_set_mnt(mnt, sb);
-error:
+release_sb:
-        kfree(st);
-        if (fid)
-                p9_client_clunk(fid);
-        if (v9ses) {
-                v9fs_session_close(v9ses);
-                kfree(v9ses);
-        }
        if (sb) {
                up_write(&sb->s_umount);
                deactivate_super(sb);
        }
+free_stat:
+        kfree(st);
+clunk_fid:
+        p9_client_clunk(fid);
+close_session:
+        v9fs_session_close(v9ses);
+        kfree(v9ses);
        return retval;
 }
diff --git a/fs/befs/endian.h b/fs/befs/endian.h
index e254a20869f..6cb84d896d0 100644
--- a/fs/befs/endian.h
+++ b/fs/befs/endian.h
@@ -9,7 +9,7 @@
 #ifndef LINUX_BEFS_ENDIAN
 #define LINUX_BEFS_ENDIAN
-#include <linux/byteorder/generic.h>
+#include <asm/byteorder.h>
 static inline u64
 fs64_to_cpu(const struct super_block *sb, fs64 n)
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index b25707fee2c..0fa95b198e6 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -256,7 +256,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 +268,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))
@@ -1900,7 +1900,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 +2034,9 @@ end_coredump:
        set_fs(fs);
 cleanup:
-        kfree(elf);
        free_note_info(&info);
+        kfree(elf);
+out:
        return has_dumped;
 }
diff --git a/fs/cifs/cifspdu.h b/fs/cifs/cifspdu.h
index a0d26b540d4..c43bf4b7a55 100644
--- a/fs/cifs/cifspdu.h
+++ b/fs/cifs/cifspdu.h
@@ -340,6 +340,7 @@
 #define OPEN_NO_RECALL          0x00400000
 #define OPEN_FREE_SPACE_QUERY   0x00800000      /* should be zero */
 #define CREATE_OPTIONS_MASK     0x007FFFFF
+#define CREATE_OPTION_READONLY  0x10000000
 #define CREATE_OPTION_SPECIAL   0x20000000   /* system. NB not sent over wire */
 /* ImpersonationLevel flags */
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index cfd9750852b..95fbba4ea7d 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -1224,11 +1224,8 @@ OldOpenRetry:
        else /* BB FIXME BB */
                pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
-        /* if ((omode & S_IWUGO) == 0)
+        if (create_options & CREATE_OPTION_READONLY)
-                pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
+                pSMB->FileAttributes |= cpu_to_le16(ATTR_READONLY);
-        /*  Above line causes problems due to vfs splitting create into two
-            pieces - need to set mode after file created not while it is
-            being created */
        /* BB FIXME BB */
 /*      pSMB->CreateOptions = cpu_to_le32(create_options &
@@ -1331,17 +1328,16 @@ openRetry:
                pSMB->FileAttributes = cpu_to_le32(ATTR_SYSTEM);
        else
                pSMB->FileAttributes = cpu_to_le32(ATTR_NORMAL);
        /* XP does not handle ATTR_POSIX_SEMANTICS */
        /* but it helps speed up case sensitive checks for other
        servers such as Samba */
        if (tcon->ses->capabilities & CAP_UNIX)
                pSMB->FileAttributes |= cpu_to_le32(ATTR_POSIX_SEMANTICS);
-        /* if ((omode & S_IWUGO) == 0)
+        if (create_options & CREATE_OPTION_READONLY)
-                pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
+                pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);
-        /*  Above line causes problems due to vfs splitting create into two
-                pieces - need to set mode after file created not while it is
-                being created */
        pSMB->ShareAccess = cpu_to_le32(FILE_SHARE_ALL);
        pSMB->CreateDisposition = cpu_to_le32(openDisposition);
        pSMB->CreateOptions = cpu_to_le32(create_options & CREATE_OPTIONS_MASK);
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 791ca5c1a11..f428bf3bf1a 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -348,7 +348,6 @@ cifs_demultiplex_thread(struct TCP_Server_Info *server)
        int reconnect;
        current->flags |= PF_MEMALLOC;
-        server->tsk = current;  /* save process info to wake at shutdown */
        cFYI(1, ("Demultiplex PID: %d", task_pid_nr(current)));
        write_lock(&GlobalSMBSeslock);
        atomic_inc(&tcpSesAllocCount);
@@ -651,10 +650,20 @@ multi_t2_fnd:
        spin_lock(&GlobalMid_Lock);
        server->tcpStatus = CifsExiting;
-        server->tsk = NULL;
+        spin_unlock(&GlobalMid_Lock);
+        /* don't exit until kthread_stop is called */
+        set_current_state(TASK_UNINTERRUPTIBLE);
+        while (!kthread_should_stop()) {
+                schedule();
+                set_current_state(TASK_UNINTERRUPTIBLE);
+        }
+        set_current_state(TASK_RUNNING);
        /* check if we have blocked requests that need to free */
        /* Note that cifs_max_pending is normally 50, but
        can be set at module install time to as little as two */
+        spin_lock(&GlobalMid_Lock);
        if (atomic_read(&server->inFlight) >= cifs_max_pending)
                atomic_set(&server->inFlight, cifs_max_pending - 1);
        /* We do not want to set the max_pending too low or we
@@ -1318,42 +1327,43 @@ cifs_parse_mount_options(char *options, const char *devname,
 static struct cifsSesInfo *
 cifs_find_tcp_session(struct in_addr *target_ip_addr,
-                struct in6_addr *target_ip6_addr,
+                      struct in6_addr *target_ip6_addr,
-                 char *userName, struct TCP_Server_Info **psrvTcp)
+                      char *userName, struct TCP_Server_Info **psrvTcp)
 {
        struct list_head *tmp;
        struct cifsSesInfo *ses;
        *psrvTcp = NULL;
-        read_lock(&GlobalSMBSeslock);
+        read_lock(&GlobalSMBSeslock);
        list_for_each(tmp, &GlobalSMBSessionList) {
                ses = list_entry(tmp, struct cifsSesInfo, cifsSessionList);
-                if (ses->server) {
+                if (!ses->server)
-                        if ((target_ip_addr &&
+                        continue;
-                                (ses->server->addr.sockAddr.sin_addr.s_addr
-                                  == target_ip_addr->s_addr)) || (target_ip6_addr
+                if (target_ip_addr &&
-                                && memcmp(&ses->server->addr.sockAddr6.sin6_addr,
+                    ses->server->addr.sockAddr.sin_addr.s_addr != target_ip_addr->s_addr)
-                                        target_ip6_addr, sizeof(*target_ip6_addr)))) {
+                                continue;
-                                /* BB lock server and tcp session and increment
+                else if (target_ip6_addr &&
-                                      use count here?? */
+                         memcmp(&ses->server->addr.sockAddr6.sin6_addr,
+                                target_ip6_addr, sizeof(*target_ip6_addr)))
-                                /* found a match on the TCP session */
+                                continue;
-                                *psrvTcp = ses->server;
+                /* BB lock server and tcp session; increment use count here?? */
-                                /* BB check if reconnection needed */
+                /* found a match on the TCP session */
-                                if (strncmp
+                *psrvTcp = ses->server;
-                                    (ses->userName, userName,
-                                     MAX_USERNAME_SIZE) == 0){
+                /* BB check if reconnection needed */
-                                        read_unlock(&GlobalSMBSeslock);
+                if (strncmp(ses->userName, userName, MAX_USERNAME_SIZE) == 0) {
-                                        /* Found exact match on both TCP and
+                        read_unlock(&GlobalSMBSeslock);
-                                           SMB sessions */
+                        /* Found exact match on both TCP and
-                                        return ses;
+                           SMB sessions */
-                                }
+                        return ses;
-                        }
                }
                /* else tcp and smb sessions need reconnection */
        }
        read_unlock(&GlobalSMBSeslock);
        return NULL;
 }
@@ -2186,15 +2196,12 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                        srvTcp->tcpStatus = CifsExiting;
                        spin_unlock(&GlobalMid_Lock);
                        if (srvTcp->tsk) {
-                                struct task_struct *tsk;
                                /* If we could verify that kthread_stop would
                                   always wake up processes blocked in
                                   tcp in recv_mesg then we could remove the
                                   send_sig call */
                                force_sig(SIGKILL, srvTcp->tsk);
-                                tsk = srvTcp->tsk;
+                                kthread_stop(srvTcp->tsk);
-                                if (tsk)
-                                        kthread_stop(tsk);
                        }
                }
                 /* If find_unc succeeded then rc == 0 so we can not end */
@@ -2210,23 +2217,17 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                                        if ((temp_rc == -ESHUTDOWN) &&
                                            (pSesInfo->server) &&
                                            (pSesInfo->server->tsk)) {
-                                                struct task_struct *tsk;
                                                force_sig(SIGKILL,
                                                        pSesInfo->server->tsk);
-                                                tsk = pSesInfo->server->tsk;
+                                                kthread_stop(pSesInfo->server->tsk);
-                                                if (tsk)
-                                                        kthread_stop(tsk);
                                        }
                                } else {
                                        cFYI(1, ("No session or bad tcon"));
                                        if ((pSesInfo->server) &&
                                            (pSesInfo->server->tsk)) {
-                                                struct task_struct *tsk;
                                                force_sig(SIGKILL,
                                                        pSesInfo->server->tsk);
-                                                tsk = pSesInfo->server->tsk;
+                                                kthread_stop(pSesInfo->server->tsk);
-                                                if (tsk)
-                                                        kthread_stop(tsk);
                                        }
                                }
                                sesInfoFree(pSesInfo);
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 6ed775986be..e4e0078a052 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -119,6 +119,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
 {
        int rc = -ENOENT;
        int xid;
+        int create_options = CREATE_NOT_DIR;
        int oplock = 0;
        int desiredAccess = GENERIC_READ | GENERIC_WRITE;
        __u16 fileHandle;
@@ -176,9 +177,19 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                FreeXid(xid);
                return -ENOMEM;
        }
+        mode &= ~current->fs->umask;
+        /*
+         * if we're not using unix extensions, see if we need to set
+         * ATTR_READONLY on the create call
+         */
+        if (!pTcon->unix_ext && (mode & S_IWUGO) == 0)
+                create_options |= CREATE_OPTION_READONLY;
        if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
                rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
-                         desiredAccess, CREATE_NOT_DIR,
+                         desiredAccess, create_options,
                         &fileHandle, &oplock, buf, cifs_sb->local_nls,
                         cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
        else
@@ -187,7 +198,7 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
        if (rc == -EIO) {
                /* old server, retry the open legacy style */
                rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
-                        desiredAccess, CREATE_NOT_DIR,
+                        desiredAccess, create_options,
                        &fileHandle, &oplock, buf, cifs_sb->local_nls,
                        cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MAP_SPECIAL_CHR);
        }
@@ -197,7 +208,6 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                /* If Open reported that we actually created a file
                then we now have to set the mode if possible */
                if ((pTcon->unix_ext) && (oplock & CIFS_CREATE_ACTION)) {
-                        mode &= ~current->fs->umask;
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
                                CIFSSMBUnixSetPerms(xid, pTcon, full_path, mode,
                                        (__u64)current->fsuid,
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index 0d9d2e6d7af..fcbdbb6ad7b 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -974,8 +974,8 @@ mkdir_get_info:
                  * failed to get it from the server or was set bogus */
                if ((direntry->d_inode) && (direntry->d_inode->i_nlink < 2))
                                direntry->d_inode->i_nlink = 2;
+                mode &= ~current->fs->umask;
                if (pTcon->unix_ext) {
-                        mode &= ~current->fs->umask;
                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SET_UID) {
                                CIFSSMBUnixSetPerms(xid, pTcon, full_path,
                                                    mode,
@@ -994,9 +994,16 @@ mkdir_get_info:
                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
                        }
                } else {
-                        /* BB to be implemented via Windows secrty descriptors
+                        if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) &&
-                           eg CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
+                            (mode & S_IWUGO) == 0) {
-                                                 -1, -1, local_nls); */
+                                FILE_BASIC_INFO pInfo;
+                                memset(&pInfo, 0, sizeof(pInfo));
+                                pInfo.Attributes = cpu_to_le32(ATTR_READONLY);
+                                CIFSSMBSetTimes(xid, pTcon, full_path,
+                                                &pInfo, cifs_sb->local_nls,
+                                                cifs_sb->mnt_cifs_flags &
+                                                CIFS_MOUNT_MAP_SPECIAL_CHR);
+                        }
                        if (direntry->d_inode) {
                                direntry->d_inode->i_mode = mode;
                                direntry->d_inode->i_mode |= S_IFDIR;
@@ -1408,18 +1415,19 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
        __u64 uid = 0xFFFFFFFFFFFFFFFFULL;
        __u64 gid = 0xFFFFFFFFFFFFFFFFULL;
        struct cifsInodeInfo *cifsInode;
+        struct inode *inode = direntry->d_inode;
        xid = GetXid();
        cFYI(1, ("setattr on file %s attrs->iavalid 0x%x",
                 direntry->d_name.name, attrs->ia_valid));
-        cifs_sb = CIFS_SB(direntry->d_inode->i_sb);
+        cifs_sb = CIFS_SB(inode->i_sb);
        pTcon = cifs_sb->tcon;
        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_PERM) == 0) {
                /* check if we have permission to change attrs */
-                rc = inode_change_ok(direntry->d_inode, attrs);
+                rc = inode_change_ok(inode, attrs);
                if (rc < 0) {
                        FreeXid(xid);
                        return rc;
@@ -1432,7 +1440,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                FreeXid(xid);
                return -ENOMEM;
        }
-        cifsInode = CIFS_I(direntry->d_inode);
+        cifsInode = CIFS_I(inode);
        if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
                /*
@@ -1443,9 +1451,9 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                   will be truncated anyway? Also, should we error out here if
                   the flush returns error?
                 */
-                rc = filemap_write_and_wait(direntry->d_inode->i_mapping);
+                rc = filemap_write_and_wait(inode->i_mapping);
                if (rc != 0) {
-                        CIFS_I(direntry->d_inode)->write_behind_rc = rc;
+                        cifsInode->write_behind_rc = rc;
                        rc = 0;
                }
        }
@@ -1521,9 +1529,8 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                   */
                if (rc == 0) {
-                        rc = cifs_vmtruncate(direntry->d_inode, attrs->ia_size);
+                        rc = cifs_vmtruncate(inode, attrs->ia_size);
-                        cifs_truncate_page(direntry->d_inode->i_mapping,
+                        cifs_truncate_page(inode->i_mapping, inode->i_size);
-                                           direntry->d_inode->i_size);
                } else
                        goto cifs_setattr_exit;
        }
@@ -1557,7 +1564,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                rc = 0;
 #ifdef CONFIG_CIFS_EXPERIMENTAL
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL)
-                        rc = mode_to_acl(direntry->d_inode, full_path, mode);
+                        rc = mode_to_acl(inode, full_path, mode);
                else if ((mode & S_IWUGO) == 0) {
 #else
                if ((mode & S_IWUGO) == 0) {
@@ -1665,7 +1672,7 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
        /* do not need local check to inode_check_ok since the server does
           that */
        if (!rc)
-                rc = inode_setattr(direntry->d_inode, attrs);
+                rc = inode_setattr(inode, attrs);
 cifs_setattr_exit:
        kfree(full_path);
        FreeXid(xid);
diff --git a/fs/compat.c b/fs/compat.c
index 332a869d2c5..ed43e17a5dc 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/dlm/lowcomms.c b/fs/dlm/lowcomms.c
index 7c1e5e5cccd..637018c891e 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 714593621f4..18bda83cc89 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 d6d6e370f89..78878c5781c 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/dquot.c b/fs/dquot.c
index dfba1623ccc..5ac77da1995 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -1491,6 +1491,16 @@ int vfs_quota_off(struct super_block *sb, int type, int remount)
        /* We need to serialize quota_off() for device */
        mutex_lock(&dqopt->dqonoff_mutex);
+        /*
+         * Skip everything if there's nothing to do. We have to do this because
+         * sometimes we are called when fill_super() failed and calling
+         * sync_fs() in such cases does no good.
+         */
+        if (!sb_any_quota_enabled(sb) && !sb_any_quota_suspended(sb)) {
+                mutex_unlock(&dqopt->dqonoff_mutex);
+                return 0;
+        }
        for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
                toputinode[cnt] = NULL;
                if (type != -1 && cnt != type)
diff --git a/fs/ecryptfs/inode.c b/fs/ecryptfs/inode.c
index 0a1397335a8..c92cc1c00aa 100644
--- a/fs/ecryptfs/inode.c
+++ b/fs/ecryptfs/inode.c
@@ -37,17 +37,11 @@ static struct dentry *lock_parent(struct dentry *dentry)
 {
        struct dentry *dir;
-        dir = dget(dentry->d_parent);
+        dir = dget_parent(dentry);
        mutex_lock_nested(&(dir->d_inode->i_mutex), I_MUTEX_PARENT);
        return dir;
 }
-static void unlock_parent(struct dentry *dentry)
-{
-        mutex_unlock(&(dentry->d_parent->d_inode->i_mutex));
-        dput(dentry->d_parent);
-}
 static void unlock_dir(struct dentry *dir)
 {
        mutex_unlock(&dir->d_inode->i_mutex);
@@ -426,8 +420,9 @@ static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
        int rc = 0;
        struct dentry *lower_dentry = ecryptfs_dentry_to_lower(dentry);
        struct inode *lower_dir_inode = ecryptfs_inode_to_lower(dir);
+        struct dentry *lower_dir_dentry;
-        lock_parent(lower_dentry);
+        lower_dir_dentry = lock_parent(lower_dentry);
        rc = vfs_unlink(lower_dir_inode, lower_dentry);
        if (rc) {
                printk(KERN_ERR "Error in vfs_unlink; rc = [%d]\n", rc);
@@ -439,7 +434,7 @@ static int ecryptfs_unlink(struct inode *dir, struct dentry *dentry)
        dentry->d_inode->i_ctime = dir->i_ctime;
        d_drop(dentry);
 out_unlock:
-        unlock_parent(lower_dentry);
+        unlock_dir(lower_dir_dentry);
        return rc;
 }
diff --git a/fs/ecryptfs/miscdev.c b/fs/ecryptfs/miscdev.c
index 788995efd1d..6560da1a58c 100644
--- a/fs/ecryptfs/miscdev.c
+++ b/fs/ecryptfs/miscdev.c
@@ -257,12 +257,14 @@ ecryptfs_miscdev_read(struct file *file, char __user *buf, size_t count,
        mutex_lock(&daemon->mux);
        if (daemon->flags & ECRYPTFS_DAEMON_ZOMBIE) {
                rc = 0;
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
                printk(KERN_WARNING "%s: Attempt to read from zombified "
                       "daemon\n", __func__);
                goto out_unlock_daemon;
        }
        if (daemon->flags & ECRYPTFS_DAEMON_IN_READ) {
                rc = 0;
+                mutex_unlock(&ecryptfs_daemon_hash_mux);
                goto out_unlock_daemon;
        }
        /* This daemon will not go away so long as this flag is set */
diff --git a/fs/exec.c b/fs/exec.c
index aeaa9791d8b..3c2ba7ce11d 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -736,7 +736,7 @@ static int exec_mmap(struct mm_struct *mm)
        tsk->active_mm = mm;
        activate_mm(active_mm, mm);
        task_unlock(tsk);
-        mm_update_next_owner(mm);
+        mm_update_next_owner(old_mm);
        arch_pick_mmap_layout(mm);
        if (old_mm) {
                up_read(&old_mm->mmap_sem);
@@ -1251,6 +1251,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 +1326,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 +1348,7 @@ out_file:
                fput(bprm->file);
        }
 out_kfree:
-        kfree(bprm);
+        free_bprm(bprm);
 out_files:
        if (displaced)
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index d4a4f0e9ff6..175414ac221 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -1000,6 +1000,11 @@ ext3_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
                        i.value = NULL;
                        error = ext3_xattr_block_set(handle, inode, &i, &bs);
                } else if (error == -ENOSPC) {
+                        if (EXT3_I(inode)->i_file_acl && !bs.s.base) {
+                                error = ext3_xattr_block_find(inode, &i, &bs);
+                                if (error)
+                                        goto cleanup;
+                        }
                        error = ext3_xattr_block_set(handle, inode, &i, &bs);
                        if (error)
                                goto cleanup;
diff --git a/fs/ext4/balloc.c b/fs/ext4/balloc.c
index da994374ec3..30494c5da84 100644
--- a/fs/ext4/balloc.c
+++ b/fs/ext4/balloc.c
@@ -287,11 +287,11 @@ read_block_bitmap(struct super_block *sb, ext4_group_t block_group)
                            (int)block_group, (unsigned long long)bitmap_blk);
                return NULL;
        }
-        if (!ext4_valid_block_bitmap(sb, desc, block_group, bh)) {
+        ext4_valid_block_bitmap(sb, desc, block_group, bh);
-                put_bh(bh);
+        /*
-                return NULL;
+         * file system mounted not to panic on error,
-        }
+         * continue with corrupt bitmap
+         */
        return bh;
 }
 /*
@@ -1770,7 +1770,12 @@ allocated:
                            "Allocating block in system zone - "
                            "blocks from %llu, length %lu",
                             ret_block, num);
-                goto out;
+                /*
+                 * claim_block marked the blocks we allocated
+                 * as in use. So we may want to selectively
+                 * mark some of the blocks as free
+                 */
+                goto retry_alloc;
        }
        performed_allocation = 1;
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index fbec2ef9379..873ad9b3418 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -2639,8 +2639,7 @@ static int ext4_mb_init_per_dev_proc(struct super_block *sb)
        struct proc_dir_entry *proc;
        char devname[64];
-        snprintf(devname, sizeof(devname) - 1, "%s",
+        bdevname(sb->s_bdev, devname);
-                bdevname(sb->s_bdev, devname));
        sbi->s_mb_proc = proc_mkdir(devname, proc_root_ext4);
        MB_PROC_HANDLER(EXT4_MB_STATS_NAME, stats);
@@ -2674,8 +2673,7 @@ static int ext4_mb_destroy_per_dev_proc(struct super_block *sb)
        if (sbi->s_mb_proc == NULL)
                return -EINVAL;
-        snprintf(devname, sizeof(devname) - 1, "%s",
+        bdevname(sb->s_bdev, devname);
-                bdevname(sb->s_bdev, devname));
        remove_proc_entry(EXT4_MB_GROUP_PREALLOC, sbi->s_mb_proc);
        remove_proc_entry(EXT4_MB_STREAM_REQ, sbi->s_mb_proc);
        remove_proc_entry(EXT4_MB_ORDER2_REQ, sbi->s_mb_proc);
@@ -2738,7 +2736,7 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
        struct ext4_sb_info *sbi;
        struct super_block *sb;
        ext4_fsblk_t block;
-        int err;
+        int err, len;
        BUG_ON(ac->ac_status != AC_STATUS_FOUND);
        BUG_ON(ac->ac_b_ex.fe_len <= 0);
@@ -2772,14 +2770,27 @@ ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
                + ac->ac_b_ex.fe_start
                + le32_to_cpu(es->s_first_data_block);
-        if (block == ext4_block_bitmap(sb, gdp) ||
+        len = ac->ac_b_ex.fe_len;
-                        block == ext4_inode_bitmap(sb, gdp) ||
+        if (in_range(ext4_block_bitmap(sb, gdp), block, len) ||
-                        in_range(block, ext4_inode_table(sb, gdp),
+            in_range(ext4_inode_bitmap(sb, gdp), block, len) ||
-                                EXT4_SB(sb)->s_itb_per_group)) {
+            in_range(block, ext4_inode_table(sb, gdp),
+                     EXT4_SB(sb)->s_itb_per_group) ||
+            in_range(block + len - 1, ext4_inode_table(sb, gdp),
+                     EXT4_SB(sb)->s_itb_per_group)) {
                ext4_error(sb, __func__,
                           "Allocating block in system zone - block = %llu",
                           block);
+                /* File system mounted not to panic on error
+                 * Fix the bitmap and repeat the block allocation
+                 * We leak some of the blocks here.
+                 */
+                mb_set_bits(sb_bgl_lock(sbi, ac->ac_b_ex.fe_group),
+                                bitmap_bh->b_data, ac->ac_b_ex.fe_start,
+                                ac->ac_b_ex.fe_len);
+                err = ext4_journal_dirty_metadata(handle, bitmap_bh);
+                if (!err)
+                        err = -EAGAIN;
+                goto out_err;
        }
 #ifdef AGGRESSIVE_CHECK
        {
@@ -2882,12 +2893,11 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac,
        if (size < i_size_read(ac->ac_inode))
                size = i_size_read(ac->ac_inode);
-        /* max available blocks in a free group */
+        /* max size of free chunks */
-        max = EXT4_BLOCKS_PER_GROUP(ac->ac_sb) - 1 - 1 -
+        max = 2 << bsbits;
-                                EXT4_SB(ac->ac_sb)->s_itb_per_group;
-#define NRL_CHECK_SIZE(req, size, max,bits)     \
+#define NRL_CHECK_SIZE(req, size, max, chunk_size)      \
-                (req <= (size) || max <= ((size) >> bits))
+                (req <= (size) || max <= (chunk_size))
        /* first, try to predict filesize */
        /* XXX: should this table be tunable? */
@@ -2906,16 +2916,16 @@ ext4_mb_normalize_request(struct ext4_allocation_context *ac,
                size = 512 * 1024;
        } else if (size <= 1024 * 1024) {
                size = 1024 * 1024;
-        } else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, bsbits)) {
+        } else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, 2 * 1024)) {
                start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
-                                                (20 - bsbits)) << 20;
+                                                (21 - bsbits)) << 21;
-                size = 1024 * 1024;
+                size = 2 * 1024 * 1024;
-        } else if (NRL_CHECK_SIZE(size, 8 * 1024 * 1024, max, bsbits)) {
+        } else if (NRL_CHECK_SIZE(size, 8 * 1024 * 1024, max, 4 * 1024)) {
                start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
                                                        (22 - bsbits)) << 22;
                size = 4 * 1024 * 1024;
        } else if (NRL_CHECK_SIZE(ac->ac_o_ex.fe_len,
-                                        (8<<20)>>bsbits, max, bsbits)) {
+                                        (8<<20)>>bsbits, max, 8 * 1024)) {
                start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
                                                        (23 - bsbits)) << 23;
                size = 8 * 1024 * 1024;
@@ -4035,7 +4045,6 @@ ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
                ac->ac_op = EXT4_MB_HISTORY_ALLOC;
                ext4_mb_normalize_request(ac, ar);
 repeat:
                /* allocate space in core */
                ext4_mb_regular_allocator(ac);
@@ -4049,10 +4058,21 @@ repeat:
        }
        if (likely(ac->ac_status == AC_STATUS_FOUND)) {
-                ext4_mb_mark_diskspace_used(ac, handle);
+                *errp = ext4_mb_mark_diskspace_used(ac, handle);
-                *errp = 0;
+                if (*errp ==  -EAGAIN) {
-                block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
+                        ac->ac_b_ex.fe_group = 0;
-                ar->len = ac->ac_b_ex.fe_len;
+                        ac->ac_b_ex.fe_start = 0;
+                        ac->ac_b_ex.fe_len = 0;
+                        ac->ac_status = AC_STATUS_CONTINUE;
+                        goto repeat;
+                } else if (*errp) {
+                        ac->ac_b_ex.fe_len = 0;
+                        ar->len = 0;
+                        ext4_mb_show_ac(ac);
+                } else {
+                        block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
+                        ar->len = ac->ac_b_ex.fe_len;
+                }
        } else {
                freed  = ext4_mb_discard_preallocations(sb, ac->ac_o_ex.fe_len);
                if (freed)
@@ -4239,6 +4259,8 @@ do_more:
                ext4_error(sb, __func__,
                           "Freeing blocks in system zone - "
                           "Block = %lu, count = %lu", block, count);
+                /* err = 0. ext4_std_error should be a no op */
+                goto error_return;
        }
        BUFFER_TRACE(bitmap_bh, "getting write access");
diff --git a/fs/ext4/super.c b/fs/ext4/super.c
index 52dd0679a4e..09d9359c805 100644
--- a/fs/ext4/super.c
+++ b/fs/ext4/super.c
@@ -979,7 +979,7 @@ static int parse_options (char *options, struct super_block *sb,
        int data_opt = 0;
        int option;
 #ifdef CONFIG_QUOTA
-        int qtype;
+        int qtype, qfmt;
        char *qname;
 #endif
@@ -1162,9 +1162,11 @@ static int parse_options (char *options, struct super_block *sb,
                case Opt_grpjquota:
                        qtype = GRPQUOTA;
 set_qf_name:
-                        if (sb_any_quota_enabled(sb)) {
+                        if ((sb_any_quota_enabled(sb) ||
+                             sb_any_quota_suspended(sb)) &&
+                            !sbi->s_qf_names[qtype]) {
                                printk(KERN_ERR
-                                        "EXT4-fs: Cannot change journalled "
+                                        "EXT4-fs: Cannot change journaled "
                                        "quota options when quota turned on.\n");
                                return 0;
                        }
@@ -1200,9 +1202,11 @@ set_qf_name:
                case Opt_offgrpjquota:
                        qtype = GRPQUOTA;
 clear_qf_name:
-                        if (sb_any_quota_enabled(sb)) {
+                        if ((sb_any_quota_enabled(sb) ||
+                             sb_any_quota_suspended(sb)) &&
+                            sbi->s_qf_names[qtype]) {
                                printk(KERN_ERR "EXT4-fs: Cannot change "
-                                        "journalled quota options when "
+                                        "journaled quota options when "
                                        "quota turned on.\n");
                                return 0;
                        }
@@ -1213,10 +1217,20 @@ clear_qf_name:
                        sbi->s_qf_names[qtype] = NULL;
                        break;
                case Opt_jqfmt_vfsold:
-                        sbi->s_jquota_fmt = QFMT_VFS_OLD;
+                        qfmt = QFMT_VFS_OLD;
-                        break;
+                        goto set_qf_format;
                case Opt_jqfmt_vfsv0:
-                        sbi->s_jquota_fmt = QFMT_VFS_V0;
+                        qfmt = QFMT_VFS_V0;
+set_qf_format:
+                        if ((sb_any_quota_enabled(sb) ||
+                             sb_any_quota_suspended(sb)) &&
+                            sbi->s_jquota_fmt != qfmt) {
+                                printk(KERN_ERR "EXT4-fs: Cannot change "
+                                        "journaled quota options when "
+                                        "quota turned on.\n");
+                                return 0;
+                        }
+                        sbi->s_jquota_fmt = qfmt;
                        break;
                case Opt_quota:
                case Opt_usrquota:
@@ -1241,6 +1255,9 @@ clear_qf_name:
                case Opt_quota:
                case Opt_usrquota:
                case Opt_grpquota:
+                        printk(KERN_ERR
+                                "EXT4-fs: quota options not supported.\n");
+                        break;
                case Opt_usrjquota:
                case Opt_grpjquota:
                case Opt_offusrjquota:
@@ -1248,7 +1265,7 @@ clear_qf_name:
                case Opt_jqfmt_vfsold:
                case Opt_jqfmt_vfsv0:
                        printk(KERN_ERR
-                                "EXT4-fs: journalled quota options not "
+                                "EXT4-fs: journaled quota options not "
                                "supported.\n");
                        break;
                case Opt_noquota:
@@ -1333,14 +1350,14 @@ clear_qf_name:
                }
                if (!sbi->s_jquota_fmt) {
-                        printk(KERN_ERR "EXT4-fs: journalled quota format "
+                        printk(KERN_ERR "EXT4-fs: journaled quota format "
                                        "not specified.\n");
                        return 0;
                }
        } else {
                if (sbi->s_jquota_fmt) {
-                        printk(KERN_ERR "EXT4-fs: journalled quota format "
+                        printk(KERN_ERR "EXT4-fs: journaled quota format "
-                                        "specified with no journalling "
+                                        "specified with no journaling "
                                        "enabled.\n");
                        return 0;
                }
@@ -1581,7 +1598,7 @@ static void ext4_orphan_cleanup (struct super_block * sb,
                        int ret = ext4_quota_on_mount(sb, i);
                        if (ret < 0)
                                printk(KERN_ERR
-                                        "EXT4-fs: Cannot turn on journalled "
+                                        "EXT4-fs: Cannot turn on journaled "
                                        "quota: error %d\n", ret);
                }
        }
@@ -3106,7 +3123,7 @@ static int ext4_release_dquot(struct dquot *dquot)
 static int ext4_mark_dquot_dirty(struct dquot *dquot)
 {
-        /* Are we journalling quotas? */
+        /* Are we journaling quotas? */
        if (EXT4_SB(dquot->dq_sb)->s_qf_names[USRQUOTA] ||
            EXT4_SB(dquot->dq_sb)->s_qf_names[GRPQUOTA]) {
                dquot_mark_dquot_dirty(dquot);
@@ -3153,23 +3170,42 @@ static int ext4_quota_on(struct super_block *sb, int type, int format_id,
        if (!test_opt(sb, QUOTA))
                return -EINVAL;
-        /* Not journalling quota? */
+        /* When remounting, no checks are needed and in fact, path is NULL */
-        if ((!EXT4_SB(sb)->s_qf_names[USRQUOTA] &&
+        if (remount)
-            !EXT4_SB(sb)->s_qf_names[GRPQUOTA]) || remount)
                return vfs_quota_on(sb, type, format_id, path, remount);
        err = path_lookup(path, LOOKUP_FOLLOW, &nd);
        if (err)
                return err;
        /* Quotafile not on the same filesystem? */
        if (nd.path.mnt->mnt_sb != sb) {
                path_put(&nd.path);
                return -EXDEV;
        }
-        /* Quotafile not of fs root? */
+        /* Journaling quota? */
-        if (nd.path.dentry->d_parent->d_inode != sb->s_root->d_inode)
+        if (EXT4_SB(sb)->s_qf_names[type]) {
-                printk(KERN_WARNING
+                /* Quotafile not of fs root? */
-                        "EXT4-fs: Quota file not on filesystem root. "
+                if (nd.path.dentry->d_parent->d_inode != sb->s_root->d_inode)
-                        "Journalled quota will not work.\n");
+                        printk(KERN_WARNING
+                                "EXT4-fs: Quota file not on filesystem root. "
+                                "Journaled quota will not work.\n");
+        }
+        /*
+         * When we journal data on quota file, we have to flush journal to see
+         * all updates to the file when we bypass pagecache...
+         */
+        if (ext4_should_journal_data(nd.path.dentry->d_inode)) {
+                /*
+                 * We don't need to lock updates but journal_flush() could
+                 * otherwise be livelocked...
+                 */
+                jbd2_journal_lock_updates(EXT4_SB(sb)->s_journal);
+                jbd2_journal_flush(EXT4_SB(sb)->s_journal);
+                jbd2_journal_unlock_updates(EXT4_SB(sb)->s_journal);
+        }
        path_put(&nd.path);
        return vfs_quota_on(sb, type, format_id, path, remount);
 }
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index 3fbc2c6c3d0..ff08633f398 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -1009,6 +1009,11 @@ ext4_xattr_set_handle(handle_t *handle, struct inode *inode, int name_index,
                        i.value = NULL;
                        error = ext4_xattr_block_set(handle, inode, &i, &bs);
                } else if (error == -ENOSPC) {
+                        if (EXT4_I(inode)->i_file_acl && !bs.s.base) {
+                                error = ext4_xattr_block_find(inode, &i, &bs);
+                                if (error)
+                                        goto cleanup;
+                        }
                        error = ext4_xattr_block_set(handle, inode, &i, &bs);
                        if (error)
                                goto cleanup;
diff --git a/fs/file.c b/fs/file.c
index 4c6f0ea12c4..7b3887e054d 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/file.c b/fs/fuse/file.c
index f28cf8b46f8..8092f0d9fd1 100644
--- a/fs/fuse/file.c
+++ b/fs/fuse/file.c
@@ -804,6 +804,8 @@ static ssize_t fuse_fill_write_pages(struct fuse_req *req,
                if (offset == PAGE_CACHE_SIZE)
                        offset = 0;
+                if (!fc->big_writes)
+                        break;
        } while (iov_iter_count(ii) && count < fc->max_write &&
                 req->num_pages < FUSE_MAX_PAGES_PER_REQ && offset == 0);
diff --git a/fs/fuse/fuse_i.h b/fs/fuse/fuse_i.h
index dadffa21a20..bae948657c4 100644
--- a/fs/fuse/fuse_i.h
+++ b/fs/fuse/fuse_i.h
@@ -404,6 +404,9 @@ struct fuse_conn {
        /** Is bmap not implemented by fs? */
        unsigned no_bmap : 1;
+        /** Do multi-page cached writes */
+        unsigned big_writes : 1;
        /** The number of requests waiting for completion */
        atomic_t num_waiting;
diff --git a/fs/fuse/inode.c b/fs/fuse/inode.c
index 79b61587383..fb77e096213 100644
--- a/fs/fuse/inode.c
+++ b/fs/fuse/inode.c
@@ -576,6 +576,8 @@ static void process_init_reply(struct fuse_conn *fc, struct fuse_req *req)
                                fc->no_lock = 1;
                        if (arg->flags & FUSE_ATOMIC_O_TRUNC)
                                fc->atomic_o_trunc = 1;
+                        if (arg->flags & FUSE_BIG_WRITES)
+                                fc->big_writes = 1;
                } else {
                        ra_pages = fc->max_read / PAGE_CACHE_SIZE;
                        fc->no_lock = 1;
@@ -599,7 +601,8 @@ static void fuse_send_init(struct fuse_conn *fc, struct fuse_req *req)
        arg->major = FUSE_KERNEL_VERSION;
        arg->minor = FUSE_KERNEL_MINOR_VERSION;
        arg->max_readahead = fc->bdi.ra_pages * PAGE_CACHE_SIZE;
-        arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC;
+        arg->flags |= FUSE_ASYNC_READ | FUSE_POSIX_LOCKS | FUSE_ATOMIC_O_TRUNC |
+                FUSE_BIG_WRITES;
        req->in.h.opcode = FUSE_INIT;
        req->in.numargs = 1;
        req->in.args[0].size = sizeof(*arg);
diff --git a/fs/hfsplus/inode.c b/fs/hfsplus/inode.c
index d53b2af91c2..67e1c8b467c 100644
--- a/fs/hfsplus/inode.c
+++ b/fs/hfsplus/inode.c
@@ -65,6 +65,8 @@ static int hfsplus_releasepage(struct page *page, gfp_t mask)
                BUG();
                return 0;
        }
+        if (!tree)
+                return 0;
        if (tree->node_size >= PAGE_CACHE_SIZE) {
                nidx = page->index >> (tree->node_size_shift - PAGE_CACHE_SHIFT);
                spin_lock(&tree->hash_lock);
diff --git a/fs/hppfs/Makefile b/fs/hppfs/Makefile
index 6890433f759..8a1f5034436 100644
--- a/fs/hppfs/Makefile
+++ b/fs/hppfs/Makefile
@@ -1,9 +1,9 @@
 #
-# Copyright (C) 2002, 2003 Jeff Dike (jdike@karaya.com)
+# Copyright (C) 2002 - 2008 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 # Licensed under the GPL
 #
-hppfs-objs := hppfs_kern.o
+hppfs-objs := hppfs.o
 obj-y =
-obj-$(CONFIG_HPPFS) += hppfs.o
+obj-$(CONFIG_HPPFS) += $(hppfs-objs)
diff --git a/fs/hppfs/hppfs_kern.c b/fs/hppfs/hppfs.c
index 8601d8ef3b5..65077aa90f0 100644
--- a/fs/hppfs/hppfs_kern.c
+++ b/fs/hppfs/hppfs.c
@@ -33,7 +33,7 @@ struct hppfs_private {
 };
 struct hppfs_inode_info {
-        struct dentry *proc_dentry;
+        struct dentry *proc_dentry;
        struct inode vfs_inode;
 };
@@ -52,7 +52,7 @@ static int is_pid(struct dentry *dentry)
        int i;
        sb = dentry->d_sb;
-        if ((sb->s_op != &hppfs_sbops) || (dentry->d_parent != sb->s_root))
+        if (dentry->d_parent != sb->s_root)
                return 0;
        for (i = 0; i < dentry->d_name.len; i++) {
@@ -136,7 +136,7 @@ static int file_removed(struct dentry *dentry, const char *file)
 }
 static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
-                                  struct nameidata *nd)
+                                   struct nameidata *nd)
 {
        struct dentry *proc_dentry, *new, *parent;
        struct inode *inode;
@@ -254,6 +254,8 @@ static ssize_t hppfs_read(struct file *file, char __user *buf, size_t count,
        int err;
        if (hppfs->contents != NULL) {
+                int rem;
                if (*ppos >= hppfs->len)
                        return 0;
@@ -267,8 +269,10 @@ static ssize_t hppfs_read(struct file *file, char __user *buf, size_t count,
                if (off + count > hppfs->len)
                        count = hppfs->len - off;
-                copy_to_user(buf, &data->contents[off], count);
+                rem = copy_to_user(buf, &data->contents[off], count);
-                *ppos += count;
+                *ppos += count - rem;
+                if (rem > 0)
+                        return -EFAULT;
        } else if (hppfs->host_fd != -1) {
                err = os_seek_file(hppfs->host_fd, *ppos);
                if (err) {
@@ -285,21 +289,15 @@ static ssize_t hppfs_read(struct file *file, char __user *buf, size_t count,
        return count;
 }
-static ssize_t hppfs_write(struct file *file, const char __user *buf, size_t len,
+static ssize_t hppfs_write(struct file *file, const char __user *buf,
-                           loff_t *ppos)
+                           size_t len, loff_t *ppos)
 {
        struct hppfs_private *data = file->private_data;
        struct file *proc_file = data->proc_file;
        ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
-        int err;
        write = proc_file->f_path.dentry->d_inode->i_fop->write;
+        return (*write)(proc_file, buf, len, ppos);
-        proc_file->f_pos = file->f_pos;
-        err = (*write)(proc_file, buf, len, &proc_file->f_pos);
-        file->f_pos = proc_file->f_pos;
-        return err;
 }
 static int open_host_sock(char *host_file, int *filter_out)
@@ -357,7 +355,7 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
        if (filter) {
                while ((n = read_proc(proc_file, data->contents,
-                                     sizeof(data->contents), NULL, 0)) > 0)
+                                      sizeof(data->contents), NULL, 0)) > 0)
                        os_write_file(fd, data->contents, n);
                err = os_shutdown_socket(fd, 0, 1);
                if (err) {
@@ -429,8 +427,8 @@ static int file_mode(int fmode)
 static int hppfs_open(struct inode *inode, struct file *file)
 {
        struct hppfs_private *data;
-        struct dentry *proc_dentry;
        struct vfsmount *proc_mnt;
+        struct dentry *proc_dentry;
        char *host_file;
        int err, fd, type, filter;
@@ -492,8 +490,8 @@ static int hppfs_open(struct inode *inode, struct file *file)
 static int hppfs_dir_open(struct inode *inode, struct file *file)
 {
        struct hppfs_private *data;
-        struct dentry *proc_dentry;
        struct vfsmount *proc_mnt;
+        struct dentry *proc_dentry;
        int err;
        err = -ENOMEM;
@@ -620,6 +618,9 @@ static struct inode *hppfs_alloc_inode(struct super_block *sb)
 void hppfs_delete_inode(struct inode *ino)
 {
+        dput(HPPFS_I(ino)->proc_dentry);
+        mntput(ino->i_sb->s_fs_info);
        clear_inode(ino);
 }
@@ -628,69 +629,46 @@ static void hppfs_destroy_inode(struct inode *inode)
        kfree(HPPFS_I(inode));
 }
-static void hppfs_put_super(struct super_block *sb)
-{
-        mntput(sb->s_fs_info);
-}
 static const struct super_operations hppfs_sbops = {
        .alloc_inode    = hppfs_alloc_inode,
        .destroy_inode  = hppfs_destroy_inode,
        .delete_inode   = hppfs_delete_inode,
        .statfs         = hppfs_statfs,
-        .put_super      = hppfs_put_super,
 };
 static int hppfs_readlink(struct dentry *dentry, char __user *buffer,
                          int buflen)
 {
-        struct file *proc_file;
        struct dentry *proc_dentry;
-        struct vfsmount *proc_mnt;
-        int ret;
        proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
-        proc_mnt = dentry->d_sb->s_fs_info;
+        return proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer,
+                                                    buflen);
-        proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt), O_RDONLY);
-        if (IS_ERR(proc_file))
-                return PTR_ERR(proc_file);
-        ret = proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer, buflen);
-        fput(proc_file);
-        return ret;
 }
-static void* hppfs_follow_link(struct dentry *dentry, struct nameidata *nd)
+static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
-        struct file *proc_file;
        struct dentry *proc_dentry;
-        struct vfsmount *proc_mnt;
-        void *ret;
        proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
-        proc_mnt = dentry->d_sb->s_fs_info;
-        proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt), O_RDONLY);
-        if (IS_ERR(proc_file))
-                return proc_file;
-        ret = proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd);
-        fput(proc_file);
+        return proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd);
+}
-        return ret;
+int hppfs_permission(struct inode *inode, int mask, struct nameidata *nd)
+{
+        return generic_permission(inode, mask, NULL);
 }
 static const struct inode_operations hppfs_dir_iops = {
        .lookup         = hppfs_lookup,
+        .permission     = hppfs_permission,
 };
 static const struct inode_operations hppfs_link_iops = {
        .readlink       = hppfs_readlink,
        .follow_link    = hppfs_follow_link,
+        .permission     = hppfs_permission,
 };
 static struct inode *get_inode(struct super_block *sb, struct dentry *dentry)
@@ -712,7 +690,7 @@ static struct inode *get_inode(struct super_block *sb, struct dentry *dentry)
                inode->i_fop = &hppfs_file_fops;
        }
-        HPPFS_I(inode)->proc_dentry = dentry;
+        HPPFS_I(inode)->proc_dentry = dget(dentry);
        inode->i_uid = proc_ino->i_uid;
        inode->i_gid = proc_ino->i_gid;
@@ -725,7 +703,7 @@ static struct inode *get_inode(struct super_block *sb, struct dentry *dentry)
        inode->i_size = proc_ino->i_size;
        inode->i_blocks = proc_ino->i_blocks;
-        return 0;
+        return inode;
 }
 static int hppfs_fill_super(struct super_block *sb, void *d, int silent)
diff --git a/fs/jbd/commit.c b/fs/jbd/commit.c
index cd931ef1f00..5a8ca61498c 100644
--- a/fs/jbd/commit.c
+++ b/fs/jbd/commit.c
@@ -470,7 +470,9 @@ void journal_commit_transaction(journal_t *journal)
         * transaction!  Now comes the tricky part: we need to write out
         * metadata.  Loop over the transaction's entire buffer list:
         */
+        spin_lock(&journal->j_state_lock);
        commit_transaction->t_state = T_COMMIT;
+        spin_unlock(&journal->j_state_lock);
        J_ASSERT(commit_transaction->t_nr_buffers <=
                 commit_transaction->t_outstanding_credits);
diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index e0139786f71..4d99685fdce 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -560,7 +560,9 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         * transaction!  Now comes the tricky part: we need to write out
         * metadata.  Loop over the transaction's entire buffer list:
         */
+        spin_lock(&journal->j_state_lock);
        commit_transaction->t_state = T_COMMIT;
+        spin_unlock(&journal->j_state_lock);
        stats.u.run.rs_logging = jiffies;
        stats.u.run.rs_flushing = jbd2_time_diff(stats.u.run.rs_flushing,
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 53632e3e845..2e24567c4a7 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -901,7 +901,7 @@ static void jbd2_stats_proc_init(journal_t *journal)
 {
        char name[BDEVNAME_SIZE];
-        snprintf(name, sizeof(name) - 1, "%s", bdevname(journal->j_dev, name));
+        bdevname(journal->j_dev, name);
        journal->j_proc_entry = proc_mkdir(name, proc_jbd2_stats);
        if (journal->j_proc_entry) {
                proc_create_data("history", S_IRUGO, journal->j_proc_entry,
@@ -915,7 +915,7 @@ static void jbd2_stats_proc_exit(journal_t *journal)
 {
        char name[BDEVNAME_SIZE];
-        snprintf(name, sizeof(name) - 1, "%s", bdevname(journal->j_dev, name));
+        bdevname(journal->j_dev, name);
        remove_proc_entry("info", journal->j_proc_entry);
        remove_proc_entry("history", journal->j_proc_entry);
        remove_proc_entry(name, proc_jbd2_stats);
diff --git a/fs/namei.c b/fs/namei.c
index 32fd9655485..c7e43536c49 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -2003,18 +2003,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)
+        if (unlikely(!is_dir && nd->last.name[nd->last.len])) {
-                goto enoent;
+                dput(dentry);
+                dentry = ERR_PTR(-ENOENT);
+        }
        return dentry;
-enoent:
+eexist:
        dput(dentry);
-        dentry = ERR_PTR(-ENOENT);
+        dentry = ERR_PTR(-EEXIST);
 fail:
        return dentry;
 }
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index 5606ae3d72d..c1e7c830062 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 15f7785048d..f7e83e23cf9 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 13619d24f02..dd0ef34b584 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_arg hdr_arg = { 0 };
-        struct cb_compound_hdr_res hdr_res;
+        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;
+        if (encode_compound_hdr_res(&xdr_out, &hdr_res) != 0)
-        encode_compound_hdr_res(&xdr_out, &hdr_res);
+                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 89ac5bb0401..f2a092ca69b 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 00a5e4405e1..cc563cfa694 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 f288b3ecab4..58d43daec08 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 3536b01164f..d84a3d8f32a 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 5cb3345eb69..596c5d8e86f 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);
+        path_put(&ctx->path);
-        mntput(ctx->path.mnt);
        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/namespace.c b/fs/nfs/namespace.c
index af4d0f1e402..2f285ef7639 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);
+        path_put(&nd->path);
-        dput(nd->path.dentry);
        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 549dbce714a..c3523ad03ed 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 bd1b9d663fb..ea790645fda 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 5f9ba41ed5b..b112857301f 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 dbc09271af0..1293e0acd82 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);
+        path_put(&p->path);
-        mntput(p->path.mnt);
        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);
+        path_put(&calldata->path);
-        mntput(calldata->path.mnt);
        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 5e2e4af1a0e..3305acbbe2a 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 46eb624e4f1..856a8934f61 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 5a2d64927b3..b916297d233 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 5ccf7faee19..03599bfe81c 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 16f57e0af99..40d17987d0e 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 7226a506f3c..2a4a024a4e7 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;
 }
@@ -2015,6 +2015,10 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
                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;
@@ -2031,6 +2035,8 @@ 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 +2120,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 +2205,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 1ade11d1ba0..6d8ace3e325 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)
diff --git a/fs/proc/array.c b/fs/proc/array.c
index dca997a93bf..9e3b8c33c24 100644
--- a/fs/proc/array.c
+++ b/fs/proc/array.c
@@ -298,6 +298,7 @@ static inline void task_cap(struct seq_file *m, struct task_struct *p)
        render_cap_t(m, "CapInh:\t", &p->cap_inheritable);
        render_cap_t(m, "CapPrm:\t", &p->cap_permitted);
        render_cap_t(m, "CapEff:\t", &p->cap_effective);
+        render_cap_t(m, "CapBnd:\t", &p->cap_bset);
 }
 static inline void task_context_switch_counts(struct seq_file *m,
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 808cbdc193d..c447e0743a3 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2441,7 +2441,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),
diff --git a/fs/ufs/ufs.h b/fs/ufs/ufs.h
index 244a1aaa940..11c035168ea 100644
--- a/fs/ufs/ufs.h
+++ b/fs/ufs/ufs.h
@@ -107,7 +107,6 @@ extern struct inode * ufs_new_inode (struct inode *, int);
 /* inode.c */
 extern struct inode *ufs_iget(struct super_block *, unsigned long);
-extern void ufs_put_inode (struct inode *);
 extern int ufs_write_inode (struct inode *, int);
 extern int ufs_sync_inode (struct inode *);
 extern void ufs_delete_inode (struct inode *);