172 files changed, 2361 insertions, 1924 deletions
diff --git a/fs/Kconfig b/fs/Kconfig
index d7312825592b..c509123bea49 100644
--- a/fs/Kconfig
+++ b/fs/Kconfig
@@ -1744,10 +1744,10 @@ config ROOT_NFS
          If you want your Linux box to mount its whole root file system (the
          one containing the directory /) from some other computer over the
          net via NFS (presumably because your box doesn't have a hard disk),
-          say Y. Read <file:Documentation/nfsroot.txt> for details. It is
+          say Y. Read <file:Documentation/filesystems/nfsroot.txt> for
-          likely that in this case, you also want to say Y to "Kernel level IP
+          details. It is likely that in this case, you also want to say Y to
-          autoconfiguration" so that your box can discover its network address
+          "Kernel level IP autoconfiguration" so that your box can discover
-          at boot time.
+          its network address at boot time.
          Most people say N here.
diff --git a/fs/afs/cell.c b/fs/afs/cell.c
index 970d38f30565..584bb0f9c36a 100644
--- a/fs/afs/cell.c
+++ b/fs/afs/cell.c
@@ -127,14 +127,21 @@ struct afs_cell *afs_cell_create(const char *name, char *vllist)
        _enter("%s,%s", name, vllist);
+        down_write(&afs_cells_sem);
+        read_lock(&afs_cells_lock);
+        list_for_each_entry(cell, &afs_cells, link) {
+                if (strcasecmp(cell->name, name) == 0)
+                        goto duplicate_name;
+        }
+        read_unlock(&afs_cells_lock);
        cell = afs_cell_alloc(name, vllist);
        if (IS_ERR(cell)) {
                _leave(" = %ld", PTR_ERR(cell));
+                up_write(&afs_cells_sem);
                return cell;
        }
-        down_write(&afs_cells_sem);
        /* add a proc directory for this cell */
        ret = afs_proc_cell_setup(cell);
        if (ret < 0)
@@ -167,6 +174,11 @@ error:
        kfree(cell);
        _leave(" = %d", ret);
        return ERR_PTR(ret);
+duplicate_name:
+        read_unlock(&afs_cells_lock);
+        up_write(&afs_cells_sem);
+        return ERR_PTR(-EEXIST);
 }
 /*
diff --git a/fs/afs/internal.h b/fs/afs/internal.h
index 5ca3625cd39e..eec41c76de72 100644
--- a/fs/afs/internal.h
+++ b/fs/afs/internal.h
@@ -573,7 +573,6 @@ extern const struct file_operations afs_mntpt_file_operations;
 extern int afs_mntpt_check_symlink(struct afs_vnode *, struct key *);
 extern void afs_mntpt_kill_timer(void);
-extern void afs_umount_begin(struct vfsmount *, int);
 /*
 * proc.c
@@ -750,7 +749,7 @@ extern int afs_fsync(struct file *, struct dentry *, int);
 extern unsigned afs_debug;
 #define dbgprintk(FMT,...) \
-        printk("[%x%-6.6s] "FMT"\n", smp_processor_id(), current->comm ,##__VA_ARGS__)
+        printk("[%-6.6s] "FMT"\n", current->comm ,##__VA_ARGS__)
 /* make sure we maintain the format strings, even when debugging is disabled */
 static inline __attribute__((format(printf,1,2)))
diff --git a/fs/afs/main.c b/fs/afs/main.c
index 0f60f6b35769..2d3e5d4fb9f7 100644
--- a/fs/afs/main.c
+++ b/fs/afs/main.c
@@ -22,7 +22,7 @@ MODULE_LICENSE("GPL");
 unsigned afs_debug;
 module_param_named(debug, afs_debug, uint, S_IWUSR | S_IRUGO);
-MODULE_PARM_DESC(afs_debug, "AFS debugging mask");
+MODULE_PARM_DESC(debug, "AFS debugging mask");
 static char *rootcell;
diff --git a/fs/afs/mntpt.c b/fs/afs/mntpt.c
index a3510b8ba3e7..2f5503902c37 100644
--- a/fs/afs/mntpt.c
+++ b/fs/afs/mntpt.c
@@ -283,11 +283,3 @@ void afs_mntpt_kill_timer(void)
        cancel_delayed_work(&afs_mntpt_expiry_timer);
        flush_scheduled_work();
 }
-/*
- * begin unmount by attempting to remove all automounted mountpoints we added
- */
-void afs_umount_begin(struct vfsmount *vfsmnt, int flags)
-{
-        shrink_submounts(vfsmnt, &afs_vfsmounts);
-}
diff --git a/fs/afs/super.c b/fs/afs/super.c
index 36bbce45f44b..4b572b801d8d 100644
--- a/fs/afs/super.c
+++ b/fs/afs/super.c
@@ -50,7 +50,6 @@ static const struct super_operations afs_super_ops = {
        .write_inode    = afs_write_inode,
        .destroy_inode  = afs_destroy_inode,
        .clear_inode    = afs_clear_inode,
-        .umount_begin   = afs_umount_begin,
        .put_super      = afs_put_super,
        .show_options   = generic_show_options,
 };
diff --git a/fs/aio.c b/fs/aio.c
index b74c567383bc..228368610dfa 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -936,14 +936,6 @@ int aio_complete(struct kiocb *iocb, long res, long res2)
                return 1;
        }
-        /*
-         * Check if the user asked us to deliver the result through an
-         * eventfd. The eventfd_signal() function is safe to be called
-         * from IRQ context.
-         */
-        if (!IS_ERR(iocb->ki_eventfd))
-                eventfd_signal(iocb->ki_eventfd, 1);
        info = &ctx->ring_info;
        /* add a completion event to the ring buffer.
@@ -992,10 +984,27 @@ int aio_complete(struct kiocb *iocb, long res, long res2)
        kunmap_atomic(ring, KM_IRQ1);
        pr_debug("added to ring %p at [%lu]\n", iocb, tail);
+        /*
+         * Check if the user asked us to deliver the result through an
+         * eventfd. The eventfd_signal() function is safe to be called
+         * from IRQ context.
+         */
+        if (!IS_ERR(iocb->ki_eventfd))
+                eventfd_signal(iocb->ki_eventfd, 1);
 put_rq:
        /* everything turned out well, dispose of the aiocb. */
        ret = __aio_put_req(ctx, iocb);
+        /*
+         * We have to order our ring_info tail store above and test
+         * of the wait list below outside the wait lock.  This is
+         * like in wake_up_bit() where clearing a bit has to be
+         * ordered with the unlocked test.
+         */
+        smp_mb();
        if (waitqueue_active(&ctx->wait))
                wake_up(&ctx->wait);
@@ -1782,6 +1791,7 @@ asmlinkage long sys_io_getevents(aio_context_t ctx_id,
                put_ioctx(ioctx);
        }
+        asmlinkage_protect(5, ret, ctx_id, min_nr, nr, events, timeout);
        return ret;
 }
diff --git a/fs/anon_inodes.c b/fs/anon_inodes.c
index 23321889d9b0..f42be069e085 100644
--- a/fs/anon_inodes.c
+++ b/fs/anon_inodes.c
@@ -81,13 +81,10 @@ int anon_inode_getfd(int *pfd, struct inode **pinode, struct file **pfile,
        if (IS_ERR(anon_inode_inode))
                return -ENODEV;
-        file = get_empty_filp();
-        if (!file)
-                return -ENFILE;
        error = get_unused_fd();
        if (error < 0)
-                goto err_put_filp;
+                return error;
        fd = error;
        /*
@@ -114,14 +111,15 @@ int anon_inode_getfd(int *pfd, struct inode **pinode, struct file **pfile,
        dentry->d_flags &= ~DCACHE_UNHASHED;
        d_instantiate(dentry, anon_inode_inode);
-        file->f_path.mnt = mntget(anon_inode_mnt);
+        error = -ENFILE;
-        file->f_path.dentry = dentry;
+        file = alloc_file(anon_inode_mnt, dentry,
+                          FMODE_READ | FMODE_WRITE, fops);
+        if (!file)
+                goto err_dput;
        file->f_mapping = anon_inode_inode->i_mapping;
        file->f_pos = 0;
        file->f_flags = O_RDWR;
-        file->f_op = fops;
-        file->f_mode = FMODE_READ | FMODE_WRITE;
        file->f_version = 0;
        file->private_data = priv;
@@ -132,10 +130,10 @@ int anon_inode_getfd(int *pfd, struct inode **pinode, struct file **pfile,
        *pfile = file;
        return 0;
+err_dput:
+        dput(dentry);
 err_put_unused_fd:
        put_unused_fd(fd);
-err_put_filp:
-        put_filp(file);
        return error;
 }
 EXPORT_SYMBOL_GPL(anon_inode_getfd);
diff --git a/fs/binfmt_elf.c b/fs/binfmt_elf.c
index 41a958a7585e..5e1a4fb5cacb 100644
--- a/fs/binfmt_elf.c
+++ b/fs/binfmt_elf.c
@@ -1424,6 +1424,18 @@ struct elf_note_info {
        int thread_notes;
 };
+/*
+ * When a regset has a writeback hook, we call it on each thread before
+ * dumping user memory.  On register window machines, this makes sure the
+ * user memory backing the register data is up to date before we read it.
+ */
+static void do_thread_regset_writeback(struct task_struct *task,
+                                       const struct user_regset *regset)
+{
+        if (regset->writeback)
+                regset->writeback(task, regset, 1);
+}
 static int fill_thread_core_info(struct elf_thread_core_info *t,
                                 const struct user_regset_view *view,
                                 long signr, size_t *total)
@@ -1445,6 +1457,8 @@ static int fill_thread_core_info(struct elf_thread_core_info *t,
                  sizeof(t->prstatus), &t->prstatus);
        *total += notesize(&t->notes[0]);
+        do_thread_regset_writeback(t->task, &view->regsets[0]);
        /*
         * Each other regset might generate a note too.  For each regset
         * that has no core_note_type or is inactive, we leave t->notes[i]
@@ -1452,6 +1466,7 @@ static int fill_thread_core_info(struct elf_thread_core_info *t,
         */
        for (i = 1; i < view->n; ++i) {
                const struct user_regset *regset = &view->regsets[i];
+                do_thread_regset_writeback(t->task, regset);
                if (regset->core_note_type &&
                    (!regset->active || regset->active(t->task, regset))) {
                        int ret;
diff --git a/fs/bio.c b/fs/bio.c
index 3312fcc3c098..553b5b7960ad 100644
--- a/fs/bio.c
+++ b/fs/bio.c
@@ -1194,6 +1194,8 @@ EXPORT_SYMBOL(bio_hw_segments);
 EXPORT_SYMBOL(bio_add_page);
 EXPORT_SYMBOL(bio_add_pc_page);
 EXPORT_SYMBOL(bio_get_nr_vecs);
+EXPORT_SYMBOL(bio_map_user);
+EXPORT_SYMBOL(bio_unmap_user);
 EXPORT_SYMBOL(bio_map_kern);
 EXPORT_SYMBOL(bio_pair_release);
 EXPORT_SYMBOL(bio_split);
diff --git a/fs/buffer.c b/fs/buffer.c
index 3ebccf4aa7e3..39ff14403d13 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -627,8 +627,7 @@ repeat:
 }
 /**
- * sync_mapping_buffers - write out and wait upon a mapping's "associated"
+ * sync_mapping_buffers - write out & wait upon a mapping's "associated" buffers
- *                        buffers
 * @mapping: the mapping which wants those buffers written
 *
 * Starts I/O against the buffers at mapping->private_list, and waits upon
@@ -836,7 +835,7 @@ static int fsync_buffers_list(spinlock_t *lock, struct list_head *list)
                smp_mb();
                if (buffer_dirty(bh)) {
                        list_add(&bh->b_assoc_buffers,
-                                 &bh->b_assoc_map->private_list);
+                                 &mapping->private_list);
                        bh->b_assoc_map = mapping;
                }
                spin_unlock(lock);
@@ -1182,7 +1181,20 @@ __getblk_slow(struct block_device *bdev, sector_t block, int size)
 void mark_buffer_dirty(struct buffer_head *bh)
 {
        WARN_ON_ONCE(!buffer_uptodate(bh));
-        if (!buffer_dirty(bh) && !test_set_buffer_dirty(bh))
+        /*
+         * Very *carefully* optimize the it-is-already-dirty case.
+         *
+         * Don't let the final "is it dirty" escape to before we
+         * perhaps modified the buffer.
+         */
+        if (buffer_dirty(bh)) {
+                smp_mb();
+                if (buffer_dirty(bh))
+                        return;
+        }
+        if (!test_set_buffer_dirty(bh))
                __set_page_dirty(bh->b_page, page_mapping(bh->b_page), 0);
 }
@@ -2565,14 +2577,13 @@ int nobh_write_end(struct file *file, struct address_space *mapping,
        struct inode *inode = page->mapping->host;
        struct buffer_head *head = fsdata;
        struct buffer_head *bh;
+        BUG_ON(fsdata != NULL && page_has_buffers(page));
-        if (!PageMappedToDisk(page)) {
+        if (unlikely(copied < len) && !page_has_buffers(page))
-                if (unlikely(copied < len) && !page_has_buffers(page))
+                attach_nobh_buffers(page, head);
-                        attach_nobh_buffers(page, head);
+        if (page_has_buffers(page))
-                if (page_has_buffers(page))
+                return generic_write_end(file, mapping, pos, len,
-                        return generic_write_end(file, mapping, pos, len,
+                                        copied, page, fsdata);
-                                                copied, page, fsdata);
-        }
        SetPageUptodate(page);
        set_page_dirty(page);
@@ -3214,7 +3225,7 @@ static int buffer_cpu_notify(struct notifier_block *self,
 }
 /**
- * bh_uptodate_or_lock: Test whether the buffer is uptodate
+ * bh_uptodate_or_lock - Test whether the buffer is uptodate
 * @bh: struct buffer_head
 *
 * Return true if the buffer is up-to-date and false,
@@ -3233,7 +3244,7 @@ int bh_uptodate_or_lock(struct buffer_head *bh)
 EXPORT_SYMBOL(bh_uptodate_or_lock);
 /**
- * bh_submit_read: Submit a locked buffer for reading
+ * bh_submit_read - Submit a locked buffer for reading
 * @bh: struct buffer_head
 *
 * Returns zero on success and -EIO on error.
diff --git a/fs/cifs/CHANGES b/fs/cifs/CHANGES
index edd248367b36..dbd91461853c 100644
--- a/fs/cifs/CHANGES
+++ b/fs/cifs/CHANGES
@@ -6,7 +6,9 @@ and sync so that events like out of disk space get reported properly on
 cached files. Fix setxattr failure to certain Samba versions. Fix mount
 of second share to disconnected server session (autoreconnect on this).
 Add ability to modify cifs acls for handling chmod (when mounted with
-cifsacl flag).
+cifsacl flag). Fix prefixpath path separator so we can handle mounts
+with prefixpaths longer than one directory (one path component) when
+mounted to Windows servers.
 Version 1.51
 ------------
diff --git a/fs/cifs/README b/fs/cifs/README
index c623e2f9c5db..50306229b0f9 100644
--- a/fs/cifs/README
+++ b/fs/cifs/README
@@ -461,7 +461,7 @@ A partial list of the supported mount options follows:
 cifsacl        Report mode bits (e.g. on stat) based on the Windows ACL for
                the file. (EXPERIMENTAL)
 servern        Specify the server 's netbios name (RFC1001 name) to use
-                when attempting to setup a session to the server.  This is
+                when attempting to setup a session to the server. 
                This is needed for mounting to some older servers (such
                as OS/2 or Windows 98 and Windows ME) since they do not
                support a default server name.  A server name can be up
diff --git a/fs/cifs/cifs_debug.c b/fs/cifs/cifs_debug.c
index 73c4c419663c..0228ed06069e 100644
--- a/fs/cifs/cifs_debug.c
+++ b/fs/cifs/cifs_debug.c
@@ -98,8 +98,7 @@ void cifs_dump_mids(struct TCP_Server_Info *server)
                        if (mid_entry->resp_buf) {
                                cifs_dump_detail(mid_entry->resp_buf);
                                cifs_dump_mem("existing buf: ",
-                                        mid_entry->resp_buf,
+                                        mid_entry->resp_buf, 62);
-                                        62 /* fixme */);
                        }
                }
        }
@@ -439,7 +438,7 @@ cifs_stats_read(char *buf, char **beginBuffer, off_t offset,
        return length;
 }
-#endif
+#endif /* STATS */
 static struct proc_dir_entry *proc_fs_cifs;
 read_proc_t cifs_txanchor_read;
@@ -482,7 +481,7 @@ cifs_proc_init(void)
                                cifs_stats_read, NULL);
        if (pde)
                pde->write_proc = cifs_stats_write;
-#endif
+#endif /* STATS */
        pde = create_proc_read_entry("cifsFYI", 0, proc_fs_cifs,
                                cifsFYI_read, NULL);
        if (pde)
@@ -918,4 +917,12 @@ security_flags_write(struct file *file, const char __user *buffer,
        /* BB should we turn on MAY flags for other MUST options? */
        return count;
 }
-#endif
+#else
+inline void cifs_proc_init(void)
+{
+}
+inline void cifs_proc_clean(void)
+{
+}
+#endif /* PROC_FS */
diff --git a/fs/cifs/cifs_debug.h b/fs/cifs/cifs_debug.h
index c26cd0d2c6d5..5eb3b83bbfa7 100644
--- a/fs/cifs/cifs_debug.h
+++ b/fs/cifs/cifs_debug.h
@@ -25,8 +25,11 @@
 void cifs_dump_mem(char *label, void *data, int length);
 #ifdef CONFIG_CIFS_DEBUG2
+#define DBG2 2
 void cifs_dump_detail(struct smb_hdr *);
 void cifs_dump_mids(struct TCP_Server_Info *);
+#else
+#define DBG2 0
 #endif
 extern int traceSMB;            /* flag which enables the function below */
 void dump_smb(struct smb_hdr *, int);
@@ -64,10 +67,10 @@ extern int cifsERROR;
 *      ---------
 */
 #else           /* _CIFS_DEBUG */
-#define cERROR(button,prspec)
+#define cERROR(button, prspec)
-#define cEVENT(format,arg...)
+#define cEVENT(format, arg...)
 #define cFYI(button, prspec)
-#define cifserror(format,arg...)
+#define cifserror(format, arg...)
 #endif          /* _CIFS_DEBUG */
 #endif                          /* _H_CIFS_DEBUG */
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index 6ad447529961..56c924033b78 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -33,7 +33,6 @@ void dfs_shrink_umount_helper(struct vfsmount *vfsmnt)
 {
        mark_mounts_for_expiry(&cifs_dfs_automount_list);
        mark_mounts_for_expiry(&cifs_dfs_automount_list);
-        shrink_submounts(vfsmnt, &cifs_dfs_automount_list);
 }
 /**
@@ -74,7 +73,7 @@ static char *cifs_get_share_name(const char *node_name)
        pSep = memchr(UNC+2, '\\', len-2);
        if (!pSep) {
                cERROR(1, ("%s: no server name end in node name: %s",
-                        __FUNCTION__, node_name));
+                        __func__, node_name));
                kfree(UNC);
                return NULL;
        }
@@ -84,7 +83,7 @@ static char *cifs_get_share_name(const char *node_name)
        pSep = memchr(UNC+(pSep-UNC), '\\', len-(pSep-UNC));
        if (!pSep) {
                cERROR(1, ("%s:2 cant find share name in node name: %s",
-                        __FUNCTION__, node_name));
+                        __func__, node_name));
                kfree(UNC);
                return NULL;
        }
@@ -127,7 +126,7 @@ static char *compose_mount_options(const char *sb_mountdata,
        rc = dns_resolve_server_name_to_ip(*devname, &srvIP);
        if (rc != 0) {
                cERROR(1, ("%s: Failed to resolve server part of %s to IP",
-                          __FUNCTION__, *devname));
+                          __func__, *devname));
                mountdata = ERR_PTR(rc);
                goto compose_mount_options_out;
        }
@@ -181,8 +180,8 @@ static char *compose_mount_options(const char *sb_mountdata,
                }
        }
-        /*cFYI(1,("%s: parent mountdata: %s", __FUNCTION__,sb_mountdata));*/
+        /*cFYI(1,("%s: parent mountdata: %s", __func__,sb_mountdata));*/
-        /*cFYI(1, ("%s: submount mountdata: %s", __FUNCTION__, mountdata ));*/
+        /*cFYI(1, ("%s: submount mountdata: %s", __func__, mountdata ));*/
 compose_mount_options_out:
        kfree(srvIP);
@@ -286,7 +285,7 @@ static void dump_referral(const struct dfs_info3_param *ref)
        cFYI(1, ("DFS: node path: %s", ref->node_name));
        cFYI(1, ("DFS: fl: %hd, srv_type: %hd", ref->flags, ref->server_type));
        cFYI(1, ("DFS: ref_flags: %hd, path_consumed: %hd", ref->ref_flag,
-                                ref->PathConsumed));
+                                ref->path_consumed));
 }
@@ -302,7 +301,7 @@ cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
        int rc = 0;
        struct vfsmount *mnt = ERR_PTR(-ENOENT);
-        cFYI(1, ("in %s", __FUNCTION__));
+        cFYI(1, ("in %s", __func__));
        BUG_ON(IS_ROOT(dentry));
        xid = GetXid();
@@ -336,7 +335,7 @@ cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
                        len = strlen(referrals[i].node_name);
                        if (len < 2) {
                                cERROR(1, ("%s: Net Address path too short: %s",
-                                        __FUNCTION__, referrals[i].node_name));
+                                        __func__, referrals[i].node_name));
                                rc = -EINVAL;
                                goto out_err;
                        }
@@ -344,7 +343,7 @@ cifs_dfs_follow_mountpoint(struct dentry *dentry, struct nameidata *nd)
                                                nd->path.dentry,
                                                referrals[i].node_name);
                        cFYI(1, ("%s: cifs_dfs_do_refmount:%s , mnt:%p",
-                                         __FUNCTION__,
+                                         __func__,
                                        referrals[i].node_name, mnt));
                        /* complete mount procedure if we accured submount */
@@ -365,7 +364,7 @@ out:
        FreeXid(xid);
        free_dfs_info_array(referrals, num_referrals);
        kfree(full_path);
-        cFYI(1, ("leaving %s" , __FUNCTION__));
+        cFYI(1, ("leaving %s" , __func__));
        return ERR_PTR(rc);
 out_err:
        path_put(&nd->path);
diff --git a/fs/cifs/cifs_spnego.c b/fs/cifs/cifs_spnego.c
index d543accc10dd..6653e29637a7 100644
--- a/fs/cifs/cifs_spnego.c
+++ b/fs/cifs/cifs_spnego.c
@@ -125,7 +125,7 @@ cifs_get_spnego_key(struct cifsSesInfo *sesInfo)
 #ifdef CONFIG_CIFS_DEBUG2
        if (cifsFYI && !IS_ERR(spnego_key)) {
                struct cifs_spnego_msg *msg = spnego_key->payload.data;
-                cifs_dump_mem("SPNEGO reply blob:", msg->data, min(1024,
+                cifs_dump_mem("SPNEGO reply blob:", msg->data, min(1024U,
                                msg->secblob_len + msg->sesskey_len));
        }
 #endif /* CONFIG_CIFS_DEBUG2 */
diff --git a/fs/cifs/cifs_unicode.c b/fs/cifs/cifs_unicode.c
index b5903b89250d..7d75272a6b3f 100644
--- a/fs/cifs/cifs_unicode.c
+++ b/fs/cifs/cifs_unicode.c
@@ -32,7 +32,7 @@
 *
 */
 int
-cifs_strfromUCS_le(char *to, const __le16 * from,
+cifs_strfromUCS_le(char *to, const __le16 *from,
                   int len, const struct nls_table *codepage)
 {
        int i;
@@ -61,7 +61,7 @@ cifs_strfromUCS_le(char *to, const __le16 * from,
 *
 */
 int
-cifs_strtoUCS(__le16 * to, const char *from, int len,
+cifs_strtoUCS(__le16 *to, const char *from, int len,
              const struct nls_table *codepage)
 {
        int charlen;
diff --git a/fs/cifs/cifs_unicode.h b/fs/cifs/cifs_unicode.h
index 614c11fcdcb6..14eb9a2395d3 100644
--- a/fs/cifs/cifs_unicode.h
+++ b/fs/cifs/cifs_unicode.h
@@ -254,7 +254,8 @@ UniStrstr(const wchar_t *ucs1, const wchar_t *ucs2)
        const wchar_t *anchor2 = ucs2;
        while (*ucs1) {
-                if (*ucs1 == *ucs2) {   /* Partial match found */
+                if (*ucs1 == *ucs2) {
+                        /* Partial match found */
                        ucs1++;
                        ucs2++;
                } else {
@@ -279,7 +280,8 @@ UniToupper(register wchar_t uc)
 {
        register const struct UniCaseRange *rp;
-        if (uc < sizeof (CifsUniUpperTable)) {  /* Latin characters */
+        if (uc < sizeof(CifsUniUpperTable)) {
+                /* Latin characters */
                return uc + CifsUniUpperTable[uc];      /* Use base tables */
        } else {
                rp = CifsUniUpperRange; /* Use range tables */
@@ -320,7 +322,8 @@ UniTolower(wchar_t uc)
 {
        register struct UniCaseRange *rp;
-        if (uc < sizeof (UniLowerTable)) {      /* Latin characters */
+        if (uc < sizeof(UniLowerTable)) {
+                /* Latin characters */
                return uc + UniLowerTable[uc];  /* Use base tables */
        } else {
                rp = UniLowerRange;     /* Use range tables */
diff --git a/fs/cifs/cifsacl.c b/fs/cifs/cifsacl.c
index a7035bd18e4e..1cb5b0a9f2ac 100644
--- a/fs/cifs/cifsacl.c
+++ b/fs/cifs/cifsacl.c
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/cifsacl.c
 *
- *   Copyright (C) International Business Machines  Corp., 2007
+ *   Copyright (C) International Business Machines  Corp., 2007,2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   Contains the routines for mapping CIFS/NTFS ACLs
@@ -46,8 +46,7 @@ static struct cifs_wksid wksidarr[NUM_WK_SIDS] = {
 static const struct cifs_sid sid_everyone = {
        1, 1, {0, 0, 0, 0, 0, 1}, {0} };
 /* group users */
-static const struct cifs_sid sid_user =
+static const struct cifs_sid sid_user = {1, 2 , {0, 0, 0, 0, 0, 5}, {} };
-                {1, 2 , {0, 0, 0, 0, 0, 5}, {} };
 int match_sid(struct cifs_sid *ctsid)
@@ -195,9 +194,9 @@ static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
        /* For deny ACEs we change the mask so that subsequent allow access
           control entries do not turn on the bits we are denying */
        if (type == ACCESS_DENIED) {
-                if (flags & GENERIC_ALL) {
+                if (flags & GENERIC_ALL)
                        *pbits_to_set &= ~S_IRWXUGO;
-                }
                if ((flags & GENERIC_WRITE) ||
                        ((flags & FILE_WRITE_RIGHTS) == FILE_WRITE_RIGHTS))
                        *pbits_to_set &= ~S_IWUGO;
@@ -216,9 +215,7 @@ static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
        if (flags & GENERIC_ALL) {
                *pmode |= (S_IRWXUGO & (*pbits_to_set));
-#ifdef CONFIG_CIFS_DEBUG2
+                cFYI(DBG2, ("all perms"));
-                cFYI(1, ("all perms"));
-#endif
                return;
        }
        if ((flags & GENERIC_WRITE) ||
@@ -231,9 +228,7 @@ static void access_flags_to_mode(__le32 ace_flags, int type, umode_t *pmode,
                        ((flags & FILE_EXEC_RIGHTS) == FILE_EXEC_RIGHTS))
                *pmode |= (S_IXUGO & (*pbits_to_set));
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("access flags 0x%x mode now 0x%x", flags, *pmode));
-        cFYI(1, ("access flags 0x%x mode now 0x%x", flags, *pmode));
-#endif
        return;
 }
@@ -262,13 +257,11 @@ static void mode_to_access_flags(umode_t mode, umode_t bits_to_use,
        if (mode & S_IXUGO)
                *pace_flags |= SET_FILE_EXEC_RIGHTS;
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("mode: 0x%x, access flags now 0x%x", mode, *pace_flags));
-        cFYI(1, ("mode: 0x%x, access flags now 0x%x", mode, *pace_flags));
-#endif
        return;
 }
-static __le16 fill_ace_for_sid(struct cifs_ace *pntace,
+static __u16 fill_ace_for_sid(struct cifs_ace *pntace,
                        const struct cifs_sid *psid, __u64 nmode, umode_t bits)
 {
        int i;
@@ -358,11 +351,9 @@ static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
                return;
        }
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("DACL revision %d size %d num aces %d",
-        cFYI(1, ("DACL revision %d size %d num aces %d",
                le16_to_cpu(pdacl->revision), le16_to_cpu(pdacl->size),
                le32_to_cpu(pdacl->num_aces)));
-#endif
        /* reset rwx permissions for user/group/other.
           Also, if num_aces is 0 i.e. DACL has no ACEs,
@@ -381,10 +372,6 @@ static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
                ppace = kmalloc(num_aces * sizeof(struct cifs_ace *),
                                GFP_KERNEL);
-/*              cifscred->cecount = pdacl->num_aces;
-                cifscred->aces = kmalloc(num_aces *
-                        sizeof(struct cifs_ace *), GFP_KERNEL);*/
                for (i = 0; i < num_aces; ++i) {
                        ppace[i] = (struct cifs_ace *) (acl_base + acl_size);
 #ifdef CONFIG_CIFS_DEBUG2
@@ -424,7 +411,7 @@ static void parse_dacl(struct cifs_acl *pdacl, char *end_of_acl,
 static int set_chmod_dacl(struct cifs_acl *pndacl, struct cifs_sid *pownersid,
                        struct cifs_sid *pgrpsid, __u64 nmode)
 {
-        __le16 size = 0;
+        u16 size = 0;
        struct cifs_acl *pnndacl;
        pnndacl = (struct cifs_acl *)((char *)pndacl + sizeof(struct cifs_acl));
@@ -437,7 +424,7 @@ static int set_chmod_dacl(struct cifs_acl *pndacl, struct cifs_sid *pownersid,
                                         &sid_everyone, nmode, S_IRWXO);
        pndacl->size = cpu_to_le16(size + sizeof(struct cifs_acl));
-        pndacl->num_aces = 3;
+        pndacl->num_aces = cpu_to_le32(3);
        return (0);
 }
@@ -495,13 +482,11 @@ static int parse_sec_desc(struct cifs_ntsd *pntsd, int acl_len,
                                le32_to_cpu(pntsd->gsidoffset));
        dacloffset = le32_to_cpu(pntsd->dacloffset);
        dacl_ptr = (struct cifs_acl *)((char *)pntsd + dacloffset);
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("revision %d type 0x%x ooffset 0x%x goffset 0x%x "
-        cFYI(1, ("revision %d type 0x%x ooffset 0x%x goffset 0x%x "
                 "sacloffset 0x%x dacloffset 0x%x",
                 pntsd->revision, pntsd->type, le32_to_cpu(pntsd->osidoffset),
                 le32_to_cpu(pntsd->gsidoffset),
                 le32_to_cpu(pntsd->sacloffset), dacloffset));
-#endif
 /*      cifs_dump_mem("owner_sid: ", owner_sid_ptr, 64); */
        rc = parse_sid(owner_sid_ptr, end_of_acl);
        if (rc)
@@ -571,9 +556,9 @@ static int build_sec_desc(struct cifs_ntsd *pntsd, struct cifs_ntsd *pnntsd,
 /* Retrieve an ACL from the server */
 static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
-                                       const char *path)
+                                       const char *path, const __u16 *pfid)
 {
-        struct cifsFileInfo *open_file;
+        struct cifsFileInfo *open_file = NULL;
        int unlock_file = FALSE;
        int xid;
        int rc = -EIO;
@@ -588,7 +573,11 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
                return NULL;
        xid = GetXid();
-        open_file = find_readable_file(CIFS_I(inode));
+        if (pfid == NULL)
+                open_file = find_readable_file(CIFS_I(inode));
+        else
+                fid = *pfid;
        sb = inode->i_sb;
        if (sb == NULL) {
                FreeXid(xid);
@@ -599,7 +588,7 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
        if (open_file) {
                unlock_file = TRUE;
                fid = open_file->netfid;
-        } else {
+        } else if (pfid == NULL) {
                int oplock = FALSE;
                /* open file */
                rc = CIFSSMBOpen(xid, cifs_sb->tcon, path, FILE_OPEN,
@@ -615,10 +604,11 @@ static struct cifs_ntsd *get_cifs_acl(u32 *pacllen, struct inode *inode,
        rc = CIFSSMBGetCIFSACL(xid, cifs_sb->tcon, fid, &pntsd, pacllen);
        cFYI(1, ("GetCIFSACL rc = %d ACL len %d", rc, *pacllen));
-        if (unlock_file == TRUE)
+        if (unlock_file == TRUE) /* find_readable_file increments ref count */
                atomic_dec(&open_file->wrtPending);
-        else
+        else if (pfid == NULL) /* if opened above we have to close the handle */
                CIFSSMBClose(xid, cifs_sb->tcon, fid);
+        /* else handle was passed in by caller */
        FreeXid(xid);
        return pntsd;
@@ -636,9 +626,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
        struct super_block *sb;
        struct cifs_sb_info *cifs_sb;
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("set ACL for %s from mode 0x%x", path, inode->i_mode));
-        cFYI(1, ("set ACL for %s from mode 0x%x", path, inode->i_mode));
-#endif
        if (!inode)
                return (rc);
@@ -669,9 +657,7 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
        }
        rc = CIFSSMBSetCIFSACL(xid, cifs_sb->tcon, fid, pnntsd, acllen);
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("SetCIFSACL rc = %d", rc));
-        cFYI(1, ("SetCIFSACL rc = %d", rc));
-#endif
        if (unlock_file == TRUE)
                atomic_dec(&open_file->wrtPending);
        else
@@ -683,16 +669,14 @@ static int set_cifs_acl(struct cifs_ntsd *pnntsd, __u32 acllen,
 }
 /* Translate the CIFS ACL (simlar to NTFS ACL) for a file into mode bits */
-void acl_to_uid_mode(struct inode *inode, const char *path)
+void acl_to_uid_mode(struct inode *inode, const char *path, const __u16 *pfid)
 {
        struct cifs_ntsd *pntsd = NULL;
        u32 acllen = 0;
        int rc = 0;
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("converting ACL to mode for %s", path));
-        cFYI(1, ("converting ACL to mode for %s", path));
+        pntsd = get_cifs_acl(&acllen, inode, path, pfid);
-#endif
-        pntsd = get_cifs_acl(&acllen, inode, path);
        /* if we can retrieve the ACL, now parse Access Control Entries, ACEs */
        if (pntsd)
@@ -712,12 +696,10 @@ int mode_to_acl(struct inode *inode, const char *path, __u64 nmode)
        struct cifs_ntsd *pntsd = NULL; /* acl obtained from server */
        struct cifs_ntsd *pnntsd = NULL; /* modified acl to be sent to server */
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("set ACL from mode for %s", path));
-        cFYI(1, ("set ACL from mode for %s", path));
-#endif
        /* Get the security descriptor */
-        pntsd = get_cifs_acl(&acllen, inode, path);
+        pntsd = get_cifs_acl(&acllen, inode, path, NULL);
        /* Add three ACEs for owner, group, everyone getting rid of
           other ACEs as chmod disables ACEs and set the security descriptor */
@@ -736,16 +718,12 @@ int mode_to_acl(struct inode *inode, const char *path, __u64 nmode)
                rc = build_sec_desc(pntsd, pnntsd, acllen, inode, nmode);
-#ifdef CONFIG_CIFS_DEBUG2
+                cFYI(DBG2, ("build_sec_desc rc: %d", rc));
-                cFYI(1, ("build_sec_desc rc: %d", rc));
-#endif
                if (!rc) {
                        /* Set the security descriptor */
                        rc = set_cifs_acl(pnntsd, acllen, inode, path);
-#ifdef CONFIG_CIFS_DEBUG2
+                        cFYI(DBG2, ("set_cifs_acl rc: %d", rc));
-                        cFYI(1, ("set_cifs_acl rc: %d", rc));
-#endif
                }
                kfree(pnntsd);
diff --git a/fs/cifs/cifsfs.c b/fs/cifs/cifsfs.c
index fcc434227691..a04b17e5a9d0 100644
--- a/fs/cifs/cifsfs.c
+++ b/fs/cifs/cifsfs.c
@@ -204,9 +204,8 @@ cifs_put_super(struct super_block *sb)
                return;
        }
        rc = cifs_umount(sb, cifs_sb);
-        if (rc) {
+        if (rc)
                cERROR(1, ("cifs_umount failed with return code %d", rc));
-        }
 #ifdef CONFIG_CIFS_DFS_UPCALL
        if (cifs_sb->mountdata) {
                kfree(cifs_sb->mountdata);
@@ -461,7 +460,7 @@ int cifs_xstate_get(struct super_block *sb, struct fs_quota_stat *qstats)
 static struct quotactl_ops cifs_quotactl_ops = {
        .set_xquota     = cifs_xquota_set,
-        .get_xquota     = cifs_xquota_set,
+        .get_xquota     = cifs_xquota_get,
        .set_xstate     = cifs_xstate_set,
        .get_xstate     = cifs_xstate_get,
 };
@@ -472,9 +471,7 @@ static void cifs_umount_begin(struct vfsmount *vfsmnt, int flags)
        struct cifs_sb_info *cifs_sb;
        struct cifsTconInfo *tcon;
-#ifdef CONFIG_CIFS_DFS_UPCALL
        dfs_shrink_umount_helper(vfsmnt);
-#endif /* CONFIG CIFS_DFS_UPCALL */
        if (!(flags & MNT_FORCE))
                return;
@@ -992,9 +989,7 @@ static int __init
 init_cifs(void)
 {
        int rc = 0;
-#ifdef CONFIG_PROC_FS
        cifs_proc_init();
-#endif
 /*      INIT_LIST_HEAD(&GlobalServerList);*/    /* BB not implemented yet */
        INIT_LIST_HEAD(&GlobalSMBSessionList);
        INIT_LIST_HEAD(&GlobalTreeConnectionList);
@@ -1095,19 +1090,15 @@ init_cifs(void)
 out_destroy_inodecache:
        cifs_destroy_inodecache();
 out_clean_proc:
-#ifdef CONFIG_PROC_FS
        cifs_proc_clean();
-#endif
        return rc;
 }
 static void __exit
 exit_cifs(void)
 {
-        cFYI(0, ("exit_cifs"));
+        cFYI(DBG2, ("exit_cifs"));
-#ifdef CONFIG_PROC_FS
        cifs_proc_clean();
-#endif
 #ifdef CONFIG_CIFS_DFS_UPCALL
        unregister_key_type(&key_type_dns_resolver);
 #endif
diff --git a/fs/cifs/cifsglob.h b/fs/cifs/cifsglob.h
index 5d32d8ddc82e..69a2e1942542 100644
--- a/fs/cifs/cifsglob.h
+++ b/fs/cifs/cifsglob.h
@@ -454,7 +454,7 @@ struct dir_notify_req {
 struct dfs_info3_param {
        int flags; /* DFSREF_REFERRAL_SERVER, DFSREF_STORAGE_SERVER*/
-        int PathConsumed;
+        int path_consumed;
        int server_type;
        int ref_flag;
        char *path_name;
diff --git a/fs/cifs/cifsproto.h b/fs/cifs/cifsproto.h
index 2f09f565a3d9..7e5e0e78cd72 100644
--- a/fs/cifs/cifsproto.h
+++ b/fs/cifs/cifsproto.h
@@ -39,8 +39,8 @@ extern int smb_send(struct socket *, struct smb_hdr *,
                        unsigned int /* length */ , struct sockaddr *);
 extern unsigned int _GetXid(void);
 extern void _FreeXid(unsigned int);
-#define GetXid() (int)_GetXid(); cFYI(1,("CIFS VFS: in %s as Xid: %d with uid: %d",__FUNCTION__, xid,current->fsuid));
+#define GetXid() (int)_GetXid(); cFYI(1,("CIFS VFS: in %s as Xid: %d with uid: %d",__func__, xid,current->fsuid));
-#define FreeXid(curr_xid) {_FreeXid(curr_xid); cFYI(1,("CIFS VFS: leaving %s (xid = %d) rc = %d",__FUNCTION__,curr_xid,(int)rc));}
+#define FreeXid(curr_xid) {_FreeXid(curr_xid); cFYI(1,("CIFS VFS: leaving %s (xid = %d) rc = %d",__func__,curr_xid,(int)rc));}
 extern char *build_path_from_dentry(struct dentry *);
 extern char *build_wildcard_path_from_dentry(struct dentry *direntry);
 /* extern void renew_parental_timestamps(struct dentry *direntry);*/
@@ -53,11 +53,11 @@ extern int SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
 extern int SendReceive2(const unsigned int /* xid */ , struct cifsSesInfo *,
                        struct kvec *, int /* nvec to send */,
                        int * /* type of buf returned */ , const int flags);
-extern int SendReceiveBlockingLock(const unsigned int /* xid */ ,
+extern int SendReceiveBlockingLock(const unsigned int xid,
-                                        struct cifsTconInfo *,
+                        struct cifsTconInfo *ptcon,
-                                struct smb_hdr * /* input */ ,
+                        struct smb_hdr *in_buf ,
-                                struct smb_hdr * /* out */ ,
+                        struct smb_hdr *out_buf,
-                                int * /* bytes returned */);
+                        int *bytes_returned);
 extern int checkSMB(struct smb_hdr *smb, __u16 mid, unsigned int length);
 extern int is_valid_oplock_break(struct smb_hdr *smb, struct TCP_Server_Info *);
 extern int is_size_safe_to_change(struct cifsInodeInfo *, __u64 eof);
@@ -84,7 +84,7 @@ extern __u16 GetNextMid(struct TCP_Server_Info *server);
 extern struct oplock_q_entry *AllocOplockQEntry(struct inode *, u16,
                                                 struct cifsTconInfo *);
 extern void DeleteOplockQEntry(struct oplock_q_entry *);
-extern struct timespec cifs_NTtimeToUnix(u64 /* utc nanoseconds since 1601 */ );
+extern struct timespec cifs_NTtimeToUnix(u64 utc_nanoseconds_since_1601);
 extern u64 cifs_UnixTimeToNT(struct timespec);
 extern __le64 cnvrtDosCifsTm(__u16 date, __u16 time);
 extern struct timespec cnvrtDosUnixTm(__u16 date, __u16 time);
@@ -92,11 +92,12 @@ extern struct timespec cnvrtDosUnixTm(__u16 date, __u16 time);
 extern int cifs_get_inode_info(struct inode **pinode,
                        const unsigned char *search_path,
                        FILE_ALL_INFO * pfile_info,
-                        struct super_block *sb, int xid);
+                        struct super_block *sb, int xid, const __u16 *pfid);
 extern int cifs_get_inode_info_unix(struct inode **pinode,
                        const unsigned char *search_path,
                        struct super_block *sb, int xid);
-extern void acl_to_uid_mode(struct inode *inode, const char *search_path);
+extern void acl_to_uid_mode(struct inode *inode, const char *path,
+                            const __u16 *pfid);
 extern int mode_to_acl(struct inode *inode, const char *path, __u64);
 extern int cifs_mount(struct super_block *, struct cifs_sb_info *, char *,
@@ -104,7 +105,11 @@ extern int cifs_mount(struct super_block *, struct cifs_sb_info *, char *,
 extern int cifs_umount(struct super_block *, struct cifs_sb_info *);
 #ifdef CONFIG_CIFS_DFS_UPCALL
 extern void dfs_shrink_umount_helper(struct vfsmount *vfsmnt);
-#endif
+#else
+static inline void dfs_shrink_umount_helper(struct vfsmount *vfsmnt)
+{
+}
+#endif /* DFS_UPCALL */
 void cifs_proc_init(void);
 void cifs_proc_clean(void);
@@ -175,11 +180,11 @@ extern int CIFSSMBQFSPosixInfo(const int xid, struct cifsTconInfo *tcon,
                        struct kstatfs *FSData);
 extern int CIFSSMBSetTimes(const int xid, struct cifsTconInfo *tcon,
-                        const char *fileName, const FILE_BASIC_INFO * data,
+                        const char *fileName, const FILE_BASIC_INFO *data,
                        const struct nls_table *nls_codepage,
                        int remap_special_chars);
 extern int CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
-                        const FILE_BASIC_INFO * data, __u16 fid);
+                        const FILE_BASIC_INFO *data, __u16 fid);
 #if 0
 extern int CIFSSMBSetAttrLegacy(int xid, struct cifsTconInfo *tcon,
                        char *fileName, __u16 dos_attributes,
diff --git a/fs/cifs/cifssmb.c b/fs/cifs/cifssmb.c
index 9409524e4bf8..30bbe448e260 100644
--- a/fs/cifs/cifssmb.c
+++ b/fs/cifs/cifssmb.c
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/cifssmb.c
 *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   Contains the routines for constructing the SMB PDUs themselves
@@ -102,10 +102,12 @@ static void mark_open_files_invalid(struct cifsTconInfo *pTcon)
           to this tcon */
 }
-/* If the return code is zero, this function must fill in request_buf pointer */
+/* Allocate and return pointer to an SMB request buffer, and set basic
+   SMB information in the SMB header.  If the return code is zero, this
+   function must have filled in request_buf pointer */
 static int
 small_smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
-         void **request_buf /* returned */)
+                void **request_buf)
 {
        int rc = 0;
@@ -363,7 +365,7 @@ smb_init(int smb_command, int wct, struct cifsTconInfo *tcon,
                *response_buf = *request_buf;
        header_assemble((struct smb_hdr *) *request_buf, smb_command, tcon,
-                        wct /*wct */ );
+                        wct);
        if (tcon != NULL)
                cifs_stats_inc(&tcon->num_smbs_sent);
@@ -523,7 +525,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
                        if (remain >= (MIN_TZ_ADJ / 2))
                                result += MIN_TZ_ADJ;
                        if (val < 0)
-                                result = - result;
+                                result = -result;
                        server->timeAdj = result;
                } else {
                        server->timeAdj = (int)tmp;
@@ -600,7 +602,7 @@ CIFSSMBNegotiate(unsigned int xid, struct cifsSesInfo *ses)
        server->maxBuf = min(le32_to_cpu(pSMBr->MaxBufferSize),
                        (__u32) CIFSMaxBufSize + MAX_CIFS_HDR_SIZE);
        server->maxRw = le32_to_cpu(pSMBr->MaxRawSize);
-        cFYI(0, ("Max buf = %d", ses->server->maxBuf));
+        cFYI(DBG2, ("Max buf = %d", ses->server->maxBuf));
        GETU32(ses->server->sessid) = le32_to_cpu(pSMBr->SessionKey);
        server->capabilities = le32_to_cpu(pSMBr->Capabilities);
        server->timeAdj = (int)(__s16)le16_to_cpu(pSMBr->ServerTimeZone);
@@ -868,9 +870,8 @@ PsxDelete:
        pSMB->ByteCount = cpu_to_le16(byte_count);
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Posix delete returned %d", rc));
-        }
        cifs_buf_release(pSMB);
        cifs_stats_inc(&tcon->num_deletes);
@@ -916,9 +917,8 @@ DelFileRetry:
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&tcon->num_deletes);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Error in RMFile = %d", rc));
-        }
        cifs_buf_release(pSMB);
        if (rc == -EAGAIN)
@@ -961,9 +961,8 @@ RmDirRetry:
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&tcon->num_rmdirs);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Error in RMDir = %d", rc));
-        }
        cifs_buf_release(pSMB);
        if (rc == -EAGAIN)
@@ -1005,9 +1004,8 @@ MkDirRetry:
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&tcon->num_mkdirs);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Error in Mkdir = %d", rc));
-        }
        cifs_buf_release(pSMB);
        if (rc == -EAGAIN)
@@ -1017,7 +1015,7 @@ MkDirRetry:
 int
 CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
-                __u64 mode, __u16 * netfid, FILE_UNIX_BASIC_INFO *pRetData,
+                __u64 mode, __u16 *netfid, FILE_UNIX_BASIC_INFO *pRetData,
                __u32 *pOplock, const char *name,
                const struct nls_table *nls_codepage, int remap)
 {
@@ -1027,8 +1025,8 @@ CIFSPOSIXCreate(const int xid, struct cifsTconInfo *tcon, __u32 posix_flags,
        int rc = 0;
        int bytes_returned = 0;
        __u16 params, param_offset, offset, byte_count, count;
-        OPEN_PSX_REQ * pdata;
+        OPEN_PSX_REQ *pdata;
-        OPEN_PSX_RSP * psx_rsp;
+        OPEN_PSX_RSP *psx_rsp;
        cFYI(1, ("In POSIX Create"));
 PsxCreat:
@@ -1110,9 +1108,7 @@ PsxCreat:
        /* check to make sure response data is there */
        if (psx_rsp->ReturnedLevel != cpu_to_le16(SMB_QUERY_FILE_UNIX_BASIC)) {
                pRetData->Type = cpu_to_le32(-1); /* unknown */
-#ifdef CONFIG_CIFS_DEBUG2
+                cFYI(DBG2, ("unknown type"));
-                cFYI(1, ("unknown type"));
-#endif
        } else {
                if (pSMBr->ByteCount < sizeof(OPEN_PSX_RSP)
                                        + sizeof(FILE_UNIX_BASIC_INFO)) {
@@ -1169,8 +1165,8 @@ static __u16 convert_disposition(int disposition)
 int
 SMBLegacyOpen(const int xid, struct cifsTconInfo *tcon,
            const char *fileName, const int openDisposition,
-            const int access_flags, const int create_options, __u16 * netfid,
+            const int access_flags, const int create_options, __u16 *netfid,
-            int *pOplock, FILE_ALL_INFO * pfile_info,
+            int *pOplock, FILE_ALL_INFO *pfile_info,
            const struct nls_table *nls_codepage, int remap)
 {
        int rc = -EACCES;
@@ -1221,8 +1217,8 @@ OldOpenRetry:
        if (create_options & CREATE_OPTION_SPECIAL)
                pSMB->FileAttributes = cpu_to_le16(ATTR_SYSTEM);
-        else
+        else /* BB FIXME BB */
-                pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/); /* BB FIXME */
+                pSMB->FileAttributes = cpu_to_le16(0/*ATTR_NORMAL*/);
        /* if ((omode & S_IWUGO) == 0)
                pSMB->FileAttributes |= cpu_to_le32(ATTR_READONLY);*/
@@ -1284,8 +1280,8 @@ OldOpenRetry:
 int
 CIFSSMBOpen(const int xid, struct cifsTconInfo *tcon,
            const char *fileName, const int openDisposition,
-            const int access_flags, const int create_options, __u16 * netfid,
+            const int access_flags, const int create_options, __u16 *netfid,
-            int *pOplock, FILE_ALL_INFO * pfile_info,
+            int *pOplock, FILE_ALL_INFO *pfile_info,
            const struct nls_table *nls_codepage, int remap)
 {
        int rc = -EACCES;
@@ -1556,9 +1552,9 @@ CIFSSMBWrite(const int xid, struct cifsTconInfo *tcon,
        } /* else setting file size with write of zero bytes */
        if (wct == 14)
                byte_count = bytes_sent + 1; /* pad */
-        else /* wct == 12 */ {
+        else /* wct == 12 */
                byte_count = bytes_sent + 5; /* bigger pad, smaller smb hdr */
-        }
        pSMB->DataLengthLow = cpu_to_le16(bytes_sent & 0xFFFF);
        pSMB->DataLengthHigh = cpu_to_le16(bytes_sent >> 16);
        pSMB->hdr.smb_buf_length += byte_count;
@@ -1663,7 +1659,7 @@ CIFSSMBWrite2(const int xid, struct cifsTconInfo *tcon,
                rc = -EIO;
                *nbytes = 0;
        } else {
-                WRITE_RSP * pSMBr = (WRITE_RSP *)iov[0].iov_base;
+                WRITE_RSP *pSMBr = (WRITE_RSP *)iov[0].iov_base;
                *nbytes = le16_to_cpu(pSMBr->CountHigh);
                *nbytes = (*nbytes) << 16;
                *nbytes += le16_to_cpu(pSMBr->Count);
@@ -1744,9 +1740,8 @@ CIFSSMBLock(const int xid, struct cifsTconInfo *tcon,
                /* SMB buffer freed by function above */
        }
        cifs_stats_inc(&tcon->num_locks);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Send error in Lock = %d", rc));
-        }
        /* Note: On -EAGAIN error only caller can retry on handle based calls
        since file handle passed in no longer valid */
@@ -1791,7 +1786,7 @@ CIFSSMBPosixLock(const int xid, struct cifsTconInfo *tcon,
        count = sizeof(struct cifs_posix_lock);
        pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
+        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
        pSMB->SetupCount = 1;
        pSMB->Reserved3 = 0;
        if (get_flag)
@@ -1972,9 +1967,8 @@ renameRetry:
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&tcon->num_renames);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Send error in rename = %d", rc));
-        }
        cifs_buf_release(pSMB);
@@ -2016,7 +2010,7 @@ int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
        data_offset = (char *) (&pSMB->hdr.Protocol) + offset;
        rename_info = (struct set_file_rename *) data_offset;
        pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB PDU from sess */
+        pSMB->MaxDataCount = cpu_to_le16(1000); /* BB find max SMB from sess */
        pSMB->SetupCount = 1;
        pSMB->Reserved3 = 0;
        pSMB->SubCommand = cpu_to_le16(TRANS2_SET_FILE_INFORMATION);
@@ -2052,9 +2046,8 @@ int CIFSSMBRenameOpenFile(const int xid, struct cifsTconInfo *pTcon,
        rc = SendReceive(xid, pTcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&pTcon->num_t2renames);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Send error in Rename (by file handle) = %d", rc));
-        }
        cifs_buf_release(pSMB);
@@ -2211,9 +2204,8 @@ createSymLinkRetry:
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&tcon->num_symlinks);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Send error in SetPathInfo create symlink = %d", rc));
-        }
        if (pSMB)
                cifs_buf_release(pSMB);
@@ -2299,9 +2291,8 @@ createHardLinkRetry:
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&tcon->num_hardlinks);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Send error in SetPathInfo (hard link) = %d", rc));
-        }
        cifs_buf_release(pSMB);
        if (rc == -EAGAIN)
@@ -2370,9 +2361,9 @@ winCreateHardLinkRetry:
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        cifs_stats_inc(&tcon->num_hardlinks);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Send error in hard link (NT rename) = %d", rc));
-        }
        cifs_buf_release(pSMB);
        if (rc == -EAGAIN)
                goto winCreateHardLinkRetry;
@@ -2968,9 +2959,8 @@ setAclRetry:
        pSMB->ByteCount = cpu_to_le16(byte_count);
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Set POSIX ACL returned %d", rc));
-        }
 setACLerrorExit:
        cifs_buf_release(pSMB);
@@ -2982,7 +2972,7 @@ setACLerrorExit:
 /* BB fix tabs in this function FIXME BB */
 int
 CIFSGetExtAttr(const int xid, struct cifsTconInfo *tcon,
-               const int netfid, __u64 * pExtAttrBits, __u64 *pMask)
+               const int netfid, __u64 *pExtAttrBits, __u64 *pMask)
 {
        int rc = 0;
        struct smb_t2_qfi_req *pSMB = NULL;
@@ -3000,7 +2990,7 @@ GetExtAttrRetry:
        if (rc)
                return rc;
-        params = 2 /* level */ +2 /* fid */;
+        params = 2 /* level */ + 2 /* fid */;
        pSMB->t2.TotalDataCount = 0;
        pSMB->t2.MaxParameterCount = cpu_to_le16(4);
        /* BB find exact max data count below from sess structure BB */
@@ -3071,7 +3061,7 @@ CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
 {
        int rc = 0;
        int buf_type = 0;
-        QUERY_SEC_DESC_REQ * pSMB;
+        QUERY_SEC_DESC_REQ *pSMB;
        struct kvec iov[1];
        cFYI(1, ("GetCifsACL"));
@@ -3101,7 +3091,7 @@ CIFSSMBGetCIFSACL(const int xid, struct cifsTconInfo *tcon, __u16 fid,
        if (rc) {
                cFYI(1, ("Send error in QuerySecDesc = %d", rc));
        } else {                /* decode response */
-                __le32 * parm;
+                __le32 *parm;
                __u32 parm_len;
                __u32 acl_len;
                struct smb_com_ntransact_rsp *pSMBr;
@@ -3230,8 +3220,8 @@ int SMBQueryInformation(const int xid, struct cifsTconInfo *tcon,
                        FILE_ALL_INFO *pFinfo,
                        const struct nls_table *nls_codepage, int remap)
 {
-        QUERY_INFORMATION_REQ * pSMB;
+        QUERY_INFORMATION_REQ *pSMB;
-        QUERY_INFORMATION_RSP * pSMBr;
+        QUERY_INFORMATION_RSP *pSMBr;
        int rc = 0;
        int bytes_returned;
        int name_len;
@@ -3263,9 +3253,11 @@ QInfRetry:
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
        if (rc) {
                cFYI(1, ("Send error in QueryInfo = %d", rc));
-        } else if (pFinfo) {            /* decode response */
+        } else if (pFinfo) {
                struct timespec ts;
                __u32 time = le32_to_cpu(pSMBr->last_write_time);
+                /* decode response */
                /* BB FIXME - add time zone adjustment BB */
                memset(pFinfo, 0, sizeof(FILE_ALL_INFO));
                ts.tv_nsec = 0;
@@ -3296,7 +3288,7 @@ QInfRetry:
 int
 CIFSSMBQPathInfo(const int xid, struct cifsTconInfo *tcon,
                 const unsigned char *searchName,
-                 FILE_ALL_INFO * pFindData,
+                 FILE_ALL_INFO *pFindData,
                 int legacy /* old style infolevel */,
                 const struct nls_table *nls_codepage, int remap)
 {
@@ -3371,10 +3363,12 @@ QPathInfoRetry:
                else if (pFindData) {
                        int size;
                        __u16 data_offset = le16_to_cpu(pSMBr->t2.DataOffset);
-                        if (legacy) /* we do not read the last field, EAsize,
-                                       fortunately since it varies by subdialect
+                        /* On legacy responses we do not read the last field,
-                                       and on Set vs. Get, is two bytes or 4
+                        EAsize, fortunately since it varies by subdialect and
-                                       bytes depending but we don't care here */
+                        also note it differs on Set vs. Get, ie two bytes or 4
+                        bytes depending but we don't care here */
+                        if (legacy)
                                size = sizeof(FILE_INFO_STANDARD);
                        else
                                size = sizeof(FILE_ALL_INFO);
@@ -3476,85 +3470,6 @@ UnixQPathInfoRetry:
        return rc;
 }
-#if 0  /* function unused at present */
-int CIFSFindSingle(const int xid, struct cifsTconInfo *tcon,
-               const char *searchName, FILE_ALL_INFO * findData,
-               const struct nls_table *nls_codepage)
-{
-/* level 257 SMB_ */
-        TRANSACTION2_FFIRST_REQ *pSMB = NULL;
-        TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
-        int rc = 0;
-        int bytes_returned;
-        int name_len;
-        __u16 params, byte_count;
-        cFYI(1, ("In FindUnique"));
-findUniqueRetry:
-        rc = smb_init(SMB_COM_TRANSACTION2, 15, tcon, (void **) &pSMB,
-                      (void **) &pSMBr);
-        if (rc)
-                return rc;
-        if (pSMB->hdr.Flags2 & SMBFLG2_UNICODE) {
-                name_len =
-                    cifsConvertToUCS((__le16 *) pSMB->FileName, searchName,
-                                     PATH_MAX, nls_codepage);
-                name_len++;     /* trailing null */
-                name_len *= 2;
-        } else {        /* BB improve the check for buffer overruns BB */
-                name_len = strnlen(searchName, PATH_MAX);
-                name_len++;     /* trailing null */
-                strncpy(pSMB->FileName, searchName, name_len);
-        }
-        params = 12 + name_len /* includes null */ ;
-        pSMB->TotalDataCount = 0;       /* no EAs */
-        pSMB->MaxParameterCount = cpu_to_le16(2);
-        pSMB->MaxDataCount = cpu_to_le16(4000); /* BB find exact max SMB PDU from sess structure BB */
-        pSMB->MaxSetupCount = 0;
-        pSMB->Reserved = 0;
-        pSMB->Flags = 0;
-        pSMB->Timeout = 0;
-        pSMB->Reserved2 = 0;
-        pSMB->ParameterOffset = cpu_to_le16(
-         offsetof(struct smb_com_transaction2_ffirst_req, InformationLevel)-4);
-        pSMB->DataCount = 0;
-        pSMB->DataOffset = 0;
-        pSMB->SetupCount = 1;   /* one byte, no need to le convert */
-        pSMB->Reserved3 = 0;
-        pSMB->SubCommand = cpu_to_le16(TRANS2_FIND_FIRST);
-        byte_count = params + 1 /* pad */ ;
-        pSMB->TotalParameterCount = cpu_to_le16(params);
-        pSMB->ParameterCount = pSMB->TotalParameterCount;
-        pSMB->SearchAttributes =
-            cpu_to_le16(ATTR_READONLY | ATTR_HIDDEN | ATTR_SYSTEM |
-                        ATTR_DIRECTORY);
-        pSMB->SearchCount = cpu_to_le16(16);    /* BB increase */
-        pSMB->SearchFlags = cpu_to_le16(1);
-        pSMB->InformationLevel = cpu_to_le16(SMB_FIND_FILE_DIRECTORY_INFO);
-        pSMB->SearchStorageType = 0;    /* BB what should we set this to? BB */
-        pSMB->hdr.smb_buf_length += byte_count;
-        pSMB->ByteCount = cpu_to_le16(byte_count);
-        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
-                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
-                cFYI(1, ("Send error in FindFileDirInfo = %d", rc));
-        } else {                /* decode response */
-                cifs_stats_inc(&tcon->num_ffirst);
-                /* BB fill in */
-        }
-        cifs_buf_release(pSMB);
-        if (rc == -EAGAIN)
-                goto findUniqueRetry;
-        return rc;
-}
-#endif /* end unused (temporarily) function */
 /* xid, tcon, searchName and codepage are input parms, rest are returned */
 int
 CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
@@ -3566,7 +3481,7 @@ CIFSFindFirst(const int xid, struct cifsTconInfo *tcon,
 /* level 257 SMB_ */
        TRANSACTION2_FFIRST_REQ *pSMB = NULL;
        TRANSACTION2_FFIRST_RSP *pSMBr = NULL;
-        T2_FFIRST_RSP_PARMS * parms;
+        T2_FFIRST_RSP_PARMS *parms;
        int rc = 0;
        int bytes_returned = 0;
        int name_len;
@@ -3697,7 +3612,7 @@ int CIFSFindNext(const int xid, struct cifsTconInfo *tcon,
 {
        TRANSACTION2_FNEXT_REQ *pSMB = NULL;
        TRANSACTION2_FNEXT_RSP *pSMBr = NULL;
-        T2_FNEXT_RSP_PARMS * parms;
+        T2_FNEXT_RSP_PARMS *parms;
        char *response_data;
        int rc = 0;
        int bytes_returned, name_len;
@@ -3836,9 +3751,9 @@ CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
        pSMB->FileID = searchHandle;
        pSMB->ByteCount = 0;
        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
-        if (rc) {
+        if (rc)
                cERROR(1, ("Send error in FindClose = %d", rc));
-        }
        cifs_stats_inc(&tcon->num_fclose);
        /* Since session is dead, search handle closed on server already */
@@ -3851,7 +3766,7 @@ CIFSFindClose(const int xid, struct cifsTconInfo *tcon,
 int
 CIFSGetSrvInodeNumber(const int xid, struct cifsTconInfo *tcon,
                      const unsigned char *searchName,
-                      __u64 * inode_number,
+                      __u64 *inode_number,
                      const struct nls_table *nls_codepage, int remap)
 {
        int rc = 0;
@@ -4560,9 +4475,8 @@ SETFSUnixRetry:
                cERROR(1, ("Send error in SETFSUnixInfo = %d", rc));
        } else {                /* decode response */
                rc = validate_t2((struct smb_t2_rsp *)pSMBr);
-                if (rc) {
+                if (rc)
                        rc = -EIO;      /* bad smb */
-                }
        }
        cifs_buf_release(pSMB);
@@ -4744,9 +4658,8 @@ SetEOFRetry:
        pSMB->ByteCount = cpu_to_le16(byte_count);
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("SetPathInfo (file size) returned %d", rc));
-        }
        cifs_buf_release(pSMB);
@@ -4897,9 +4810,8 @@ CIFSSMBSetFileTimes(const int xid, struct cifsTconInfo *tcon,
        pSMB->ByteCount = cpu_to_le16(byte_count);
        memcpy(data_offset, data, sizeof(FILE_BASIC_INFO));
        rc = SendReceiveNoRsp(xid, tcon->ses, (struct smb_hdr *) pSMB, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Send error in Set Time (SetFileInfo) = %d", rc));
-        }
        /* Note: On -EAGAIN error only caller can retry on handle based calls
                since file handle passed in no longer valid */
@@ -4975,9 +4887,8 @@ SetTimesRetry:
        pSMB->ByteCount = cpu_to_le16(byte_count);
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("SetPathInfo (times) returned %d", rc));
-        }
        cifs_buf_release(pSMB);
@@ -5027,9 +4938,8 @@ SetAttrLgcyRetry:
        pSMB->ByteCount = cpu_to_le16(name_len + 1);
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("Error in LegacySetAttr = %d", rc));
-        }
        cifs_buf_release(pSMB);
@@ -5138,9 +5048,8 @@ setPermsRetry:
        pSMB->ByteCount = cpu_to_le16(byte_count);
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("SetPathInfo (perms) returned %d", rc));
-        }
        if (pSMB)
                cifs_buf_release(pSMB);
@@ -5615,9 +5524,8 @@ SetEARetry:
        pSMB->ByteCount = cpu_to_le16(byte_count);
        rc = SendReceive(xid, tcon->ses, (struct smb_hdr *) pSMB,
                         (struct smb_hdr *) pSMBr, &bytes_returned, 0);
-        if (rc) {
+        if (rc)
                cFYI(1, ("SetPathInfo (EA) returned %d", rc));
-        }
        cifs_buf_release(pSMB);
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 65d0ba72e78f..8dbfa97cd18c 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1722,8 +1722,15 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
                           originally at mount time */
                        if ((saved_cap & CIFS_UNIX_POSIX_ACL_CAP) == 0)
                                cap &= ~CIFS_UNIX_POSIX_ACL_CAP;
-                        if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0)
+                        if ((saved_cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
+                                if (cap & CIFS_UNIX_POSIX_PATHNAMES_CAP)
+                                        cERROR(1, ("POSIXPATH support change"));
                                cap &= ~CIFS_UNIX_POSIX_PATHNAMES_CAP;
+                        } else if ((cap & CIFS_UNIX_POSIX_PATHNAMES_CAP) == 0) {
+                                cERROR(1, ("possible reconnect error"));
+                                cERROR(1,
+                                        ("server disabled POSIX path support"));
+                        }
                }
                cap &= CIFS_UNIX_CAP_MASK;
@@ -1753,9 +1760,8 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
                if (sb && (CIFS_SB(sb)->rsize > 127 * 1024)) {
                        if ((cap & CIFS_UNIX_LARGE_READ_CAP) == 0) {
                                CIFS_SB(sb)->rsize = 127 * 1024;
-#ifdef CONFIG_CIFS_DEBUG2
+                                cFYI(DBG2,
-                                cFYI(1, ("larger reads not supported by srv"));
+                                        ("larger reads not supported by srv"));
-#endif
                        }
                }
@@ -1792,6 +1798,26 @@ void reset_cifs_unix_caps(int xid, struct cifsTconInfo *tcon,
        }
 }
+static void
+convert_delimiter(char *path, char delim)
+{
+        int i;
+        char old_delim;
+        if (path == NULL)
+                return;
+        if (delim == '/') 
+                old_delim = '\\';
+        else
+                old_delim = '/';
+        for (i = 0; path[i] != '\0'; i++) {
+                if (path[i] == old_delim)
+                        path[i] = delim;
+        }
+}
 int
 cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
           char *mount_data, const char *devname)
@@ -2057,7 +2083,11 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                cifs_sb->prepath = volume_info.prepath;
                if (cifs_sb->prepath) {
                        cifs_sb->prepathlen = strlen(cifs_sb->prepath);
-                        cifs_sb->prepath[0] = CIFS_DIR_SEP(cifs_sb);
+                        /* we can not convert the / to \ in the path
+                        separators in the prefixpath yet because we do not
+                        know (until reset_cifs_unix_caps is called later)
+                        whether POSIX PATH CAP is available. We normalize
+                        the / to \ after reset_cifs_unix_caps is called */
                        volume_info.prepath = NULL;
                } else
                        cifs_sb->prepathlen = 0;
@@ -2225,11 +2255,15 @@ cifs_mount(struct super_block *sb, struct cifs_sb_info *cifs_sb,
                else
                        tcon->unix_ext = 0; /* server does not support them */
+                /* convert forward to back slashes in prepath here if needed */
+                if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_POSIX_PATHS) == 0)
+                        convert_delimiter(cifs_sb->prepath,
+                                          CIFS_DIR_SEP(cifs_sb));
                if ((tcon->unix_ext == 0) && (cifs_sb->rsize > (1024 * 127))) {
                        cifs_sb->rsize = 1024 * 127;
-#ifdef CONFIG_CIFS_DEBUG2
+                        cFYI(DBG2,
-                        cFYI(1, ("no very large read support, rsize now 127K"));
+                                ("no very large read support, rsize now 127K"));
-#endif
                }
                if (!(tcon->ses->capabilities & CAP_LARGE_WRITE_X))
                        cifs_sb->wsize = min(cifs_sb->wsize,
diff --git a/fs/cifs/dir.c b/fs/cifs/dir.c
index 699ec1198409..0f5c62ba4038 100644
--- a/fs/cifs/dir.c
+++ b/fs/cifs/dir.c
@@ -3,7 +3,7 @@
 *
 *   vfs operations that deal with dentries
 *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
@@ -111,16 +111,6 @@ cifs_bp_rename_retry:
        return full_path;
 }
-/* char * build_wildcard_path_from_dentry(struct dentry *direntry)
-{
-        if(full_path == NULL)
-                return full_path;
-        full_path[namelen] = '\\';
-        full_path[namelen+1] = '*';
-        full_path[namelen+2] = 0;
-BB remove above eight lines BB */
 /* Inode operations in similar order to how they appear in Linux file fs.h */
 int
@@ -171,9 +161,8 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                        disposition = FILE_OVERWRITE_IF;
                else if ((oflags & O_CREAT) == O_CREAT)
                        disposition = FILE_OPEN_IF;
-                else {
+                else
                        cFYI(1, ("Create flag not set in create function"));
-                }
        }
        /* BB add processing to set equivalent of mode - e.g. via CreateX with
@@ -240,7 +229,8 @@ cifs_create(struct inode *inode, struct dentry *direntry, int mode,
                                                 inode->i_sb, xid);
                else {
                        rc = cifs_get_inode_info(&newinode, full_path,
-                                                 buf, inode->i_sb, xid);
+                                                 buf, inode->i_sb, xid,
+                                                 &fileHandle);
                        if (newinode) {
                                newinode->i_mode = mode;
                                if ((oplock & CIFS_CREATE_ACTION) &&
@@ -367,7 +357,7 @@ int cifs_mknod(struct inode *inode, struct dentry *direntry, int mode,
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
                        int oplock = 0;
                        u16 fileHandle;
-                        FILE_ALL_INFO * buf;
+                        FILE_ALL_INFO *buf;
                        cFYI(1, ("sfu compat create special file"));
@@ -494,7 +484,7 @@ cifs_lookup(struct inode *parent_dir_inode, struct dentry *direntry,
                                              parent_dir_inode->i_sb, xid);
        else
                rc = cifs_get_inode_info(&newInode, full_path, NULL,
-                                         parent_dir_inode->i_sb, xid);
+                                         parent_dir_inode->i_sb, xid, NULL);
        if ((rc == 0) && (newInode != NULL)) {
                if (pTcon->nocase)
@@ -534,9 +524,8 @@ cifs_d_revalidate(struct dentry *direntry, struct nameidata *nd)
        int isValid = 1;
        if (direntry->d_inode) {
-                if (cifs_revalidate(direntry)) {
+                if (cifs_revalidate(direntry))
                        return 0;
-                }
        } else {
                cFYI(1, ("neg dentry 0x%p name = %s",
                         direntry, direntry->d_name.name));
diff --git a/fs/cifs/dns_resolve.c b/fs/cifs/dns_resolve.c
index ef7f43824347..7cc86c418182 100644
--- a/fs/cifs/dns_resolve.c
+++ b/fs/cifs/dns_resolve.c
@@ -77,14 +77,14 @@ dns_resolve_server_name_to_ip(const char *unc, char **ip_addr)
        /* search for server name delimiter */
        len = strlen(unc);
        if (len < 3) {
-                cFYI(1, ("%s: unc is too short: %s", __FUNCTION__, unc));
+                cFYI(1, ("%s: unc is too short: %s", __func__, unc));
                return -EINVAL;
        }
        len -= 2;
        name = memchr(unc+2, '\\', len);
        if (!name) {
                cFYI(1, ("%s: probably server name is whole unc: %s",
-                                        __FUNCTION__, unc));
+                                        __func__, unc));
        } else {
                len = (name - unc) - 2/* leading // */;
        }
@@ -104,7 +104,7 @@ dns_resolve_server_name_to_ip(const char *unc, char **ip_addr)
                if (*ip_addr) {
                        memcpy(*ip_addr, rkey->payload.data, len);
                        (*ip_addr)[len] = '\0';
-                        cFYI(1, ("%s: resolved: %s to %s", __FUNCTION__,
+                        cFYI(1, ("%s: resolved: %s to %s", __func__,
                                        rkey->description,
                                        *ip_addr
                                ));
@@ -114,7 +114,7 @@ dns_resolve_server_name_to_ip(const char *unc, char **ip_addr)
                }
                key_put(rkey);
        } else {
-                cERROR(1, ("%s: unable to resolve: %s", __FUNCTION__, name));
+                cERROR(1, ("%s: unable to resolve: %s", __func__, name));
        }
        kfree(name);
diff --git a/fs/cifs/dns_resolve.h b/fs/cifs/dns_resolve.h
index 073fdc3db419..966e9288930b 100644
--- a/fs/cifs/dns_resolve.h
+++ b/fs/cifs/dns_resolve.h
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/dns_resolve.h -- DNS Resolver upcall management for CIFS DFS
 *                            Handles host name to IP address resolution
- * 
+ *
 *   Copyright (c) International Business Machines  Corp., 2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
diff --git a/fs/cifs/fcntl.c b/fs/cifs/fcntl.c
index 995474c90885..7d1d5aa4c430 100644
--- a/fs/cifs/fcntl.c
+++ b/fs/cifs/fcntl.c
@@ -35,9 +35,8 @@ static __u32 convert_to_cifs_notify_flags(unsigned long fcntl_notify_flags)
        /* No way on Linux VFS to ask to monitor xattr
        changes (and no stream support either */
-        if (fcntl_notify_flags & DN_ACCESS) {
+        if (fcntl_notify_flags & DN_ACCESS)
                cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_ACCESS;
-        }
        if (fcntl_notify_flags & DN_MODIFY) {
                /* What does this mean on directories? */
                cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_WRITE |
@@ -47,9 +46,8 @@ static __u32 convert_to_cifs_notify_flags(unsigned long fcntl_notify_flags)
                cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_CREATION |
                        FILE_NOTIFY_CHANGE_LAST_WRITE;
        }
-        if (fcntl_notify_flags & DN_DELETE) {
+        if (fcntl_notify_flags & DN_DELETE)
                cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_LAST_WRITE;
-        }
        if (fcntl_notify_flags & DN_RENAME) {
                /* BB review this - checking various server behaviors */
                cifs_ntfy_flags |= FILE_NOTIFY_CHANGE_DIR_NAME |
diff --git a/fs/cifs/file.c b/fs/cifs/file.c
index 5f7c374ae89c..40b690073fc1 100644
--- a/fs/cifs/file.c
+++ b/fs/cifs/file.c
@@ -145,7 +145,7 @@ client_can_cache:
                        full_path, inode->i_sb, xid);
        else
                rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
-                        full_path, buf, inode->i_sb, xid);
+                        full_path, buf, inode->i_sb, xid, NULL);
        if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
                pCifsInode->clientCanCacheAll = TRUE;
@@ -353,9 +353,9 @@ static int cifs_reopen_file(struct file *file, int can_flush)
        int disposition = FILE_OPEN;
        __u16 netfid;
-        if (file->private_data) {
+        if (file->private_data)
                pCifsFile = (struct cifsFileInfo *)file->private_data;
-        } else
+        else
                return -EBADF;
        xid = GetXid();
@@ -440,7 +440,7 @@ reopen_error_exit:
                                else
                                        rc = cifs_get_inode_info(&inode,
                                                full_path, NULL, inode->i_sb,
-                                                xid);
+                                                xid, NULL);
                        } /* else we are writing out data to server already
                             and could deadlock if we tried to flush data, and
                             since we do not know if we have data that would
@@ -499,9 +499,8 @@ int cifs_close(struct inode *inode, struct file *file)
                                        the struct would be in each open file,
                                        but this should give enough time to
                                        clear the socket */
-#ifdef CONFIG_CIFS_DEBUG2
+                                        cFYI(DBG2,
-                                        cFYI(1, ("close delay, write pending"));
+                                                ("close delay, write pending"));
-#endif /* DEBUG2 */
                                        msleep(timeout);
                                        timeout *= 4;
                                }
@@ -1423,9 +1422,8 @@ static int cifs_writepage(struct page *page, struct writeback_control *wbc)
        xid = GetXid();
 /* BB add check for wbc flags */
        page_cache_get(page);
-        if (!PageUptodate(page)) {
+        if (!PageUptodate(page))
                cFYI(1, ("ppw - page not up to date"));
-        }
        /*
         * Set the "writeback" flag, and clear "dirty" in the radix tree.
@@ -1460,9 +1458,9 @@ static int cifs_commit_write(struct file *file, struct page *page,
        cFYI(1, ("commit write for page %p up to position %lld for %d",
                 page, position, to));
        spin_lock(&inode->i_lock);
-        if (position > inode->i_size) {
+        if (position > inode->i_size)
                i_size_write(inode, position);
-        }
        spin_unlock(&inode->i_lock);
        if (!PageUptodate(page)) {
                position =  ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
@@ -1596,9 +1594,9 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
        }
        open_file = (struct cifsFileInfo *)file->private_data;
-        if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
+        if ((file->f_flags & O_ACCMODE) == O_WRONLY)
                cFYI(1, ("attempting read on write only file instance"));
-        }
        for (total_read = 0, current_offset = read_data;
             read_size > total_read;
             total_read += bytes_read, current_offset += bytes_read) {
@@ -1625,9 +1623,8 @@ ssize_t cifs_user_read(struct file *file, char __user *read_data,
                                                smb_read_data +
                                                4 /* RFC1001 length field */ +
                                                le16_to_cpu(pSMBr->DataOffset),
-                                                bytes_read)) {
+                                                bytes_read))
                                        rc = -EFAULT;
-                                }
                                if (buf_type == CIFS_SMALL_BUFFER)
                                        cifs_small_buf_release(smb_read_data);
@@ -1814,9 +1811,7 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
        pTcon = cifs_sb->tcon;
        pagevec_init(&lru_pvec, 0);
-#ifdef CONFIG_CIFS_DEBUG2
+                cFYI(DBG2, ("rpages: num pages %d", num_pages));
-                cFYI(1, ("rpages: num pages %d", num_pages));
-#endif
        for (i = 0; i < num_pages; ) {
                unsigned contig_pages;
                struct page *tmp_page;
@@ -1849,10 +1844,8 @@ static int cifs_readpages(struct file *file, struct address_space *mapping,
                /* Read size needs to be in multiples of one page */
                read_size = min_t(const unsigned int, read_size,
                                  cifs_sb->rsize & PAGE_CACHE_MASK);
-#ifdef CONFIG_CIFS_DEBUG2
+                cFYI(DBG2, ("rpages: read size 0x%x  contiguous pages %d",
-                cFYI(1, ("rpages: read size 0x%x  contiguous pages %d",
                                read_size, contig_pages));
-#endif
                rc = -EAGAIN;
                while (rc == -EAGAIN) {
                        if ((open_file->invalidHandle) &&
@@ -2026,7 +2019,7 @@ int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
                struct cifs_sb_info *cifs_sb;
                cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
-                if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
                        /* since no page cache to corrupt on directio
                        we can change size safely */
                        return 1;
diff --git a/fs/cifs/inode.c b/fs/cifs/inode.c
index b1a4a65eaa08..bc673c8c1e6b 100644
--- a/fs/cifs/inode.c
+++ b/fs/cifs/inode.c
@@ -29,6 +29,162 @@
 #include "cifs_debug.h"
 #include "cifs_fs_sb.h"
+static void cifs_set_ops(struct inode *inode, const bool is_dfs_referral)
+{
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+        switch (inode->i_mode & S_IFMT) {
+        case S_IFREG:
+                inode->i_op = &cifs_file_inode_ops;
+                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
+                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                                inode->i_fop = &cifs_file_direct_nobrl_ops;
+                        else
+                                inode->i_fop = &cifs_file_direct_ops;
+                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+                        inode->i_fop = &cifs_file_nobrl_ops;
+                else { /* not direct, send byte range locks */
+                        inode->i_fop = &cifs_file_ops;
+                }
+                /* check if server can support readpages */
+                if (cifs_sb->tcon->ses->server->maxBuf <
+                                PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
+                        inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
+                else
+                        inode->i_data.a_ops = &cifs_addr_ops;
+                break;
+        case S_IFDIR:
+#ifdef CONFIG_CIFS_DFS_UPCALL
+                if (is_dfs_referral) {
+                        inode->i_op = &cifs_dfs_referral_inode_operations;
+                } else {
+#else /* NO DFS support, treat as a directory */
+                {
+#endif
+                        inode->i_op = &cifs_dir_inode_ops;
+                        inode->i_fop = &cifs_dir_ops;
+                }
+                break;
+        case S_IFLNK:
+                inode->i_op = &cifs_symlink_inode_ops;
+                break;
+        default:
+                init_special_inode(inode, inode->i_mode, inode->i_rdev);
+                break;
+        }
+}
+static void cifs_unix_info_to_inode(struct inode *inode,
+                FILE_UNIX_BASIC_INFO *info, int force_uid_gid)
+{
+        struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
+        struct cifsInodeInfo *cifsInfo = CIFS_I(inode);
+        __u64 num_of_bytes = le64_to_cpu(info->NumOfBytes);
+        __u64 end_of_file = le64_to_cpu(info->EndOfFile);
+        inode->i_atime = cifs_NTtimeToUnix(le64_to_cpu(info->LastAccessTime));
+        inode->i_mtime =
+                cifs_NTtimeToUnix(le64_to_cpu(info->LastModificationTime));
+        inode->i_ctime = cifs_NTtimeToUnix(le64_to_cpu(info->LastStatusChange));
+        inode->i_mode = le64_to_cpu(info->Permissions);
+        /*
+         * Since we set the inode type below we need to mask off
+         * to avoid strange results if bits set above.
+         */
+        inode->i_mode &= ~S_IFMT;
+        switch (le32_to_cpu(info->Type)) {
+        case UNIX_FILE:
+                inode->i_mode |= S_IFREG;
+                break;
+        case UNIX_SYMLINK:
+                inode->i_mode |= S_IFLNK;
+                break;
+        case UNIX_DIR:
+                inode->i_mode |= S_IFDIR;
+                break;
+        case UNIX_CHARDEV:
+                inode->i_mode |= S_IFCHR;
+                inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
+                                      le64_to_cpu(info->DevMinor) & MINORMASK);
+                break;
+        case UNIX_BLOCKDEV:
+                inode->i_mode |= S_IFBLK;
+                inode->i_rdev = MKDEV(le64_to_cpu(info->DevMajor),
+                                      le64_to_cpu(info->DevMinor) & MINORMASK);
+                break;
+        case UNIX_FIFO:
+                inode->i_mode |= S_IFIFO;
+                break;
+        case UNIX_SOCKET:
+                inode->i_mode |= S_IFSOCK;
+                break;
+        default:
+                /* safest to call it a file if we do not know */
+                inode->i_mode |= S_IFREG;
+                cFYI(1, ("unknown type %d", le32_to_cpu(info->Type)));
+                break;
+        }
+        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID) &&
+            !force_uid_gid)
+                inode->i_uid = cifs_sb->mnt_uid;
+        else
+                inode->i_uid = le64_to_cpu(info->Uid);
+        if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID) &&
+            !force_uid_gid)
+                inode->i_gid = cifs_sb->mnt_gid;
+        else
+                inode->i_gid = le64_to_cpu(info->Gid);
+        inode->i_nlink = le64_to_cpu(info->Nlinks);
+        spin_lock(&inode->i_lock);
+        if (is_size_safe_to_change(cifsInfo, end_of_file)) {
+                /*
+                 * We can not safely change the file size here if the client
+                 * is writing to it due to potential races.
+                 */
+                i_size_write(inode, end_of_file);
+                /*
+                 * i_blocks is not related to (i_size / i_blksize),
+                 * but instead 512 byte (2**9) size is required for
+                 * calculating num blocks.
+                 */
+                inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
+        }
+        spin_unlock(&inode->i_lock);
+}
+static const unsigned char *cifs_get_search_path(struct cifsTconInfo *pTcon,
+                                        const char *search_path)
+{
+        int tree_len;
+        int path_len;
+        char *tmp_path;
+        if (!(pTcon->Flags & SMB_SHARE_IS_IN_DFS))
+                return search_path;
+        /* use full path name for working with DFS */
+        tree_len = strnlen(pTcon->treeName, MAX_TREE_SIZE + 1);
+        path_len = strnlen(search_path, MAX_PATHCONF);
+        tmp_path = kmalloc(tree_len+path_len+1, GFP_KERNEL);
+        if (tmp_path == NULL)
+                return search_path;
+        strncpy(tmp_path, pTcon->treeName, tree_len);
+        strncpy(tmp_path+tree_len, search_path, path_len);
+        tmp_path[tree_len+path_len] = 0;
+        return tmp_path;
+}
 int cifs_get_inode_info_unix(struct inode **pinode,
        const unsigned char *search_path, struct super_block *sb, int xid)
 {
@@ -37,52 +193,43 @@ int cifs_get_inode_info_unix(struct inode **pinode,
        struct cifsTconInfo *pTcon;
        struct inode *inode;
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
-        char *tmp_path;
+        const unsigned char *full_path;
+        bool is_dfs_referral = false;
        pTcon = cifs_sb->tcon;
        cFYI(1, ("Getting info on %s", search_path));
+        full_path = cifs_get_search_path(pTcon, search_path);
+try_again_CIFSSMBUnixQPathInfo:
        /* could have done a find first instead but this returns more info */
-        rc = CIFSSMBUnixQPathInfo(xid, pTcon, search_path, &findData,
+        rc = CIFSSMBUnixQPathInfo(xid, pTcon, full_path, &findData,
                                  cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
 /*      dump_mem("\nUnixQPathInfo return data", &findData,
                 sizeof(findData)); */
        if (rc) {
-                if (rc == -EREMOTE) {
+                if (rc == -EREMOTE && !is_dfs_referral) {
-                        tmp_path =
+                        is_dfs_referral = true;
-                            kmalloc(strnlen(pTcon->treeName,
+                        if (full_path != search_path) {
-                                            MAX_TREE_SIZE + 1) +
+                                kfree(full_path);
-                                    strnlen(search_path, MAX_PATHCONF) + 1,
+                                full_path = search_path;
-                                    GFP_KERNEL);
+                        }
-                        if (tmp_path == NULL)
+                        goto try_again_CIFSSMBUnixQPathInfo;
-                                return -ENOMEM;
-                        /* have to skip first of the double backslash of
-                           UNC name */
-                        strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
-                        strncat(tmp_path, search_path, MAX_PATHCONF);
-                        rc = connect_to_dfs_path(xid, pTcon->ses,
-                                                 /* treename + */ tmp_path,
-                                                 cifs_sb->local_nls,
-                                                 cifs_sb->mnt_cifs_flags &
-                                                    CIFS_MOUNT_MAP_SPECIAL_CHR);
-                        kfree(tmp_path);
-                        /* BB fix up inode etc. */
-                } else if (rc) {
-                        return rc;
                }
+                goto cgiiu_exit;
        } else {
                struct cifsInodeInfo *cifsInfo;
-                __u32 type = le32_to_cpu(findData.Type);
                __u64 num_of_bytes = le64_to_cpu(findData.NumOfBytes);
                __u64 end_of_file = le64_to_cpu(findData.EndOfFile);
                /* get new inode */
                if (*pinode == NULL) {
                        *pinode = new_inode(sb);
-                        if (*pinode == NULL)
+                        if (*pinode == NULL) {
-                                return -ENOMEM;
+                                rc = -ENOMEM;
+                                goto cgiiu_exit;
+                        }
                        /* Is an i_ino of zero legal? */
                        /* Are there sanity checks we can use to ensure that
                           the server is really filling in that field? */
@@ -105,113 +252,20 @@ int cifs_get_inode_info_unix(struct inode **pinode,
                /* this is ok to set on every inode revalidate */
                atomic_set(&cifsInfo->inUse, 1);
-                inode->i_atime =
+                cifs_unix_info_to_inode(inode, &findData, 0);
-                    cifs_NTtimeToUnix(le64_to_cpu(findData.LastAccessTime));
-                inode->i_mtime =
-                    cifs_NTtimeToUnix(le64_to_cpu
-                                (findData.LastModificationTime));
-                inode->i_ctime =
-                    cifs_NTtimeToUnix(le64_to_cpu(findData.LastStatusChange));
-                inode->i_mode = le64_to_cpu(findData.Permissions);
-                /* since we set the inode type below we need to mask off
-                   to avoid strange results if bits set above */
-                inode->i_mode &= ~S_IFMT;
-                if (type == UNIX_FILE) {
-                        inode->i_mode |= S_IFREG;
-                } else if (type == UNIX_SYMLINK) {
-                        inode->i_mode |= S_IFLNK;
-                } else if (type == UNIX_DIR) {
-                        inode->i_mode |= S_IFDIR;
-                } else if (type == UNIX_CHARDEV) {
-                        inode->i_mode |= S_IFCHR;
-                        inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
-                                le64_to_cpu(findData.DevMinor) & MINORMASK);
-                } else if (type == UNIX_BLOCKDEV) {
-                        inode->i_mode |= S_IFBLK;
-                        inode->i_rdev = MKDEV(le64_to_cpu(findData.DevMajor),
-                                le64_to_cpu(findData.DevMinor) & MINORMASK);
-                } else if (type == UNIX_FIFO) {
-                        inode->i_mode |= S_IFIFO;
-                } else if (type == UNIX_SOCKET) {
-                        inode->i_mode |= S_IFSOCK;
-                } else {
-                        /* safest to call it a file if we do not know */
-                        inode->i_mode |= S_IFREG;
-                        cFYI(1, ("unknown type %d", type));
-                }
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_UID)
-                        inode->i_uid = cifs_sb->mnt_uid;
-                else
-                        inode->i_uid = le64_to_cpu(findData.Uid);
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_OVERR_GID)
-                        inode->i_gid = cifs_sb->mnt_gid;
-                else
-                        inode->i_gid = le64_to_cpu(findData.Gid);
-                inode->i_nlink = le64_to_cpu(findData.Nlinks);
-                spin_lock(&inode->i_lock);
-                if (is_size_safe_to_change(cifsInfo, end_of_file)) {
-                /* can not safely change the file size here if the
-                   client is writing to it due to potential races */
-                        i_size_write(inode, end_of_file);
-                /* blksize needs to be multiple of two. So safer to default to
-                blksize and blkbits set in superblock so 2**blkbits and blksize
-                will match rather than setting to:
-                (pTcon->ses->server->maxBuf - MAX_CIFS_HDR_SIZE) & 0xFFFFFE00;*/
-                /* This seems incredibly stupid but it turns out that i_blocks
-                   is not related to (i_size / i_blksize), instead 512 byte size
-                   is required for calculating num blocks */
-                /* 512 bytes (2**9) is the fake blocksize that must be used */
-                /* for this calculation */
-                        inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
-                }
-                spin_unlock(&inode->i_lock);
                if (num_of_bytes < end_of_file)
                        cFYI(1, ("allocation size less than end of file"));
                cFYI(1, ("Size %ld and blocks %llu",
                        (unsigned long) inode->i_size,
                        (unsigned long long)inode->i_blocks));
-                if (S_ISREG(inode->i_mode)) {
-                        cFYI(1, ("File inode"));
+                cifs_set_ops(inode, is_dfs_referral);
-                        inode->i_op = &cifs_file_inode_ops;
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                        inode->i_fop =
-                                                &cifs_file_direct_nobrl_ops;
-                                else
-                                        inode->i_fop = &cifs_file_direct_ops;
-                        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                inode->i_fop = &cifs_file_nobrl_ops;
-                        else /* not direct, send byte range locks */
-                                inode->i_fop = &cifs_file_ops;
-                        /* check if server can support readpages */
-                        if (pTcon->ses->server->maxBuf <
-                            PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
-                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
-                        else
-                                inode->i_data.a_ops = &cifs_addr_ops;
-                } else if (S_ISDIR(inode->i_mode)) {
-                        cFYI(1, ("Directory inode"));
-                        inode->i_op = &cifs_dir_inode_ops;
-                        inode->i_fop = &cifs_dir_ops;
-                } else if (S_ISLNK(inode->i_mode)) {
-                        cFYI(1, ("Symbolic Link inode"));
-                        inode->i_op = &cifs_symlink_inode_ops;
-                /* tmp_inode->i_fop = */ /* do not need to set to anything */
-                } else {
-                        cFYI(1, ("Init special inode"));
-                        init_special_inode(inode, inode->i_mode,
-                                           inode->i_rdev);
-                }
        }
+cgiiu_exit:
+        if (full_path != search_path)
+                kfree(full_path);
        return rc;
 }
@@ -320,15 +374,16 @@ static int get_sfu_mode(struct inode *inode,
 int cifs_get_inode_info(struct inode **pinode,
        const unsigned char *search_path, FILE_ALL_INFO *pfindData,
-        struct super_block *sb, int xid)
+        struct super_block *sb, int xid, const __u16 *pfid)
 {
        int rc = 0;
        struct cifsTconInfo *pTcon;
        struct inode *inode;
        struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
-        char *tmp_path;
+        const unsigned char *full_path = NULL;
        char *buf = NULL;
        int adjustTZ = FALSE;
+        bool is_dfs_referral = false;
        pTcon = cifs_sb->tcon;
        cFYI(1, ("Getting info on %s", search_path));
@@ -346,8 +401,12 @@ int cifs_get_inode_info(struct inode **pinode,
                if (buf == NULL)
                        return -ENOMEM;
                pfindData = (FILE_ALL_INFO *)buf;
+                full_path = cifs_get_search_path(pTcon, search_path);
+try_again_CIFSSMBQPathInfo:
                /* could do find first instead but this returns more info */
-                rc = CIFSSMBQPathInfo(xid, pTcon, search_path, pfindData,
+                rc = CIFSSMBQPathInfo(xid, pTcon, full_path, pfindData,
                              0 /* not legacy */,
                              cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
                                CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -355,7 +414,7 @@ int cifs_get_inode_info(struct inode **pinode,
                when server claims no NT SMB support and the above call
                failed at least once - set flag in tcon or mount */
                if ((rc == -EOPNOTSUPP) || (rc == -EINVAL)) {
-                        rc = SMBQueryInformation(xid, pTcon, search_path,
+                        rc = SMBQueryInformation(xid, pTcon, full_path,
                                        pfindData, cifs_sb->local_nls,
                                        cifs_sb->mnt_cifs_flags &
                                          CIFS_MOUNT_MAP_SPECIAL_CHR);
@@ -364,31 +423,15 @@ int cifs_get_inode_info(struct inode **pinode,
        }
        /* dump_mem("\nQPathInfo return data",&findData, sizeof(findData)); */
        if (rc) {
-                if (rc == -EREMOTE) {
+                if (rc == -EREMOTE && !is_dfs_referral) {
-                        tmp_path =
+                        is_dfs_referral = true;
-                            kmalloc(strnlen
+                        if (full_path != search_path) {
-                                    (pTcon->treeName,
+                                kfree(full_path);
-                                     MAX_TREE_SIZE + 1) +
+                                full_path = search_path;
-                                    strnlen(search_path, MAX_PATHCONF) + 1,
-                                    GFP_KERNEL);
-                        if (tmp_path == NULL) {
-                                kfree(buf);
-                                return -ENOMEM;
                        }
+                        goto try_again_CIFSSMBQPathInfo;
-                        strncpy(tmp_path, pTcon->treeName, MAX_TREE_SIZE);
-                        strncat(tmp_path, search_path, MAX_PATHCONF);
-                        rc = connect_to_dfs_path(xid, pTcon->ses,
-                                                 /* treename + */ tmp_path,
-                                                 cifs_sb->local_nls,
-                                                 cifs_sb->mnt_cifs_flags &
-                                                   CIFS_MOUNT_MAP_SPECIAL_CHR);
-                        kfree(tmp_path);
-                        /* BB fix up inode etc. */
-                } else if (rc) {
-                        kfree(buf);
-                        return rc;
                }
+                goto cgii_exit;
        } else {
                struct cifsInodeInfo *cifsInfo;
                __u32 attr = le32_to_cpu(pfindData->Attributes);
@@ -397,8 +440,8 @@ int cifs_get_inode_info(struct inode **pinode,
                if (*pinode == NULL) {
                        *pinode = new_inode(sb);
                        if (*pinode == NULL) {
-                                kfree(buf);
+                                rc = -ENOMEM;
-                                return -ENOMEM;
+                                goto cgii_exit;
                        }
                        /* Is an i_ino of zero legal? Can we use that to check
                           if the server supports returning inode numbers?  Are
@@ -490,9 +533,9 @@ int cifs_get_inode_info(struct inode **pinode,
                        if (decode_sfu_inode(inode,
                                         le64_to_cpu(pfindData->EndOfFile),
                                         search_path,
-                                         cifs_sb, xid)) {
+                                         cifs_sb, xid))
                                cFYI(1, ("Unrecognized sfu inode type"));
-                        }
                        cFYI(1, ("sfu mode 0%o", inode->i_mode));
                } else {
                        inode->i_mode |= S_IFREG;
@@ -532,7 +575,7 @@ int cifs_get_inode_info(struct inode **pinode,
                /* fill in 0777 bits from ACL */
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
                        cFYI(1, ("Getting mode bits from ACL"));
-                        acl_to_uid_mode(inode, search_path);
+                        acl_to_uid_mode(inode, search_path, pfid);
                }
 #endif
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) {
@@ -546,37 +589,11 @@ int cifs_get_inode_info(struct inode **pinode,
                        atomic_set(&cifsInfo->inUse, 1);
                }
-                if (S_ISREG(inode->i_mode)) {
+                cifs_set_ops(inode, is_dfs_referral);
-                        cFYI(1, ("File inode"));
-                        inode->i_op = &cifs_file_inode_ops;
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                        inode->i_fop =
-                                                &cifs_file_direct_nobrl_ops;
-                                else
-                                        inode->i_fop = &cifs_file_direct_ops;
-                        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                inode->i_fop = &cifs_file_nobrl_ops;
-                        else /* not direct, send byte range locks */
-                                inode->i_fop = &cifs_file_ops;
-                        if (pTcon->ses->server->maxBuf <
-                             PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE)
-                                inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
-                        else
-                                inode->i_data.a_ops = &cifs_addr_ops;
-                } else if (S_ISDIR(inode->i_mode)) {
-                        cFYI(1, ("Directory inode"));
-                        inode->i_op = &cifs_dir_inode_ops;
-                        inode->i_fop = &cifs_dir_ops;
-                } else if (S_ISLNK(inode->i_mode)) {
-                        cFYI(1, ("Symbolic Link inode"));
-                        inode->i_op = &cifs_symlink_inode_ops;
-                } else {
-                        init_special_inode(inode, inode->i_mode,
-                                           inode->i_rdev);
-                }
        }
+cgii_exit:
+        if (full_path != search_path)
+                kfree(full_path);
        kfree(buf);
        return rc;
 }
@@ -605,7 +622,8 @@ struct inode *cifs_iget(struct super_block *sb, unsigned long ino)
        if (cifs_sb->tcon->unix_ext)
                rc = cifs_get_inode_info_unix(&inode, "", inode->i_sb, xid);
        else
-                rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid);
+                rc = cifs_get_inode_info(&inode, "", NULL, inode->i_sb, xid,
+                                         NULL);
        if (rc && cifs_sb->tcon->ipc) {
                cFYI(1, ("ipc connection - fake read inode"));
                inode->i_mode |= S_IFDIR;
@@ -792,17 +810,12 @@ psx_del_no_retry:
 }
 static void posix_fill_in_inode(struct inode *tmp_inode,
-        FILE_UNIX_BASIC_INFO *pData, int *pobject_type, int isNewInode)
+        FILE_UNIX_BASIC_INFO *pData, int isNewInode)
 {
+        struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
        loff_t local_size;
        struct timespec local_mtime;
-        struct cifsInodeInfo *cifsInfo = CIFS_I(tmp_inode);
-        struct cifs_sb_info *cifs_sb = CIFS_SB(tmp_inode->i_sb);
-        __u32 type = le32_to_cpu(pData->Type);
-        __u64 num_of_bytes = le64_to_cpu(pData->NumOfBytes);
-        __u64 end_of_file = le64_to_cpu(pData->EndOfFile);
        cifsInfo->time = jiffies;
        atomic_inc(&cifsInfo->inUse);
@@ -810,115 +823,27 @@ static void posix_fill_in_inode(struct inode *tmp_inode,
        local_mtime = tmp_inode->i_mtime;
        local_size  = tmp_inode->i_size;
-        tmp_inode->i_atime =
+        cifs_unix_info_to_inode(tmp_inode, pData, 1);
-            cifs_NTtimeToUnix(le64_to_cpu(pData->LastAccessTime));
+        cifs_set_ops(tmp_inode, false);
-        tmp_inode->i_mtime =
-            cifs_NTtimeToUnix(le64_to_cpu(pData->LastModificationTime));
-        tmp_inode->i_ctime =
-            cifs_NTtimeToUnix(le64_to_cpu(pData->LastStatusChange));
-        tmp_inode->i_mode = le64_to_cpu(pData->Permissions);
-        /* since we set the inode type below we need to mask off type
-           to avoid strange results if bits above were corrupt */
-        tmp_inode->i_mode &= ~S_IFMT;
-        if (type == UNIX_FILE) {
-                *pobject_type = DT_REG;
-                tmp_inode->i_mode |= S_IFREG;
-        } else if (type == UNIX_SYMLINK) {
-                *pobject_type = DT_LNK;
-                tmp_inode->i_mode |= S_IFLNK;
-        } else if (type == UNIX_DIR) {
-                *pobject_type = DT_DIR;
-                tmp_inode->i_mode |= S_IFDIR;
-        } else if (type == UNIX_CHARDEV) {
-                *pobject_type = DT_CHR;
-                tmp_inode->i_mode |= S_IFCHR;
-                tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
-                                le64_to_cpu(pData->DevMinor) & MINORMASK);
-        } else if (type == UNIX_BLOCKDEV) {
-                *pobject_type = DT_BLK;
-                tmp_inode->i_mode |= S_IFBLK;
-                tmp_inode->i_rdev = MKDEV(le64_to_cpu(pData->DevMajor),
-                                le64_to_cpu(pData->DevMinor) & MINORMASK);
-        } else if (type == UNIX_FIFO) {
-                *pobject_type = DT_FIFO;
-                tmp_inode->i_mode |= S_IFIFO;
-        } else if (type == UNIX_SOCKET) {
-                *pobject_type = DT_SOCK;
-                tmp_inode->i_mode |= S_IFSOCK;
-        } else {
-                /* safest to just call it a file */
-                *pobject_type = DT_REG;
-                tmp_inode->i_mode |= S_IFREG;
-                cFYI(1, ("unknown inode type %d", type));
-        }
-#ifdef CONFIG_CIFS_DEBUG2
-        cFYI(1, ("object type: %d", type));
-#endif
-        tmp_inode->i_uid = le64_to_cpu(pData->Uid);
-        tmp_inode->i_gid = le64_to_cpu(pData->Gid);
-        tmp_inode->i_nlink = le64_to_cpu(pData->Nlinks);
-        spin_lock(&tmp_inode->i_lock);
-        if (is_size_safe_to_change(cifsInfo, end_of_file)) {
-                /* can not safely change the file size here if the
-                client is writing to it due to potential races */
-                i_size_write(tmp_inode, end_of_file);
-        /* 512 bytes (2**9) is the fake blocksize that must be used */
-        /* for this calculation, not the real blocksize */
-                tmp_inode->i_blocks = (512 - 1 + num_of_bytes) >> 9;
-        }
-        spin_unlock(&tmp_inode->i_lock);
-        if (S_ISREG(tmp_inode->i_mode)) {
-                cFYI(1, ("File inode"));
-                tmp_inode->i_op = &cifs_file_inode_ops;
-                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
-                        if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
-                                tmp_inode->i_fop = &cifs_file_direct_nobrl_ops;
-                        else
-                                tmp_inode->i_fop = &cifs_file_direct_ops;
-                } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
+        if (!S_ISREG(tmp_inode->i_mode))
-                        tmp_inode->i_fop = &cifs_file_nobrl_ops;
+                return;
-                else
-                        tmp_inode->i_fop = &cifs_file_ops;
-                if ((cifs_sb->tcon) && (cifs_sb->tcon->ses) &&
+        /*
-                   (cifs_sb->tcon->ses->server->maxBuf <
+         * No sense invalidating pages for new inode
-                        PAGE_CACHE_SIZE + MAX_CIFS_HDR_SIZE))
+         * since we we have not started caching
-                        tmp_inode->i_data.a_ops = &cifs_addr_ops_smallbuf;
+         * readahead file data yet.
-                else
+         */
-                        tmp_inode->i_data.a_ops = &cifs_addr_ops;
+        if (isNewInode)
+                return;
-                if (isNewInode)
-                        return; /* No sense invalidating pages for new inode
-                                   since we we have not started caching
-                                   readahead file data yet */
-                if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
+        if (timespec_equal(&tmp_inode->i_mtime, &local_mtime) &&
-                        (local_size == tmp_inode->i_size)) {
+                (local_size == tmp_inode->i_size)) {
-                        cFYI(1, ("inode exists but unchanged"));
+                cFYI(1, ("inode exists but unchanged"));
-                } else {
-                        /* file may have changed on server */
-                        cFYI(1, ("invalidate inode, readdir detected change"));
-                        invalidate_remote_inode(tmp_inode);
-                }
-        } else if (S_ISDIR(tmp_inode->i_mode)) {
-                cFYI(1, ("Directory inode"));
-                tmp_inode->i_op = &cifs_dir_inode_ops;
-                tmp_inode->i_fop = &cifs_dir_ops;
-        } else if (S_ISLNK(tmp_inode->i_mode)) {
-                cFYI(1, ("Symbolic Link inode"));
-                tmp_inode->i_op = &cifs_symlink_inode_ops;
-/* tmp_inode->i_fop = *//* do not need to set to anything */
        } else {
-                cFYI(1, ("Special inode"));
+                /* file may have changed on server */
-                init_special_inode(tmp_inode, tmp_inode->i_mode,
+                cFYI(1, ("invalidate inode, readdir detected change"));
-                                   tmp_inode->i_rdev);
+                invalidate_remote_inode(tmp_inode);
        }
 }
@@ -968,7 +893,6 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                        cFYI(1, ("posix mkdir returned 0x%x", rc));
                        d_drop(direntry);
                } else {
-                        int obj_type;
                        if (pInfo->Type == cpu_to_le32(-1)) {
                                /* no return info, go query for it */
                                kfree(pInfo);
@@ -1004,7 +928,7 @@ int cifs_mkdir(struct inode *inode, struct dentry *direntry, int mode)
                        /* we already checked in POSIXCreate whether
                           frame was long enough */
                        posix_fill_in_inode(direntry->d_inode,
-                                        pInfo, &obj_type, 1 /* NewInode */);
+                                        pInfo, 1 /* NewInode */);
 #ifdef CONFIG_CIFS_DEBUG2
                        cFYI(1, ("instantiated dentry %p %s to inode %p",
                                direntry, direntry->d_name.name, newinode));
@@ -1032,7 +956,7 @@ mkdir_get_info:
                                                      inode->i_sb, xid);
                else
                        rc = cifs_get_inode_info(&newinode, full_path, NULL,
-                                                 inode->i_sb, xid);
+                                                 inode->i_sb, xid, NULL);
                if (pTcon->nocase)
                        direntry->d_op = &cifs_ci_dentry_ops;
@@ -1214,9 +1138,8 @@ int cifs_rename(struct inode *source_inode, struct dentry *source_direntry,
                } /* if we can not get memory just leave rc as EEXIST */
        }
-        if (rc) {
+        if (rc)
                cFYI(1, ("rename rc %d", rc));
-        }
        if ((rc == -EIO) || (rc == -EEXIST)) {
                int oplock = FALSE;
@@ -1315,7 +1238,7 @@ int cifs_revalidate(struct dentry *direntry)
                }
        } else {
                rc = cifs_get_inode_info(&direntry->d_inode, full_path, NULL,
-                                         direntry->d_sb, xid);
+                                         direntry->d_sb, xid, NULL);
                if (rc) {
                        cFYI(1, ("error on getting revalidate info %d", rc));
 /*                      if (rc != -ENOENT)
@@ -1504,11 +1427,10 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
        }
        cifsInode = CIFS_I(direntry->d_inode);
-        /* BB check if we need to refresh inode from server now ? BB */
+        if ((attrs->ia_valid & ATTR_MTIME) || (attrs->ia_valid & ATTR_SIZE)) {
-        if (attrs->ia_valid & ATTR_SIZE) {
                /*
-                   Flush data before changing file size on server. If the
+                   Flush data before changing file size or changing the last
+                   write time of the file on the server. If the
                   flush returns error, store it to report later and continue.
                   BB: This should be smarter. Why bother flushing pages that
                   will be truncated anyway? Also, should we error out here if
@@ -1519,7 +1441,9 @@ int cifs_setattr(struct dentry *direntry, struct iattr *attrs)
                        CIFS_I(direntry->d_inode)->write_behind_rc = rc;
                        rc = 0;
                }
+        }
+        if (attrs->ia_valid & ATTR_SIZE) {
                /* To avoid spurious oplock breaks from server, in the case of
                   inodes that we already have open, avoid doing path based
                   setting of file size if we can do it by handle.
diff --git a/fs/cifs/ioctl.c b/fs/cifs/ioctl.c
index d24fe6880a04..5c792df13d62 100644
--- a/fs/cifs/ioctl.c
+++ b/fs/cifs/ioctl.c
@@ -30,7 +30,7 @@
 #define CIFS_IOC_CHECKUMOUNT _IO(0xCF, 2)
-int cifs_ioctl (struct inode *inode, struct file *filep,
+int cifs_ioctl(struct inode *inode, struct file *filep,
                unsigned int command, unsigned long arg)
 {
        int rc = -ENOTTY; /* strange error - but the precedent */
diff --git a/fs/cifs/link.c b/fs/cifs/link.c
index 1d6fb01b8e6d..d4e7ec93285f 100644
--- a/fs/cifs/link.c
+++ b/fs/cifs/link.c
@@ -205,7 +205,7 @@ cifs_symlink(struct inode *inode, struct dentry *direntry, const char *symname)
                                                      inode->i_sb, xid);
                else
                        rc = cifs_get_inode_info(&newinode, full_path, NULL,
-                                                 inode->i_sb, xid);
+                                                 inode->i_sb, xid, NULL);
                if (rc != 0) {
                        cFYI(1, ("Create symlink ok, getinodeinfo fail rc = %d",
diff --git a/fs/cifs/md4.c b/fs/cifs/md4.c
index a2415c1a14db..a725c2609d67 100644
--- a/fs/cifs/md4.c
+++ b/fs/cifs/md4.c
@@ -56,7 +56,7 @@ lshift(__u32 x, int s)
 /* this applies md4 to 64 byte chunks */
 static void
-mdfour64(__u32 * M, __u32 * A, __u32 *B, __u32 * C, __u32 *D)
+mdfour64(__u32 *M, __u32 *A, __u32 *B, __u32 *C, __u32 *D)
 {
        int j;
        __u32 AA, BB, CC, DD;
@@ -137,7 +137,7 @@ mdfour64(__u32 * M, __u32 * A, __u32 *B, __u32 * C, __u32 *D)
 }
 static void
-copy64(__u32 * M, unsigned char *in)
+copy64(__u32 *M, unsigned char *in)
 {
        int i;
diff --git a/fs/cifs/md5.c b/fs/cifs/md5.c
index f13f96d42fcf..462bbfefd4b6 100644
--- a/fs/cifs/md5.c
+++ b/fs/cifs/md5.c
@@ -161,7 +161,7 @@ MD5Final(unsigned char digest[16], struct MD5Context *ctx)
 /* This is the central step in the MD5 algorithm. */
 #define MD5STEP(f, w, x, y, z, data, s) \
-        ( w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x )
+        (w += f(x, y, z) + data,  w = w<<s | w>>(32-s),  w += x)
 /*
 * The core of the MD5 algorithm, this alters an existing MD5 hash to
@@ -302,9 +302,8 @@ hmac_md5_init_limK_to_64(const unsigned char *key, int key_len,
        int i;
        /* if key is longer than 64 bytes truncate it */
-        if (key_len > 64) {
+        if (key_len > 64)
                key_len = 64;
-        }
        /* start out by storing key in pads */
        memset(ctx->k_ipad, 0, sizeof(ctx->k_ipad));
@@ -359,9 +358,9 @@ hmac_md5(unsigned char key[16], unsigned char *data, int data_len,
 {
        struct HMACMD5Context ctx;
        hmac_md5_init_limK_to_64(key, 16, &ctx);
-        if (data_len != 0) {
+        if (data_len != 0)
                hmac_md5_update(data, data_len, &ctx);
-        }
        hmac_md5_final(digest, &ctx);
 }
 #endif
diff --git a/fs/cifs/misc.c b/fs/cifs/misc.c
index 15546c2354c5..2a42d9fedbb2 100644
--- a/fs/cifs/misc.c
+++ b/fs/cifs/misc.c
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/misc.c
 *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
@@ -320,9 +320,9 @@ header_assemble(struct smb_hdr *buffer, char smb_command /* command */ ,
                if (treeCon->ses) {
                        if (treeCon->ses->capabilities & CAP_UNICODE)
                                buffer->Flags2 |= SMBFLG2_UNICODE;
-                        if (treeCon->ses->capabilities & CAP_STATUS32) {
+                        if (treeCon->ses->capabilities & CAP_STATUS32)
                                buffer->Flags2 |= SMBFLG2_ERR_STATUS;
-                        }
                        /* Uid is not converted */
                        buffer->Uid = treeCon->ses->Suid;
                        buffer->Mid = GetNextMid(treeCon->ses->server);
@@ -610,7 +610,8 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
        buffer = (unsigned char *) smb_buf;
        for (i = 0, j = 0; i < smb_buf_length; i++, j++) {
-                if (i % 8 == 0) {       /* have reached the beginning of line */
+                if (i % 8 == 0) {
+                        /* have reached the beginning of line */
                        printk(KERN_DEBUG "| ");
                        j = 0;
                }
@@ -621,7 +622,8 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
                else
                        debug_line[1 + (2 * j)] = '_';
-                if (i % 8 == 7) { /* reached end of line, time to print ascii */
+                if (i % 8 == 7) {
+                        /* reached end of line, time to print ascii */
                        debug_line[16] = 0;
                        printk(" | %s\n", debug_line);
                }
@@ -631,7 +633,7 @@ dump_smb(struct smb_hdr *smb_buf, int smb_buf_length)
                debug_line[2 * j] = ' ';
                debug_line[1 + (2 * j)] = ' ';
        }
-        printk( " | %s\n", debug_line);
+        printk(" | %s\n", debug_line);
        return;
 }
diff --git a/fs/cifs/netmisc.c b/fs/cifs/netmisc.c
index 646e1f06941b..3b5a5ce882b6 100644
--- a/fs/cifs/netmisc.c
+++ b/fs/cifs/netmisc.c
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/netmisc.c
 *
- *   Copyright (c) International Business Machines  Corp., 2002
+ *   Copyright (c) International Business Machines  Corp., 2002,2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   Error mapping routines from Samba libsmb/errormap.c
@@ -150,9 +150,7 @@ static int canonicalize_unc(char *cp)
                if (cp[i] == '\\')
                        break;
                if (cp[i] == '/') {
-#ifdef CONFIG_CIFS_DEBUG2
+                        cFYI(DBG2, ("change slash to \\ in malformed UNC"));
-                        cFYI(1, ("change slash to backslash in malformed UNC"));
-#endif
                        cp[i] = '\\';
                        return 1;
                }
@@ -178,9 +176,7 @@ cifs_inet_pton(int address_family, char *cp, void *dst)
        } else if (address_family == AF_INET6) {
                ret = in6_pton(cp, -1 /* len */, dst , '\\', NULL);
        }
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("address conversion returned %d for %s", ret, cp));
-        cFYI(1, ("address conversion returned %d for %s", ret, cp));
-#endif
        if (ret > 0)
                ret = 1;
        return ret;
@@ -253,7 +249,8 @@ static const struct {
        ERRDOS, 87, NT_STATUS_INVALID_PARAMETER_MIX}, {
        ERRHRD, ERRgeneral, NT_STATUS_INVALID_QUOTA_LOWER}, {
        ERRHRD, ERRgeneral, NT_STATUS_DISK_CORRUPT_ERROR}, {
-        ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_INVALID}, {   /* mapping changed since shell does lookup on * and expects file not found */
+         /* mapping changed since shell does lookup on * expects FileNotFound */
+        ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_INVALID}, {
        ERRDOS, ERRbadfile, NT_STATUS_OBJECT_NAME_NOT_FOUND}, {
        ERRDOS, ERRalreadyexists, NT_STATUS_OBJECT_NAME_COLLISION}, {
        ERRHRD, ERRgeneral, NT_STATUS_HANDLE_NOT_WAITABLE}, {
@@ -820,7 +817,8 @@ map_smb_to_linux_error(struct smb_hdr *smb, int logErr)
        /* old style errors */
        /* DOS class smb error codes - map DOS */
-        if (smberrclass == ERRDOS) {  /* 1 byte field no need to byte reverse */
+        if (smberrclass == ERRDOS) {
+                /* 1 byte field no need to byte reverse */
                for (i = 0;
                     i <
                     sizeof(mapping_table_ERRDOS) /
@@ -834,7 +832,8 @@ map_smb_to_linux_error(struct smb_hdr *smb, int logErr)
                        }
                        /* else try next error mapping one to see if match */
                }
-        } else if (smberrclass == ERRSRV) {   /* server class of error codes */
+        } else if (smberrclass == ERRSRV) {
+                /* server class of error codes */
                for (i = 0;
                     i <
                     sizeof(mapping_table_ERRSRV) /
@@ -922,8 +921,8 @@ struct timespec cnvrtDosUnixTm(__u16 date, __u16 time)
 {
        struct timespec ts;
        int sec, min, days, month, year;
-        SMB_TIME * st = (SMB_TIME *)&time;
+        SMB_TIME *st = (SMB_TIME *)&time;
-        SMB_DATE * sd = (SMB_DATE *)&date;
+        SMB_DATE *sd = (SMB_DATE *)&date;
        cFYI(1, ("date %d time %d", date, time));
diff --git a/fs/cifs/readdir.c b/fs/cifs/readdir.c
index 0f22def4bdff..32b445edc882 100644
--- a/fs/cifs/readdir.c
+++ b/fs/cifs/readdir.c
@@ -3,7 +3,7 @@
 *
 *   Directory search handling
 *
- *   Copyright (C) International Business Machines  Corp., 2004, 2007
+ *   Copyright (C) International Business Machines  Corp., 2004, 2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *
 *   This library is free software; you can redistribute it and/or modify
@@ -42,17 +42,18 @@ static void dump_cifs_file_struct(struct file *file, char *label)
                        cFYI(1, ("empty cifs private file data"));
                        return;
                }
-                if (cf->invalidHandle) {
+                if (cf->invalidHandle)
                        cFYI(1, ("invalid handle"));
-                }
+                if (cf->srch_inf.endOfSearch)
-                if (cf->srch_inf.endOfSearch) {
                        cFYI(1, ("end of search"));
-                }
+                if (cf->srch_inf.emptyDir)
-                if (cf->srch_inf.emptyDir) {
                        cFYI(1, ("empty dir"));
-                }
        }
 }
+#else
+static inline void dump_cifs_file_struct(struct file *file, char *label)
+{
+}
 #endif /* DEBUG2 */
 /* Returns one if new inode created (which therefore needs to be hashed) */
@@ -150,7 +151,7 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
                      cifs_NTtimeToUnix(le64_to_cpu(pfindData->ChangeTime));
        } else { /* legacy, OS2 and DOS style */
 /*              struct timespec ts;*/
-                FIND_FILE_STANDARD_INFO * pfindData =
+                FIND_FILE_STANDARD_INFO *pfindData =
                        (FIND_FILE_STANDARD_INFO *)buf;
                tmp_inode->i_mtime = cnvrtDosUnixTm(
@@ -198,9 +199,8 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
        if (attr & ATTR_DIRECTORY) {
                *pobject_type = DT_DIR;
                /* override default perms since we do not lock dirs */
-                if (atomic_read(&cifsInfo->inUse) == 0) {
+                if (atomic_read(&cifsInfo->inUse) == 0)
                        tmp_inode->i_mode = cifs_sb->mnt_dir_mode;
-                }
                tmp_inode->i_mode |= S_IFDIR;
        } else if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_UNX_EMUL) &&
                   (attr & ATTR_SYSTEM)) {
@@ -231,9 +231,8 @@ static void fill_in_inode(struct inode *tmp_inode, int new_buf_type,
        } /* could add code here - to validate if device or weird share type? */
        /* can not fill in nlink here as in qpathinfo version and Unx search */
-        if (atomic_read(&cifsInfo->inUse) == 0) {
+        if (atomic_read(&cifsInfo->inUse) == 0)
                atomic_set(&cifsInfo->inUse, 1);
-        }
        spin_lock(&tmp_inode->i_lock);
        if (is_size_safe_to_change(cifsInfo, end_of_file)) {
@@ -461,9 +460,8 @@ static int initiate_cifs_search(const int xid, struct file *file)
        full_path = build_path_from_dentry(file->f_path.dentry);
-        if (full_path == NULL) {
+        if (full_path == NULL)
                return -ENOMEM;
-        }
        cFYI(1, ("Full path: %s start at: %lld", full_path, file->f_pos));
@@ -471,9 +469,9 @@ ffirst_retry:
        /* test for Unix extensions */
        /* but now check for them on the share/mount not on the SMB session */
 /*      if (pTcon->ses->capabilities & CAP_UNIX) { */
-        if (pTcon->unix_ext) {
+        if (pTcon->unix_ext)
                cifsFile->srch_inf.info_level = SMB_FIND_FILE_UNIX;
-        } else if ((pTcon->ses->capabilities &
+        else if ((pTcon->ses->capabilities &
                        (CAP_NT_SMBS | CAP_NT_FIND)) == 0) {
                cifsFile->srch_inf.info_level = SMB_FIND_FILE_INFO_STANDARD;
        } else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_SERVER_INUM) {
@@ -514,10 +512,10 @@ static int cifs_unicode_bytelen(char *str)
 static char *nxt_dir_entry(char *old_entry, char *end_of_smb, int level)
 {
        char *new_entry;
-        FILE_DIRECTORY_INFO * pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
+        FILE_DIRECTORY_INFO *pDirInfo = (FILE_DIRECTORY_INFO *)old_entry;
        if (level == SMB_FIND_FILE_INFO_STANDARD) {
-                FIND_FILE_STANDARD_INFO * pfData;
+                FIND_FILE_STANDARD_INFO *pfData;
                pfData = (FIND_FILE_STANDARD_INFO *)pDirInfo;
                new_entry = old_entry + sizeof(FIND_FILE_STANDARD_INFO) +
@@ -553,7 +551,7 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
        int len = 0;
        if (cfile->srch_inf.info_level == SMB_FIND_FILE_UNIX) {
-                FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
+                FILE_UNIX_INFO *pFindData = (FILE_UNIX_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                if (cfile->srch_inf.unicode) {
                        len = cifs_unicode_bytelen(filename);
@@ -562,30 +560,30 @@ static int cifs_entry_is_dot(char *current_entry, struct cifsFileInfo *cfile)
                        len = strnlen(filename, 5);
                }
        } else if (cfile->srch_inf.info_level == SMB_FIND_FILE_DIRECTORY_INFO) {
-                FILE_DIRECTORY_INFO * pFindData =
+                FILE_DIRECTORY_INFO *pFindData =
                        (FILE_DIRECTORY_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
        } else if (cfile->srch_inf.info_level ==
                        SMB_FIND_FILE_FULL_DIRECTORY_INFO) {
-                FILE_FULL_DIRECTORY_INFO * pFindData =
+                FILE_FULL_DIRECTORY_INFO *pFindData =
                        (FILE_FULL_DIRECTORY_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
        } else if (cfile->srch_inf.info_level ==
                        SMB_FIND_FILE_ID_FULL_DIR_INFO) {
-                SEARCH_ID_FULL_DIR_INFO * pFindData =
+                SEARCH_ID_FULL_DIR_INFO *pFindData =
                        (SEARCH_ID_FULL_DIR_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
        } else if (cfile->srch_inf.info_level ==
                        SMB_FIND_FILE_BOTH_DIRECTORY_INFO) {
-                FILE_BOTH_DIRECTORY_INFO * pFindData =
+                FILE_BOTH_DIRECTORY_INFO *pFindData =
                        (FILE_BOTH_DIRECTORY_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
        } else if (cfile->srch_inf.info_level == SMB_FIND_FILE_INFO_STANDARD) {
-                FIND_FILE_STANDARD_INFO * pFindData =
+                FIND_FILE_STANDARD_INFO *pFindData =
                        (FIND_FILE_STANDARD_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                len = pFindData->FileNameLength;
@@ -666,9 +664,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
        . and .. for the root of a drive and for those we need
        to start two entries earlier */
-#ifdef CONFIG_CIFS_DEBUG2
        dump_cifs_file_struct(file, "In fce ");
-#endif
        if (((index_to_find < cifsFile->srch_inf.index_of_last_entry) &&
             is_dir_changed(file)) ||
           (index_to_find < first_entry_in_buffer)) {
@@ -718,7 +714,7 @@ static int find_cifs_entry(const int xid, struct cifsTconInfo *pTcon,
                pos_in_buf = index_to_find - first_entry_in_buffer;
                cFYI(1, ("found entry - pos_in_buf %d", pos_in_buf));
-                for (i=0; (i < (pos_in_buf)) && (current_entry != NULL); i++) {
+                for (i = 0; (i < (pos_in_buf)) && (current_entry != NULL); i++) {
                        /* go entry by entry figuring out which is first */
                        current_entry = nxt_dir_entry(current_entry, end_of_smb,
                                                cifsFile->srch_inf.info_level);
@@ -793,7 +789,7 @@ static int cifs_get_name_from_search_buf(struct qstr *pqst,
                filename = &pFindData->FileName[0];
                len = le32_to_cpu(pFindData->FileNameLength);
        } else if (level == SMB_FIND_FILE_INFO_STANDARD) {
-                FIND_FILE_STANDARD_INFO * pFindData =
+                FIND_FILE_STANDARD_INFO *pFindData =
                        (FIND_FILE_STANDARD_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                /* one byte length, no name conversion */
@@ -928,7 +924,7 @@ static int cifs_save_resume_key(const char *current_entry,
        level = cifsFile->srch_inf.info_level;
        if (level == SMB_FIND_FILE_UNIX) {
-                FILE_UNIX_INFO * pFindData = (FILE_UNIX_INFO *)current_entry;
+                FILE_UNIX_INFO *pFindData = (FILE_UNIX_INFO *)current_entry;
                filename = &pFindData->FileName[0];
                if (cifsFile->srch_inf.unicode) {
diff --git a/fs/cifs/sess.c b/fs/cifs/sess.c
index d2153abcba6d..ed150efbe27c 100644
--- a/fs/cifs/sess.c
+++ b/fs/cifs/sess.c
@@ -417,10 +417,6 @@ CIFS_SessSetup(unsigned int xid, struct cifsSesInfo *ses, int first_time,
                calc_lanman_hash(ses, lnm_session_key);
                ses->flags |= CIFS_SES_LANMAN;
-/* #ifdef CONFIG_CIFS_DEBUG2
-                cifs_dump_mem("cryptkey: ",ses->server->cryptKey,
-                        CIFS_SESS_KEY_SIZE);
-#endif */
                memcpy(bcc_ptr, (char *)lnm_session_key, CIFS_SESS_KEY_SIZE);
                bcc_ptr += CIFS_SESS_KEY_SIZE;
diff --git a/fs/cifs/smbdes.c b/fs/cifs/smbdes.c
index cfa6d21fb4e8..04943c976f98 100644
--- a/fs/cifs/smbdes.c
+++ b/fs/cifs/smbdes.c
@@ -114,42 +114,42 @@ static uchar sbox[8][4][16] = {
        {{14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7},
         {0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8},
         {4, 1, 14, 8, 13, 6, 2, 11, 15, 12, 9, 7, 3, 10, 5, 0},
-         {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13}},
+         {15, 12, 8, 2, 4, 9, 1, 7, 5, 11, 3, 14, 10, 0, 6, 13} },
        {{15, 1, 8, 14, 6, 11, 3, 4, 9, 7, 2, 13, 12, 0, 5, 10},
         {3, 13, 4, 7, 15, 2, 8, 14, 12, 0, 1, 10, 6, 9, 11, 5},
         {0, 14, 7, 11, 10, 4, 13, 1, 5, 8, 12, 6, 9, 3, 2, 15},
-         {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9}},
+         {13, 8, 10, 1, 3, 15, 4, 2, 11, 6, 7, 12, 0, 5, 14, 9} },
        {{10, 0, 9, 14, 6, 3, 15, 5, 1, 13, 12, 7, 11, 4, 2, 8},
         {13, 7, 0, 9, 3, 4, 6, 10, 2, 8, 5, 14, 12, 11, 15, 1},
         {13, 6, 4, 9, 8, 15, 3, 0, 11, 1, 2, 12, 5, 10, 14, 7},
-         {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12}},
+         {1, 10, 13, 0, 6, 9, 8, 7, 4, 15, 14, 3, 11, 5, 2, 12} },
        {{7, 13, 14, 3, 0, 6, 9, 10, 1, 2, 8, 5, 11, 12, 4, 15},
         {13, 8, 11, 5, 6, 15, 0, 3, 4, 7, 2, 12, 1, 10, 14, 9},
         {10, 6, 9, 0, 12, 11, 7, 13, 15, 1, 3, 14, 5, 2, 8, 4},
-         {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14}},
+         {3, 15, 0, 6, 10, 1, 13, 8, 9, 4, 5, 11, 12, 7, 2, 14} },
        {{2, 12, 4, 1, 7, 10, 11, 6, 8, 5, 3, 15, 13, 0, 14, 9},
         {14, 11, 2, 12, 4, 7, 13, 1, 5, 0, 15, 10, 3, 9, 8, 6},
         {4, 2, 1, 11, 10, 13, 7, 8, 15, 9, 12, 5, 6, 3, 0, 14},
-         {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3}},
+         {11, 8, 12, 7, 1, 14, 2, 13, 6, 15, 0, 9, 10, 4, 5, 3} },
        {{12, 1, 10, 15, 9, 2, 6, 8, 0, 13, 3, 4, 14, 7, 5, 11},
         {10, 15, 4, 2, 7, 12, 9, 5, 6, 1, 13, 14, 0, 11, 3, 8},
         {9, 14, 15, 5, 2, 8, 12, 3, 7, 0, 4, 10, 1, 13, 11, 6},
-         {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13}},
+         {4, 3, 2, 12, 9, 5, 15, 10, 11, 14, 1, 7, 6, 0, 8, 13} },
        {{4, 11, 2, 14, 15, 0, 8, 13, 3, 12, 9, 7, 5, 10, 6, 1},
         {13, 0, 11, 7, 4, 9, 1, 10, 14, 3, 5, 12, 2, 15, 8, 6},
         {1, 4, 11, 13, 12, 3, 7, 14, 10, 15, 6, 8, 0, 5, 9, 2},
-         {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12}},
+         {6, 11, 13, 8, 1, 4, 10, 7, 9, 5, 0, 15, 14, 2, 3, 12} },
        {{13, 2, 8, 4, 6, 15, 11, 1, 10, 9, 3, 14, 5, 0, 12, 7},
         {1, 15, 13, 8, 10, 3, 7, 4, 12, 5, 6, 11, 0, 14, 9, 2},
         {7, 11, 4, 1, 9, 12, 14, 2, 0, 6, 10, 13, 15, 3, 5, 8},
-         {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11}}
+         {2, 1, 14, 7, 4, 10, 8, 13, 15, 12, 9, 0, 3, 5, 6, 11} }
 };
 static void
@@ -313,9 +313,8 @@ str_to_key(unsigned char *str, unsigned char *key)
        key[5] = ((str[4] & 0x1F) << 2) | (str[5] >> 6);
        key[6] = ((str[5] & 0x3F) << 1) | (str[6] >> 7);
        key[7] = str[6] & 0x7F;
-        for (i = 0; i < 8; i++) {
+        for (i = 0; i < 8; i++)
                key[i] = (key[i] << 1);
-        }
 }
 static void
@@ -344,9 +343,8 @@ smbhash(unsigned char *out, unsigned char *in, unsigned char *key, int forw)
        dohash(outb, inb, keyb, forw);
-        for (i = 0; i < 8; i++) {
+        for (i = 0; i < 8; i++)
                out[i] = 0;
-        }
        for (i = 0; i < 64; i++) {
                if (outb[i])
diff --git a/fs/cifs/transport.c b/fs/cifs/transport.c
index 50b623ad9320..3612d6c0a0bb 100644
--- a/fs/cifs/transport.c
+++ b/fs/cifs/transport.c
@@ -1,7 +1,7 @@
 /*
 *   fs/cifs/transport.c
 *
- *   Copyright (C) International Business Machines  Corp., 2002,2007
+ *   Copyright (C) International Business Machines  Corp., 2002,2008
 *   Author(s): Steve French (sfrench@us.ibm.com)
 *   Jeremy Allison (jra@samba.org) 2006.
 *
@@ -358,9 +358,9 @@ static int allocate_mid(struct cifsSesInfo *ses, struct smb_hdr *in_buf,
        } else if (ses->status != CifsGood) {
                /* check if SMB session is bad because we are setting it up */
                if ((in_buf->Command != SMB_COM_SESSION_SETUP_ANDX) &&
-                        (in_buf->Command != SMB_COM_NEGOTIATE)) {
+                        (in_buf->Command != SMB_COM_NEGOTIATE))
                        return -EAGAIN;
-                } /* else ok - we are setting up session */
+                /* else ok - we are setting up session */
        }
        *ppmidQ = AllocMidQEntry(in_buf, ses);
        if (*ppmidQ == NULL)
@@ -437,9 +437,8 @@ SendReceiveNoRsp(const unsigned int xid, struct cifsSesInfo *ses,
        iov[0].iov_len = in_buf->smb_buf_length + 4;
        flags |= CIFS_NO_RESP;
        rc = SendReceive2(xid, ses, iov, 1, &resp_buf_type, flags);
-#ifdef CONFIG_CIFS_DEBUG2
+        cFYI(DBG2, ("SendRcvNoRsp flags %d rc %d", flags, rc));
-        cFYI(1, ("SendRcvNoR flags %d rc %d", flags, rc));
-#endif
        return rc;
 }
diff --git a/fs/cifs/xattr.c b/fs/cifs/xattr.c
index 54e8ef96cb79..8cd6a445b017 100644
--- a/fs/cifs/xattr.c
+++ b/fs/cifs/xattr.c
@@ -139,9 +139,9 @@ int cifs_setxattr(struct dentry *direntry, const char *ea_name,
        } else if (strncmp(ea_name, CIFS_XATTR_USER_PREFIX, 5) == 0) {
                if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_XATTR)
                        goto set_ea_exit;
-                if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0) {
+                if (strncmp(ea_name, CIFS_XATTR_DOS_ATTRIB, 14) == 0)
                        cFYI(1, ("attempt to set cifs inode metadata"));
-                }
                ea_name += 5; /* skip past user. prefix */
                rc = CIFSSMBSetEA(xid, pTcon, full_path, ea_name, ea_value,
                        (__u16)value_size, cifs_sb->local_nls,
@@ -262,7 +262,7 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
                                cifs_sb->mnt_cifs_flags &
                                        CIFS_MOUNT_MAP_SPECIAL_CHR);
 #ifdef CONFIG_CIFS_EXPERIMENTAL
-                else if(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
+                else if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_CIFS_ACL) {
                        __u16 fid;
                        int oplock = FALSE;
                        struct cifs_ntsd *pacl = NULL;
@@ -303,11 +303,10 @@ ssize_t cifs_getxattr(struct dentry *direntry, const char *ea_name,
        } else if (strncmp(ea_name,
                  CIFS_XATTR_SECURITY_PREFIX, XATTR_SECURITY_PREFIX_LEN) == 0) {
                cFYI(1, ("Security xattr namespace not supported yet"));
-        } else {
+        } else
                cFYI(1,
                    ("illegal xattr request %s (only user namespace supported)",
                        ea_name));
-        }
        /* We could add an additional check for streams ie
            if proc/fs/cifs/streamstoxattr is set then
diff --git a/fs/debugfs/inode.c b/fs/debugfs/inode.c
index d26e2826ba5b..e9602d85c11d 100644
--- a/fs/debugfs/inode.c
+++ b/fs/debugfs/inode.c
@@ -29,10 +29,6 @@
 #define DEBUGFS_MAGIC   0x64626720
-/* declared over in file.c */
-extern struct file_operations debugfs_file_operations;
-extern struct inode_operations debugfs_link_operations;
 static struct vfsmount *debugfs_mount;
 static int debugfs_mount_count;
diff --git a/fs/dlm/rcom.c b/fs/dlm/rcom.c
index 035e6f9990b0..67522c268c14 100644
--- a/fs/dlm/rcom.c
+++ b/fs/dlm/rcom.c
@@ -215,6 +215,8 @@ int dlm_rcom_names(struct dlm_ls *ls, int nodeid, char *last_name, int last_len)
        ls->ls_recover_nodeid = nodeid;
        if (nodeid == dlm_our_nodeid()) {
+                ls->ls_recover_buf->rc_header.h_length =
+                        dlm_config.ci_buffer_size;
                dlm_copy_master_names(ls, last_name, last_len,
                                      ls->ls_recover_buf->rc_buf,
                                      max_size, nodeid);
diff --git a/fs/dquot.c b/fs/dquot.c
index 9c7feb62eed1..41b9dbd68b0e 100644
--- a/fs/dquot.c
+++ b/fs/dquot.c
@@ -1522,8 +1522,8 @@ int vfs_quota_off(struct super_block *sb, int type)
                                truncate_inode_pages(&toputinode[cnt]->i_data, 0);
                                mutex_unlock(&toputinode[cnt]->i_mutex);
                                mark_inode_dirty(toputinode[cnt]);
-                                iput(toputinode[cnt]);
                        }
+                        iput(toputinode[cnt]);
                        mutex_unlock(&dqopt->dqonoff_mutex);
                }
        if (sb->s_bdev)
diff --git a/fs/ecryptfs/dentry.c b/fs/ecryptfs/dentry.c
index 841a032050a7..5e596583946c 100644
--- a/fs/ecryptfs/dentry.c
+++ b/fs/ecryptfs/dentry.c
@@ -80,8 +80,8 @@ static void ecryptfs_d_release(struct dentry *dentry)
 {
        if (ecryptfs_dentry_to_private(dentry)) {
                if (ecryptfs_dentry_to_lower(dentry)) {
-                        mntput(ecryptfs_dentry_to_lower_mnt(dentry));
                        dput(ecryptfs_dentry_to_lower(dentry));
+                        mntput(ecryptfs_dentry_to_lower_mnt(dentry));
                }
                kmem_cache_free(ecryptfs_dentry_info_cache,
                                ecryptfs_dentry_to_private(dentry));
diff --git a/fs/ecryptfs/mmap.c b/fs/ecryptfs/mmap.c
index dc74b186145d..6df1debdccce 100644
--- a/fs/ecryptfs/mmap.c
+++ b/fs/ecryptfs/mmap.c
@@ -263,52 +263,102 @@ out:
        return 0;
 }
-/* This function must zero any hole we create */
+/**
+ * ecryptfs_prepare_write
+ * @file: The eCryptfs file
+ * @page: The eCryptfs page
+ * @from: The start byte from which we will write
+ * @to: The end byte to which we will write
+ *
+ * This function must zero any hole we create
+ *
+ * Returns zero on success; non-zero otherwise
+ */
 static int ecryptfs_prepare_write(struct file *file, struct page *page,
                                  unsigned from, unsigned to)
 {
-        int rc = 0;
        loff_t prev_page_end_size;
+        int rc = 0;
        if (!PageUptodate(page)) {
-                rc = ecryptfs_read_lower_page_segment(page, page->index, 0,
+                struct ecryptfs_crypt_stat *crypt_stat =
-                                                      PAGE_CACHE_SIZE,
+                        &ecryptfs_inode_to_private(
-                                                      page->mapping->host);
+                                file->f_path.dentry->d_inode)->crypt_stat;
-                if (rc) {
-                        printk(KERN_ERR "%s: Error attemping to read lower "
+                if (!(crypt_stat->flags & ECRYPTFS_ENCRYPTED)
-                               "page segment; rc = [%d]\n", __FUNCTION__, rc);
+                    || (crypt_stat->flags & ECRYPTFS_NEW_FILE)) {
-                        ClearPageUptodate(page);
+                        rc = ecryptfs_read_lower_page_segment(
-                        goto out;
+                                page, page->index, 0, PAGE_CACHE_SIZE,
-                } else
+                                page->mapping->host);
+                        if (rc) {
+                                printk(KERN_ERR "%s: Error attemping to read "
+                                       "lower page segment; rc = [%d]\n",
+                                       __FUNCTION__, rc);
+                                ClearPageUptodate(page);
+                                goto out;
+                        } else
+                                SetPageUptodate(page);
+                } else if (crypt_stat->flags & ECRYPTFS_VIEW_AS_ENCRYPTED) {
+                        if (crypt_stat->flags & ECRYPTFS_METADATA_IN_XATTR) {
+                                rc = ecryptfs_copy_up_encrypted_with_header(
+                                        page, crypt_stat);
+                                if (rc) {
+                                        printk(KERN_ERR "%s: Error attempting "
+                                               "to copy the encrypted content "
+                                               "from the lower file whilst "
+                                               "inserting the metadata from "
+                                               "the xattr into the header; rc "
+                                               "= [%d]\n", __FUNCTION__, rc);
+                                        ClearPageUptodate(page);
+                                        goto out;
+                                }
+                                SetPageUptodate(page);
+                        } else {
+                                rc = ecryptfs_read_lower_page_segment(
+                                        page, page->index, 0, PAGE_CACHE_SIZE,
+                                        page->mapping->host);
+                                if (rc) {
+                                        printk(KERN_ERR "%s: Error reading "
+                                               "page; rc = [%d]\n",
+                                               __FUNCTION__, rc);
+                                        ClearPageUptodate(page);
+                                        goto out;
+                                }
+                                SetPageUptodate(page);
+                        }
+                } else {
+                        rc = ecryptfs_decrypt_page(page);
+                        if (rc) {
+                                printk(KERN_ERR "%s: Error decrypting page "
+                                       "at index [%ld]; rc = [%d]\n",
+                                       __FUNCTION__, page->index, rc);
+                                ClearPageUptodate(page);
+                                goto out;
+                        }
                        SetPageUptodate(page);
+                }
        }
        prev_page_end_size = ((loff_t)page->index << PAGE_CACHE_SHIFT);
+        /* If creating a page or more of holes, zero them out via truncate.
-        /*
+         * Note, this will increase i_size. */
-         * If creating a page or more of holes, zero them out via truncate.
-         * Note, this will increase i_size.
-         */
        if (page->index != 0) {
                if (prev_page_end_size > i_size_read(page->mapping->host)) {
                        rc = ecryptfs_truncate(file->f_path.dentry,
                                               prev_page_end_size);
                        if (rc) {
-                                printk(KERN_ERR "Error on attempt to "
+                                printk(KERN_ERR "%s: Error on attempt to "
                                       "truncate to (higher) offset [%lld];"
-                                       " rc = [%d]\n", prev_page_end_size, rc);
+                                       " rc = [%d]\n", __FUNCTION__,
+                                       prev_page_end_size, rc);
                                goto out;
                        }
                }
        }
-        /*
+        /* Writing to a new page, and creating a small hole from start
-         * Writing to a new page, and creating a small hole from start of page?
+         * of page?  Zero it out. */
-         * Zero it out.
+        if ((i_size_read(page->mapping->host) == prev_page_end_size)
-         */
+            && (from != 0))
-        if ((i_size_read(page->mapping->host) == prev_page_end_size) &&
-            (from != 0)) {
                zero_user(page, 0, PAGE_CACHE_SIZE);
-        }
 out:
        return rc;
 }
diff --git a/fs/efs/dir.c b/fs/efs/dir.c
index dfb5cb400217..49308a29798a 100644
--- a/fs/efs/dir.c
+++ b/fs/efs/dir.c
@@ -5,8 +5,8 @@
 */
 #include <linux/buffer_head.h>
-#include <linux/efs_fs.h>
 #include <linux/smp_lock.h>
+#include "efs.h"
 static int efs_readdir(struct file *, void *, filldir_t);
diff --git a/fs/efs/efs.h b/fs/efs/efs.h
new file mode 100644
index 000000000000..d8305b582ab0
--- /dev/null
+++ b/fs/efs/efs.h
@@ -0,0 +1,140 @@
+/*
+ * Copyright (c) 1999 Al Smith
+ *
+ * Portions derived from work (c) 1995,1996 Christian Vogelgsang.
+ * Portions derived from IRIX header files (c) 1988 Silicon Graphics
+ */
+#ifndef _EFS_EFS_H_
+#define _EFS_EFS_H_
+#include <linux/fs.h>
+#include <asm/uaccess.h>
+#define EFS_VERSION "1.0a"
+static const char cprt[] = "EFS: "EFS_VERSION" - (c) 1999 Al Smith <Al.Smith@aeschi.ch.eu.org>";
+/* 1 block is 512 bytes */
+#define EFS_BLOCKSIZE_BITS      9
+#define EFS_BLOCKSIZE           (1 << EFS_BLOCKSIZE_BITS)
+typedef int32_t         efs_block_t;
+typedef uint32_t        efs_ino_t;
+#define EFS_DIRECTEXTENTS       12
+/*
+ * layout of an extent, in memory and on disk. 8 bytes exactly.
+ */
+typedef union extent_u {
+        unsigned char raw[8];
+        struct extent_s {
+                unsigned int    ex_magic:8;     /* magic # (zero) */
+                unsigned int    ex_bn:24;       /* basic block */
+                unsigned int    ex_length:8;    /* numblocks in this extent */
+                unsigned int    ex_offset:24;   /* logical offset into file */
+        } cooked;
+} efs_extent;
+typedef struct edevs {
+        __be16          odev;
+        __be32          ndev;
+} efs_devs;
+/*
+ * extent based filesystem inode as it appears on disk.  The efs inode
+ * is exactly 128 bytes long.
+ */
+struct  efs_dinode {
+        __be16          di_mode;        /* mode and type of file */
+        __be16          di_nlink;       /* number of links to file */
+        __be16          di_uid;         /* owner's user id */
+        __be16          di_gid;         /* owner's group id */
+        __be32          di_size;        /* number of bytes in file */
+        __be32          di_atime;       /* time last accessed */
+        __be32          di_mtime;       /* time last modified */
+        __be32          di_ctime;       /* time created */
+        __be32          di_gen;         /* generation number */
+        __be16          di_numextents;  /* # of extents */
+        u_char          di_version;     /* version of inode */
+        u_char          di_spare;       /* spare - used by AFS */
+        union di_addr {
+                efs_extent      di_extents[EFS_DIRECTEXTENTS];
+                efs_devs        di_dev; /* device for IFCHR/IFBLK */
+        } di_u;
+};
+/* efs inode storage in memory */
+struct efs_inode_info {
+        int             numextents;
+        int             lastextent;
+        efs_extent      extents[EFS_DIRECTEXTENTS];
+        struct inode    vfs_inode;
+};
+#include <linux/efs_fs_sb.h>
+#define EFS_DIRBSIZE_BITS       EFS_BLOCKSIZE_BITS
+#define EFS_DIRBSIZE            (1 << EFS_DIRBSIZE_BITS)
+struct efs_dentry {
+        __be32          inode;
+        unsigned char   namelen;
+        char            name[3];
+};
+#define EFS_DENTSIZE    (sizeof(struct efs_dentry) - 3 + 1)
+#define EFS_MAXNAMELEN  ((1 << (sizeof(char) * 8)) - 1)
+#define EFS_DIRBLK_HEADERSIZE   4
+#define EFS_DIRBLK_MAGIC        0xbeef  /* moo */
+struct efs_dir {
+        __be16  magic;
+        unsigned char   firstused;
+        unsigned char   slots;
+        unsigned char   space[EFS_DIRBSIZE - EFS_DIRBLK_HEADERSIZE];
+};
+#define EFS_MAXENTS \
+        ((EFS_DIRBSIZE - EFS_DIRBLK_HEADERSIZE) / \
+         (EFS_DENTSIZE + sizeof(char)))
+#define EFS_SLOTAT(dir, slot) EFS_REALOFF((dir)->space[slot])
+#define EFS_REALOFF(offset) ((offset << 1))
+static inline struct efs_inode_info *INODE_INFO(struct inode *inode)
+{
+        return container_of(inode, struct efs_inode_info, vfs_inode);
+}
+static inline struct efs_sb_info *SUPER_INFO(struct super_block *sb)
+{
+        return sb->s_fs_info;
+}
+struct statfs;
+struct fid;
+extern const struct inode_operations efs_dir_inode_operations;
+extern const struct file_operations efs_dir_operations;
+extern const struct address_space_operations efs_symlink_aops;
+extern struct inode *efs_iget(struct super_block *, unsigned long);
+extern efs_block_t efs_map_block(struct inode *, efs_block_t);
+extern int efs_get_block(struct inode *, sector_t, struct buffer_head *, int);
+extern struct dentry *efs_lookup(struct inode *, struct dentry *, struct nameidata *);
+extern struct dentry *efs_fh_to_dentry(struct super_block *sb, struct fid *fid,
+                int fh_len, int fh_type);
+extern struct dentry *efs_fh_to_parent(struct super_block *sb, struct fid *fid,
+                int fh_len, int fh_type);
+extern struct dentry *efs_get_parent(struct dentry *);
+extern int efs_bmap(struct inode *, int);
+#endif /* _EFS_EFS_H_ */
diff --git a/fs/efs/file.c b/fs/efs/file.c
index 5db20129681e..1ccb364ffa63 100644
--- a/fs/efs/file.c
+++ b/fs/efs/file.c
@@ -7,7 +7,7 @@
 */
 #include <linux/buffer_head.h>
-#include <linux/efs_fs.h>
+#include "efs.h"
 int efs_get_block(struct inode *inode, sector_t iblock,
                  struct buffer_head *bh_result, int create)
diff --git a/fs/efs/inode.c b/fs/efs/inode.c
index 627c3026946d..a8e7797b9477 100644
--- a/fs/efs/inode.c
+++ b/fs/efs/inode.c
@@ -7,11 +7,11 @@
 *              and from work (c) 1998 Mike Shaver.
 */
-#include <linux/efs_fs.h>
-#include <linux/efs_fs_sb.h>
 #include <linux/buffer_head.h>
 #include <linux/module.h>
 #include <linux/fs.h>
+#include "efs.h"
+#include <linux/efs_fs_sb.h>
 static int efs_readpage(struct file *file, struct page *page)
 {
@@ -140,7 +140,7 @@ struct inode *efs_iget(struct super_block *super, unsigned long ino)
        brelse(bh);
   
 #ifdef DEBUG
-        printk(KERN_DEBUG "EFS: read_inode(): inode %lu, extents %d, mode %o\n",
+        printk(KERN_DEBUG "EFS: efs_iget(): inode %lu, extents %d, mode %o\n",
                inode->i_ino, in->numextents, inode->i_mode);
 #endif
diff --git a/fs/efs/namei.c b/fs/efs/namei.c
index e26704742d41..3a404e7fad53 100644
--- a/fs/efs/namei.c
+++ b/fs/efs/namei.c
@@ -8,9 +8,9 @@
 #include <linux/buffer_head.h>
 #include <linux/string.h>
-#include <linux/efs_fs.h>
 #include <linux/smp_lock.h>
 #include <linux/exportfs.h>
+#include "efs.h"
 static efs_ino_t efs_find_entry(struct inode *inode, const char *name, int len) {
diff --git a/fs/efs/super.c b/fs/efs/super.c
index 14082405cdd1..d733531b55e2 100644
--- a/fs/efs/super.c
+++ b/fs/efs/super.c
@@ -8,14 +8,15 @@
 #include <linux/init.h>
 #include <linux/module.h>
-#include <linux/efs_fs.h>
-#include <linux/efs_vh.h>
-#include <linux/efs_fs_sb.h>
 #include <linux/exportfs.h>
 #include <linux/slab.h>
 #include <linux/buffer_head.h>
 #include <linux/vfs.h>
+#include "efs.h"
+#include <linux/efs_vh.h>
+#include <linux/efs_fs_sb.h>
 static int efs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int efs_fill_super(struct super_block *s, void *d, int silent);
diff --git a/fs/efs/symlink.c b/fs/efs/symlink.c
index 1d30d2ff440f..41911ec83aaf 100644
--- a/fs/efs/symlink.c
+++ b/fs/efs/symlink.c
@@ -7,10 +7,10 @@
 */
 #include <linux/string.h>
-#include <linux/efs_fs.h>
 #include <linux/pagemap.h>
 #include <linux/buffer_head.h>
 #include <linux/smp_lock.h>
+#include "efs.h"
 static int efs_symlink_readpage(struct file *file, struct page *page)
 {
diff --git a/fs/exec.c b/fs/exec.c
index a44b142fb460..54a0a557b678 100644
--- a/fs/exec.c
+++ b/fs/exec.c
@@ -173,8 +173,15 @@ static struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,
                return NULL;
        if (write) {
-                struct rlimit *rlim = current->signal->rlim;
                unsigned long size = bprm->vma->vm_end - bprm->vma->vm_start;
+                struct rlimit *rlim;
+                /*
+                 * We've historically supported up to 32 pages (ARG_MAX)
+                 * of argument strings even with small stacks
+                 */
+                if (size <= ARG_MAX)
+                        return page;
                /*
                 * Limit to 1/4-th the stack size for the argv+env strings.
@@ -183,6 +190,7 @@ static struct page *get_arg_page(struct linux_binprm *bprm, unsigned long pos,
                 *  - the program will have a reasonable amount of stack left
                 *    to work from.
                 */
+                rlim = current->signal->rlim;
                if (size > rlim[RLIMIT_STACK].rlim_cur / 4) {
                        put_page(page);
                        return NULL;
diff --git a/fs/ext2/xattr.c b/fs/ext2/xattr.c
index 3e8683dbb13f..a99d46f3b26e 100644
--- a/fs/ext2/xattr.c
+++ b/fs/ext2/xattr.c
@@ -835,7 +835,7 @@ ext2_xattr_cache_insert(struct buffer_head *bh)
        struct mb_cache_entry *ce;
        int error;
-        ce = mb_cache_entry_alloc(ext2_xattr_cache);
+        ce = mb_cache_entry_alloc(ext2_xattr_cache, GFP_NOFS);
        if (!ce)
                return -ENOMEM;
        error = mb_cache_entry_insert(ce, bh->b_bdev, bh->b_blocknr, &hash);
diff --git a/fs/ext3/acl.c b/fs/ext3/acl.c
index d34e9967430a..a754d1848173 100644
--- a/fs/ext3/acl.c
+++ b/fs/ext3/acl.c
@@ -37,7 +37,7 @@ ext3_acl_from_disk(const void *value, size_t size)
                return ERR_PTR(-EINVAL);
        if (count == 0)
                return NULL;
-        acl = posix_acl_alloc(count, GFP_KERNEL);
+        acl = posix_acl_alloc(count, GFP_NOFS);
        if (!acl)
                return ERR_PTR(-ENOMEM);
        for (n=0; n < count; n++) {
@@ -91,7 +91,7 @@ ext3_acl_to_disk(const struct posix_acl *acl, size_t *size)
        *size = ext3_acl_size(acl->a_count);
        ext_acl = kmalloc(sizeof(ext3_acl_header) + acl->a_count *
-                        sizeof(ext3_acl_entry), GFP_KERNEL);
+                        sizeof(ext3_acl_entry), GFP_NOFS);
        if (!ext_acl)
                return ERR_PTR(-ENOMEM);
        ext_acl->a_version = cpu_to_le32(EXT3_ACL_VERSION);
@@ -187,7 +187,7 @@ ext3_get_acl(struct inode *inode, int type)
        }
        retval = ext3_xattr_get(inode, name_index, "", NULL, 0);
        if (retval > 0) {
-                value = kmalloc(retval, GFP_KERNEL);
+                value = kmalloc(retval, GFP_NOFS);
                if (!value)
                        return ERR_PTR(-ENOMEM);
                retval = ext3_xattr_get(inode, name_index, "", value, retval);
@@ -335,7 +335,7 @@ ext3_init_acl(handle_t *handle, struct inode *inode, struct inode *dir)
                        if (error)
                                goto cleanup;
                }
-                clone = posix_acl_clone(acl, GFP_KERNEL);
+                clone = posix_acl_clone(acl, GFP_NOFS);
                error = -ENOMEM;
                if (!clone)
                        goto cleanup;
diff --git a/fs/ext3/resize.c b/fs/ext3/resize.c
index 9397d779c43d..0e97b6e07cb0 100644
--- a/fs/ext3/resize.c
+++ b/fs/ext3/resize.c
@@ -485,7 +485,7 @@ static int add_new_gdb(handle_t *handle, struct inode *inode,
                goto exit_dindj;
        n_group_desc = kmalloc((gdb_num + 1) * sizeof(struct buffer_head *),
-                        GFP_KERNEL);
+                        GFP_NOFS);
        if (!n_group_desc) {
                err = -ENOMEM;
                ext3_warning (sb, __FUNCTION__,
@@ -568,7 +568,7 @@ static int reserve_backup_gdb(handle_t *handle, struct inode *inode,
        int res, i;
        int err;
-        primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_KERNEL);
+        primary = kmalloc(reserved_gdb * sizeof(*primary), GFP_NOFS);
        if (!primary)
                return -ENOMEM;
diff --git a/fs/ext3/super.c b/fs/ext3/super.c
index 18769cc32377..ad5360664082 100644
--- a/fs/ext3/super.c
+++ b/fs/ext3/super.c
@@ -806,8 +806,8 @@ static match_table_t tokens = {
        {Opt_quota, "quota"},
        {Opt_usrquota, "usrquota"},
        {Opt_barrier, "barrier=%u"},
-        {Opt_err, NULL},
        {Opt_resize, "resize"},
+        {Opt_err, NULL},
 };
 static ext3_fsblk_t get_sb_block(void **data)
diff --git a/fs/ext3/xattr.c b/fs/ext3/xattr.c
index fb89c299bece..42856541e9a5 100644
--- a/fs/ext3/xattr.c
+++ b/fs/ext3/xattr.c
@@ -728,7 +728,7 @@ ext3_xattr_block_set(handle_t *handle, struct inode *inode,
                                ce = NULL;
                        }
                        ea_bdebug(bs->bh, "cloning");
-                        s->base = kmalloc(bs->bh->b_size, GFP_KERNEL);
+                        s->base = kmalloc(bs->bh->b_size, GFP_NOFS);
                        error = -ENOMEM;
                        if (s->base == NULL)
                                goto cleanup;
@@ -740,7 +740,7 @@ ext3_xattr_block_set(handle_t *handle, struct inode *inode,
                }
        } else {
                /* Allocate a buffer where we construct the new block. */
-                s->base = kzalloc(sb->s_blocksize, GFP_KERNEL);
+                s->base = kzalloc(sb->s_blocksize, GFP_NOFS);
                /* assert(header == s->base) */
                error = -ENOMEM;
                if (s->base == NULL)
@@ -1126,7 +1126,7 @@ ext3_xattr_cache_insert(struct buffer_head *bh)
        struct mb_cache_entry *ce;
        int error;
-        ce = mb_cache_entry_alloc(ext3_xattr_cache);
+        ce = mb_cache_entry_alloc(ext3_xattr_cache, GFP_NOFS);
        if (!ce) {
                ea_bdebug(bh, "out of memory");
                return;
diff --git a/fs/ext4/dir.c b/fs/ext4/dir.c
index 33888bb58144..2c23bade9aa6 100644
--- a/fs/ext4/dir.c
+++ b/fs/ext4/dir.c
@@ -46,7 +46,7 @@ const struct file_operations ext4_dir_operations = {
 #ifdef CONFIG_COMPAT
        .compat_ioctl   = ext4_compat_ioctl,
 #endif
-        .fsync          = ext4_sync_file,       /* BKL held */
+        .fsync          = ext4_sync_file,
        .release        = ext4_release_dir,
 };
diff --git a/fs/ext4/extents.c b/fs/ext4/extents.c
index bc7081f1fbe8..9ae6e67090cd 100644
--- a/fs/ext4/extents.c
+++ b/fs/ext4/extents.c
@@ -148,6 +148,7 @@ static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
 {
        struct ext4_inode_info *ei = EXT4_I(inode);
        ext4_fsblk_t bg_start;
+        ext4_fsblk_t last_block;
        ext4_grpblk_t colour;
        int depth;
@@ -169,8 +170,13 @@ static ext4_fsblk_t ext4_ext_find_goal(struct inode *inode,
        /* OK. use inode's group */
        bg_start = (ei->i_block_group * EXT4_BLOCKS_PER_GROUP(inode->i_sb)) +
                le32_to_cpu(EXT4_SB(inode->i_sb)->s_es->s_first_data_block);
-        colour = (current->pid % 16) *
+        last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
+        if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
+                colour = (current->pid % 16) *
                        (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
+        else
+                colour = (current->pid % 16) * ((last_block - bg_start) / 16);
        return bg_start + colour + block;
 }
@@ -349,7 +355,7 @@ static void ext4_ext_show_leaf(struct inode *inode, struct ext4_ext_path *path)
 #define ext4_ext_show_leaf(inode,path)
 #endif
-static void ext4_ext_drop_refs(struct ext4_ext_path *path)
+void ext4_ext_drop_refs(struct ext4_ext_path *path)
 {
        int depth = path->p_depth;
        int i;
@@ -2168,6 +2174,10 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
        newblock = iblock - ee_block + ext_pblock(ex);
        ex2 = ex;
+        err = ext4_ext_get_access(handle, inode, path + depth);
+        if (err)
+                goto out;
        /* ex1: ee_block to iblock - 1 : uninitialized */
        if (iblock > ee_block) {
                ex1 = ex;
@@ -2200,16 +2210,20 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
                newdepth = ext_depth(inode);
                if (newdepth != depth) {
                        depth = newdepth;
-                        path = ext4_ext_find_extent(inode, iblock, NULL);
+                        ext4_ext_drop_refs(path);
+                        path = ext4_ext_find_extent(inode, iblock, path);
                        if (IS_ERR(path)) {
                                err = PTR_ERR(path);
-                                path = NULL;
                                goto out;
                        }
                        eh = path[depth].p_hdr;
                        ex = path[depth].p_ext;
                        if (ex2 != &newex)
                                ex2 = ex;
+                        err = ext4_ext_get_access(handle, inode, path + depth);
+                        if (err)
+                                goto out;
                }
                allocated = max_blocks;
        }
@@ -2230,9 +2244,6 @@ static int ext4_ext_convert_to_initialized(handle_t *handle,
        ex2->ee_len = cpu_to_le16(allocated);
        if (ex2 != ex)
                goto insert;
-        err = ext4_ext_get_access(handle, inode, path + depth);
-        if (err)
-                goto out;
        /*
         * New (initialized) extent starts from the first block
         * in the current extent. i.e., ex2 == ex
@@ -2276,9 +2287,22 @@ out:
 }
 /*
+ * Block allocation/map/preallocation routine for extents based files
+ *
+ *
 * Need to be called with
 * down_read(&EXT4_I(inode)->i_data_sem) if not allocating file system block
 * (ie, create is zero). Otherwise down_write(&EXT4_I(inode)->i_data_sem)
+ *
+ * return > 0, number of of blocks already mapped/allocated
+ *          if create == 0 and these are pre-allocated blocks
+ *              buffer head is unmapped
+ *          otherwise blocks are mapped
+ *
+ * return = 0, if plain look up failed (blocks have not been allocated)
+ *          buffer head is unmapped
+ *
+ * return < 0, error case.
 */
 int ext4_ext_get_blocks(handle_t *handle, struct inode *inode,
                        ext4_lblk_t iblock,
@@ -2623,7 +2647,7 @@ long ext4_fallocate(struct inode *inode, int mode, loff_t offset, loff_t len)
         * modify 1 super block, 1 block bitmap and 1 group descriptor.
         */
        credits = EXT4_DATA_TRANS_BLOCKS(inode->i_sb) + 3;
-        down_write((&EXT4_I(inode)->i_data_sem));
+        mutex_lock(&inode->i_mutex);
 retry:
        while (ret >= 0 && ret < max_blocks) {
                block = block + ret;
@@ -2634,16 +2658,17 @@ retry:
                        break;
                }
-                ret = ext4_ext_get_blocks(handle, inode, block,
+                ret = ext4_get_blocks_wrap(handle, inode, block,
                                          max_blocks, &map_bh,
                                          EXT4_CREATE_UNINITIALIZED_EXT, 0);
-                WARN_ON(ret <= 0);
                if (ret <= 0) {
-                        ext4_error(inode->i_sb, "ext4_fallocate",
+#ifdef EXT4FS_DEBUG
-                                    "ext4_ext_get_blocks returned error: "
+                        WARN_ON(ret <= 0);
-                                    "inode#%lu, block=%u, max_blocks=%lu",
+                        printk(KERN_ERR "%s: ext4_ext_get_blocks "
+                                    "returned error inode#%lu, block=%u, "
+                                    "max_blocks=%lu", __func__,
                                    inode->i_ino, block, max_blocks);
-                        ret = -EIO;
+#endif
                        ext4_mark_inode_dirty(handle, inode);
                        ret2 = ext4_journal_stop(handle);
                        break;
@@ -2680,7 +2705,6 @@ retry:
        if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
                goto retry;
-        up_write((&EXT4_I(inode)->i_data_sem));
        /*
         * Time to update the file size.
         * Update only when preallocation was requested beyond the file size.
@@ -2692,21 +2716,18 @@ retry:
                         * if no error, we assume preallocation succeeded
                         * completely
                         */
-                        mutex_lock(&inode->i_mutex);
                        i_size_write(inode, offset + len);
                        EXT4_I(inode)->i_disksize = i_size_read(inode);
-                        mutex_unlock(&inode->i_mutex);
                } else if (ret < 0 && nblocks) {
                        /* Handle partial allocation scenario */
                        loff_t newsize;
-                        mutex_lock(&inode->i_mutex);
                        newsize  = (nblocks << blkbits) + i_size_read(inode);
                        i_size_write(inode, EXT4_BLOCK_ALIGN(newsize, blkbits));
                        EXT4_I(inode)->i_disksize = i_size_read(inode);
-                        mutex_unlock(&inode->i_mutex);
                }
        }
+        mutex_unlock(&inode->i_mutex);
        return ret > 0 ? ret2 : ret;
 }
diff --git a/fs/ext4/ialloc.c b/fs/ext4/ialloc.c
index da18a74b966a..8036b9b5376b 100644
--- a/fs/ext4/ialloc.c
+++ b/fs/ext4/ialloc.c
@@ -702,7 +702,12 @@ got:
        ei->i_dir_start_lookup = 0;
        ei->i_disksize = 0;
-        ei->i_flags = EXT4_I(dir)->i_flags & ~EXT4_INDEX_FL;
+        /*
+         * Don't inherit extent flag from directory. We set extent flag on
+         * newly created directory and file only if -o extent mount option is
+         * specified
+         */
+        ei->i_flags = EXT4_I(dir)->i_flags & ~(EXT4_INDEX_FL|EXT4_EXTENTS_FL);
        if (S_ISLNK(mode))
                ei->i_flags &= ~(EXT4_IMMUTABLE_FL|EXT4_APPEND_FL);
        /* dirsync only applies to directories */
@@ -745,12 +750,15 @@ got:
                goto fail_free_drop;
        }
        if (test_opt(sb, EXTENTS)) {
-                EXT4_I(inode)->i_flags |= EXT4_EXTENTS_FL;
+                /* set extent flag only for directory and file */
-                ext4_ext_tree_init(handle, inode);
+                if (S_ISDIR(mode) || S_ISREG(mode)) {
-                err = ext4_update_incompat_feature(handle, sb,
+                        EXT4_I(inode)->i_flags |= EXT4_EXTENTS_FL;
-                                                EXT4_FEATURE_INCOMPAT_EXTENTS);
+                        ext4_ext_tree_init(handle, inode);
-                if (err)
+                        err = ext4_update_incompat_feature(handle, sb,
-                        goto fail;
+                                        EXT4_FEATURE_INCOMPAT_EXTENTS);
+                        if (err)
+                                goto fail;
+                }
        }
        ext4_debug("allocating inode %lu\n", inode->i_ino);
diff --git a/fs/ext4/inode.c b/fs/ext4/inode.c
index 7dd9b50d5ebc..945cbf6cb1fc 100644
--- a/fs/ext4/inode.c
+++ b/fs/ext4/inode.c
@@ -403,6 +403,7 @@ static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
        __le32 *start = ind->bh ? (__le32*) ind->bh->b_data : ei->i_data;
        __le32 *p;
        ext4_fsblk_t bg_start;
+        ext4_fsblk_t last_block;
        ext4_grpblk_t colour;
        /* Try to find previous block */
@@ -420,8 +421,13 @@ static ext4_fsblk_t ext4_find_near(struct inode *inode, Indirect *ind)
         * into the same cylinder group then.
         */
        bg_start = ext4_group_first_block_no(inode->i_sb, ei->i_block_group);
-        colour = (current->pid % 16) *
+        last_block = ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es) - 1;
+        if (bg_start + EXT4_BLOCKS_PER_GROUP(inode->i_sb) <= last_block)
+                colour = (current->pid % 16) *
                        (EXT4_BLOCKS_PER_GROUP(inode->i_sb) / 16);
+        else
+                colour = (current->pid % 16) * ((last_block - bg_start) / 16);
        return bg_start + colour;
 }
@@ -768,7 +774,6 @@ err_out:
 *
 * `handle' can be NULL if create == 0.
 *
- * The BKL may not be held on entry here.  Be sure to take it early.
 * return > 0, # of blocks mapped or allocated.
 * return = 0, if plain lookup failed.
 * return < 0, error case.
@@ -903,11 +908,38 @@ out:
 */
 #define DIO_CREDITS 25
+/*
+ *
+ *
+ * ext4_ext4 get_block() wrapper function
+ * It will do a look up first, and returns if the blocks already mapped.
+ * Otherwise it takes the write lock of the i_data_sem and allocate blocks
+ * and store the allocated blocks in the result buffer head and mark it
+ * mapped.
+ *
+ * If file type is extents based, it will call ext4_ext_get_blocks(),
+ * Otherwise, call with ext4_get_blocks_handle() to handle indirect mapping
+ * based files
+ *
+ * On success, it returns the number of blocks being mapped or allocate.
+ * if create==0 and the blocks are pre-allocated and uninitialized block,
+ * the result buffer head is unmapped. If the create ==1, it will make sure
+ * the buffer head is mapped.
+ *
+ * It returns 0 if plain look up failed (blocks have not been allocated), in
+ * that casem, buffer head is unmapped
+ *
+ * It returns the error in case of allocation failure.
+ */
 int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
                        unsigned long max_blocks, struct buffer_head *bh,
                        int create, int extend_disksize)
 {
        int retval;
+        clear_buffer_mapped(bh);
        /*
         * Try to see if we can get  the block without requesting
         * for new file system block.
@@ -921,12 +953,26 @@ int ext4_get_blocks_wrap(handle_t *handle, struct inode *inode, sector_t block,
                                inode, block, max_blocks, bh, 0, 0);
        }
        up_read((&EXT4_I(inode)->i_data_sem));
-        if (!create || (retval > 0))
+        /* If it is only a block(s) look up */
+        if (!create)
+                return retval;
+        /*
+         * Returns if the blocks have already allocated
+         *
+         * Note that if blocks have been preallocated
+         * ext4_ext_get_block() returns th create = 0
+         * with buffer head unmapped.
+         */
+        if (retval > 0 && buffer_mapped(bh))
                return retval;
        /*
-         * We need to allocate new blocks which will result
+         * New blocks allocate and/or writing to uninitialized extent
-         * in i_data update
+         * will possibly result in updating i_data, so we take
+         * the write lock of i_data_sem, and call get_blocks()
+         * with create == 1 flag.
         */
        down_write((&EXT4_I(inode)->i_data_sem));
        /*
diff --git a/fs/ext4/mballoc.c b/fs/ext4/mballoc.c
index dd0fcfcb35ce..ef97f19c2f9d 100644
--- a/fs/ext4/mballoc.c
+++ b/fs/ext4/mballoc.c
@@ -627,21 +627,19 @@ static ext4_fsblk_t ext4_grp_offs_to_block(struct super_block *sb,
        return block;
 }
+static inline void *mb_correct_addr_and_bit(int *bit, void *addr)
+{
 #if BITS_PER_LONG == 64
-#define mb_correct_addr_and_bit(bit, addr)              \
+        *bit += ((unsigned long) addr & 7UL) << 3;
-{                                                       \
+        addr = (void *) ((unsigned long) addr & ~7UL);
-        bit += ((unsigned long) addr & 7UL) << 3;       \
-        addr = (void *) ((unsigned long) addr & ~7UL);  \
-}
 #elif BITS_PER_LONG == 32
-#define mb_correct_addr_and_bit(bit, addr)              \
+        *bit += ((unsigned long) addr & 3UL) << 3;
-{                                                       \
+        addr = (void *) ((unsigned long) addr & ~3UL);
-        bit += ((unsigned long) addr & 3UL) << 3;       \
-        addr = (void *) ((unsigned long) addr & ~3UL);  \
-}
 #else
 #error "how many bits you are?!"
 #endif
+        return addr;
+}
 static inline int mb_test_bit(int bit, void *addr)
 {
@@ -649,34 +647,54 @@ static inline int mb_test_bit(int bit, void *addr)
         * ext4_test_bit on architecture like powerpc
         * needs unsigned long aligned address
         */
-        mb_correct_addr_and_bit(bit, addr);
+        addr = mb_correct_addr_and_bit(&bit, addr);
        return ext4_test_bit(bit, addr);
 }
 static inline void mb_set_bit(int bit, void *addr)
 {
-        mb_correct_addr_and_bit(bit, addr);
+        addr = mb_correct_addr_and_bit(&bit, addr);
        ext4_set_bit(bit, addr);
 }
 static inline void mb_set_bit_atomic(spinlock_t *lock, int bit, void *addr)
 {
-        mb_correct_addr_and_bit(bit, addr);
+        addr = mb_correct_addr_and_bit(&bit, addr);
        ext4_set_bit_atomic(lock, bit, addr);
 }
 static inline void mb_clear_bit(int bit, void *addr)
 {
-        mb_correct_addr_and_bit(bit, addr);
+        addr = mb_correct_addr_and_bit(&bit, addr);
        ext4_clear_bit(bit, addr);
 }
 static inline void mb_clear_bit_atomic(spinlock_t *lock, int bit, void *addr)
 {
-        mb_correct_addr_and_bit(bit, addr);
+        addr = mb_correct_addr_and_bit(&bit, addr);
        ext4_clear_bit_atomic(lock, bit, addr);
 }
+static inline int mb_find_next_zero_bit(void *addr, int max, int start)
+{
+        int fix = 0;
+        addr = mb_correct_addr_and_bit(&fix, addr);
+        max += fix;
+        start += fix;
+        return ext4_find_next_zero_bit(addr, max, start) - fix;
+}
+static inline int mb_find_next_bit(void *addr, int max, int start)
+{
+        int fix = 0;
+        addr = mb_correct_addr_and_bit(&fix, addr);
+        max += fix;
+        start += fix;
+        return ext4_find_next_bit(addr, max, start) - fix;
+}
 static void *mb_find_buddy(struct ext4_buddy *e4b, int order, int *max)
 {
        char *bb;
@@ -906,7 +924,7 @@ static void ext4_mb_mark_free_simple(struct super_block *sb,
        unsigned short chunk;
        unsigned short border;
-        BUG_ON(len >= EXT4_BLOCKS_PER_GROUP(sb));
+        BUG_ON(len > EXT4_BLOCKS_PER_GROUP(sb));
        border = 2 << sb->s_blocksize_bits;
@@ -946,12 +964,12 @@ static void ext4_mb_generate_buddy(struct super_block *sb,
        /* initialize buddy from bitmap which is aggregation
         * of on-disk bitmap and preallocations */
-        i = ext4_find_next_zero_bit(bitmap, max, 0);
+        i = mb_find_next_zero_bit(bitmap, max, 0);
        grp->bb_first_free = i;
        while (i < max) {
                fragments++;
                first = i;
-                i = ext4_find_next_bit(bitmap, max, i);
+                i = mb_find_next_bit(bitmap, max, i);
                len = i - first;
                free += len;
                if (len > 1)
@@ -959,7 +977,7 @@ static void ext4_mb_generate_buddy(struct super_block *sb,
                else
                        grp->bb_counters[0]++;
                if (i < max)
-                        i = ext4_find_next_zero_bit(bitmap, max, i);
+                        i = mb_find_next_zero_bit(bitmap, max, i);
        }
        grp->bb_fragments = fragments;
@@ -967,6 +985,10 @@ static void ext4_mb_generate_buddy(struct super_block *sb,
                ext4_error(sb, __FUNCTION__,
                        "EXT4-fs: group %lu: %u blocks in bitmap, %u in gd\n",
                        group, free, grp->bb_free);
+                /*
+                 * If we intent to continue, we consider group descritor
+                 * corrupt and update bb_free using bitmap value
+                 */
                grp->bb_free = free;
        }
@@ -1778,7 +1800,7 @@ static void ext4_mb_simple_scan_group(struct ext4_allocation_context *ac,
                buddy = mb_find_buddy(e4b, i, &max);
                BUG_ON(buddy == NULL);
-                k = ext4_find_next_zero_bit(buddy, max, 0);
+                k = mb_find_next_zero_bit(buddy, max, 0);
                BUG_ON(k >= max);
                ac->ac_found++;
@@ -1818,11 +1840,11 @@ static void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
        i = e4b->bd_info->bb_first_free;
        while (free && ac->ac_status == AC_STATUS_CONTINUE) {
-                i = ext4_find_next_zero_bit(bitmap,
+                i = mb_find_next_zero_bit(bitmap,
                                                EXT4_BLOCKS_PER_GROUP(sb), i);
                if (i >= EXT4_BLOCKS_PER_GROUP(sb)) {
                        /*
-                         * IF we corrupt the bitmap  we won't find any
+                         * IF we have corrupt bitmap, we won't find any
                         * free blocks even though group info says we
                         * we have free blocks
                         */
@@ -1838,6 +1860,12 @@ static void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
                        ext4_error(sb, __FUNCTION__, "%d free blocks as per "
                                        "group info. But got %d blocks\n",
                                        free, ex.fe_len);
+                        /*
+                         * The number of free blocks differs. This mostly
+                         * indicate that the bitmap is corrupt. So exit
+                         * without claiming the space.
+                         */
+                        break;
                }
                ext4_mb_measure_extent(ac, &ex, e4b);
@@ -3740,10 +3768,10 @@ static int ext4_mb_release_inode_pa(struct ext4_buddy *e4b,
        }
        while (bit < end) {
-                bit = ext4_find_next_zero_bit(bitmap_bh->b_data, end, bit);
+                bit = mb_find_next_zero_bit(bitmap_bh->b_data, end, bit);
                if (bit >= end)
                        break;
-                next = ext4_find_next_bit(bitmap_bh->b_data, end, bit);
+                next = mb_find_next_bit(bitmap_bh->b_data, end, bit);
                if (next > end)
                        next = end;
                start = group * EXT4_BLOCKS_PER_GROUP(sb) + bit +
@@ -3771,6 +3799,10 @@ static int ext4_mb_release_inode_pa(struct ext4_buddy *e4b,
                        (unsigned long) pa->pa_len);
                ext4_error(sb, __FUNCTION__, "free %u, pa_free %u\n",
                                                free, pa->pa_free);
+                /*
+                 * pa is already deleted so we use the value obtained
+                 * from the bitmap and continue.
+                 */
        }
        atomic_add(free, &sbi->s_mb_discarded);
        if (ac)
diff --git a/fs/ext4/migrate.c b/fs/ext4/migrate.c
index 8c6c685b9d22..5c1e27de7755 100644
--- a/fs/ext4/migrate.c
+++ b/fs/ext4/migrate.c
@@ -43,6 +43,7 @@ static int finish_range(handle_t *handle, struct inode *inode,
        if (IS_ERR(path)) {
                retval = PTR_ERR(path);
+                path = NULL;
                goto err_out;
        }
@@ -74,6 +75,10 @@ static int finish_range(handle_t *handle, struct inode *inode,
        }
        retval = ext4_ext_insert_extent(handle, inode, path, &newext);
 err_out:
+        if (path) {
+                ext4_ext_drop_refs(path);
+                kfree(path);
+        }
        lb->first_pblock = 0;
        return retval;
 }
diff --git a/fs/ext4/namei.c b/fs/ext4/namei.c
index a9347fb43bcc..28aa2ed4297e 100644
--- a/fs/ext4/namei.c
+++ b/fs/ext4/namei.c
@@ -1804,12 +1804,8 @@ retry:
        inode->i_fop = &ext4_dir_operations;
        inode->i_size = EXT4_I(inode)->i_disksize = inode->i_sb->s_blocksize;
        dir_block = ext4_bread (handle, inode, 0, 1, &err);
-        if (!dir_block) {
+        if (!dir_block)
-                ext4_dec_count(handle, inode); /* is this nlink == 0? */
+                goto out_clear_inode;
-                ext4_mark_inode_dirty(handle, inode);
-                iput (inode);
-                goto out_stop;
-        }
        BUFFER_TRACE(dir_block, "get_write_access");
        ext4_journal_get_write_access(handle, dir_block);
        de = (struct ext4_dir_entry_2 *) dir_block->b_data;
@@ -1832,7 +1828,8 @@ retry:
        ext4_mark_inode_dirty(handle, inode);
        err = ext4_add_entry (handle, dentry, inode);
        if (err) {
-                inode->i_nlink = 0;
+out_clear_inode:
+                clear_nlink(inode);
                ext4_mark_inode_dirty(handle, inode);
                iput (inode);
                goto out_stop;
@@ -2164,7 +2161,7 @@ static int ext4_unlink(struct inode * dir, struct dentry *dentry)
        dir->i_ctime = dir->i_mtime = ext4_current_time(dir);
        ext4_update_dx_flag(dir);
        ext4_mark_inode_dirty(handle, dir);
-        ext4_dec_count(handle, inode);
+        drop_nlink(inode);
        if (!inode->i_nlink)
                ext4_orphan_add(handle, inode);
        inode->i_ctime = ext4_current_time(inode);
@@ -2214,7 +2211,7 @@ retry:
                err = __page_symlink(inode, symname, l,
                                mapping_gfp_mask(inode->i_mapping) & ~__GFP_FS);
                if (err) {
-                        ext4_dec_count(handle, inode);
+                        clear_nlink(inode);
                        ext4_mark_inode_dirty(handle, inode);
                        iput (inode);
                        goto out_stop;
@@ -2223,7 +2220,6 @@ retry:
                inode->i_op = &ext4_fast_symlink_inode_operations;
                memcpy((char*)&EXT4_I(inode)->i_data,symname,l);
                inode->i_size = l-1;
-                EXT4_I(inode)->i_flags &= ~EXT4_EXTENTS_FL;
        }
        EXT4_I(inode)->i_disksize = inode->i_size;
        err = ext4_add_nondir(handle, dentry, inode);
@@ -2407,7 +2403,7 @@ static int ext4_rename (struct inode * old_dir, struct dentry *old_dentry,
                ext4_dec_count(handle, old_dir);
                if (new_inode) {
                        /* checked empty_dir above, can't have another parent,
-                         * ext3_dec_count() won't work for many-linked dirs */
+                         * ext4_dec_count() won't work for many-linked dirs */
                        new_inode->i_nlink = 0;
                } else {
                        ext4_inc_count(handle, new_dir);
diff --git a/fs/ext4/resize.c b/fs/ext4/resize.c
index 9477a2bd6ff2..e29efa0f9d62 100644
--- a/fs/ext4/resize.c
+++ b/fs/ext4/resize.c
@@ -1037,6 +1037,7 @@ int ext4_group_extend(struct super_block *sb, struct ext4_super_block *es,
                ext4_warning(sb, __FUNCTION__,
                             "multiple resizers run on filesystem!");
                unlock_super(sb);
+                ext4_journal_stop(handle);
                err = -EBUSY;
                goto exit_put;
        }
diff --git a/fs/ext4/xattr.c b/fs/ext4/xattr.c
index d7962139c010..e9054c1c7d93 100644
--- a/fs/ext4/xattr.c
+++ b/fs/ext4/xattr.c
@@ -1386,7 +1386,7 @@ ext4_xattr_cache_insert(struct buffer_head *bh)
        struct mb_cache_entry *ce;
        int error;
-        ce = mb_cache_entry_alloc(ext4_xattr_cache);
+        ce = mb_cache_entry_alloc(ext4_xattr_cache, GFP_NOFS);
        if (!ce) {
                ea_bdebug(bh, "out of memory");
                return;
diff --git a/fs/file_table.c b/fs/file_table.c
index 6d27befe2d48..986ff4ed0a7c 100644
--- a/fs/file_table.c
+++ b/fs/file_table.c
@@ -83,6 +83,12 @@ int proc_nr_files(ctl_table *table, int write, struct file *filp,
 /* Find an unused file structure and return a pointer to it.
 * Returns NULL, if there are no more free file structures or
 * we run out of memory.
+ *
+ * Be very careful using this.  You are responsible for
+ * getting write access to any mount that you might assign
+ * to this filp, if it is opened for write.  If this is not
+ * done, you will imbalance int the mount's writer count
+ * and a warning at __fput() time.
 */
 struct file *get_empty_filp(void)
 {
diff --git a/fs/fs-writeback.c b/fs/fs-writeback.c
index c0076077d338..06557679ca41 100644
--- a/fs/fs-writeback.c
+++ b/fs/fs-writeback.c
@@ -751,7 +751,7 @@ int generic_osync_inode(struct inode *inode, struct address_space *mapping, int
 EXPORT_SYMBOL(generic_osync_inode);
 /**
- * writeback_acquire: attempt to get exclusive writeback access to a device
+ * writeback_acquire - attempt to get exclusive writeback access to a device
 * @bdi: the device's backing_dev_info structure
 *
 * It is a waste of resources to have more than one pdflush thread blocked on
@@ -768,7 +768,7 @@ int writeback_acquire(struct backing_dev_info *bdi)
 }
 /**
- * writeback_in_progress: determine whether there is writeback in progress
+ * writeback_in_progress - determine whether there is writeback in progress
 * @bdi: the device's backing_dev_info structure.
 *
 * Determine whether there is writeback in progress against a backing device.
@@ -779,7 +779,7 @@ int writeback_in_progress(struct backing_dev_info *bdi)
 }
 /**
- * writeback_release: relinquish exclusive writeback access against a device.
+ * writeback_release - relinquish exclusive writeback access against a device.
 * @bdi: the device's backing_dev_info structure
 */
 void writeback_release(struct backing_dev_info *bdi)
diff --git a/fs/fuse/dir.c b/fs/fuse/dir.c
index 7fb514b6d852..c4807b3fc8a3 100644
--- a/fs/fuse/dir.c
+++ b/fs/fuse/dir.c
@@ -906,7 +906,7 @@ static int fuse_permission(struct inode *inode, int mask, struct nameidata *nd)
        }
        if (fc->flags & FUSE_DEFAULT_PERMISSIONS) {
-                int err = generic_permission(inode, mask, NULL);
+                err = generic_permission(inode, mask, NULL);
                /* If permission is denied, try to refresh file
                   attributes.  This is also needed, because the root
diff --git a/fs/hfs/brec.c b/fs/hfs/brec.c
index 878bf25dbc6a..92fb358ce824 100644
--- a/fs/hfs/brec.c
+++ b/fs/hfs/brec.c
@@ -229,7 +229,7 @@ skip:
 static struct hfs_bnode *hfs_bnode_split(struct hfs_find_data *fd)
 {
        struct hfs_btree *tree;
-        struct hfs_bnode *node, *new_node;
+        struct hfs_bnode *node, *new_node, *next_node;
        struct hfs_bnode_desc node_desc;
        int num_recs, new_rec_off, new_off, old_rec_off;
        int data_start, data_end, size;
@@ -248,6 +248,17 @@ static struct hfs_bnode *hfs_bnode_split(struct hfs_find_data *fd)
        new_node->type = node->type;
        new_node->height = node->height;
+        if (node->next)
+                next_node = hfs_bnode_find(tree, node->next);
+        else
+                next_node = NULL;
+        if (IS_ERR(next_node)) {
+                hfs_bnode_put(node);
+                hfs_bnode_put(new_node);
+                return next_node;
+        }
        size = tree->node_size / 2 - node->num_recs * 2 - 14;
        old_rec_off = tree->node_size - 4;
        num_recs = 1;
@@ -261,6 +272,8 @@ static struct hfs_bnode *hfs_bnode_split(struct hfs_find_data *fd)
                /* panic? */
                hfs_bnode_put(node);
                hfs_bnode_put(new_node);
+                if (next_node)
+                        hfs_bnode_put(next_node);
                return ERR_PTR(-ENOSPC);
        }
@@ -315,8 +328,7 @@ static struct hfs_bnode *hfs_bnode_split(struct hfs_find_data *fd)
        hfs_bnode_write(node, &node_desc, 0, sizeof(node_desc));
        /* update next bnode header */
-        if (new_node->next) {
+        if (next_node) {
-                struct hfs_bnode *next_node = hfs_bnode_find(tree, new_node->next);
                next_node->prev = new_node->this;
                hfs_bnode_read(next_node, &node_desc, 0, sizeof(node_desc));
                node_desc.prev = cpu_to_be32(next_node->prev);
diff --git a/fs/hfsplus/dir.c b/fs/hfsplus/dir.c
index 29683645fa0a..5f4023678251 100644
--- a/fs/hfsplus/dir.c
+++ b/fs/hfsplus/dir.c
@@ -340,16 +340,23 @@ static int hfsplus_unlink(struct inode *dir, struct dentry *dentry)
        if (inode->i_nlink > 0)
                drop_nlink(inode);
-        hfsplus_delete_inode(inode);
+        if (inode->i_ino == cnid)
-        if (inode->i_ino != cnid && !inode->i_nlink) {
+                clear_nlink(inode);
-                if (!atomic_read(&HFSPLUS_I(inode).opencnt)) {
+        if (!inode->i_nlink) {
-                        res = hfsplus_delete_cat(inode->i_ino, HFSPLUS_SB(sb).hidden_dir, NULL);
+                if (inode->i_ino != cnid) {
-                        if (!res)
+                        HFSPLUS_SB(sb).file_count--;
-                                hfsplus_delete_inode(inode);
+                        if (!atomic_read(&HFSPLUS_I(inode).opencnt)) {
+                                res = hfsplus_delete_cat(inode->i_ino,
+                                                         HFSPLUS_SB(sb).hidden_dir,
+                                                         NULL);
+                                if (!res)
+                                        hfsplus_delete_inode(inode);
+                        } else
+                                inode->i_flags |= S_DEAD;
                } else
-                        inode->i_flags |= S_DEAD;
+                        hfsplus_delete_inode(inode);
        } else
-                clear_nlink(inode);
+                HFSPLUS_SB(sb).file_count--;
        inode->i_ctime = CURRENT_TIME_SEC;
        mark_inode_dirty(inode);
diff --git a/fs/hppfs/hppfs_kern.c b/fs/hppfs/hppfs_kern.c
index a1e1f0f61aa5..8601d8ef3b55 100644
--- a/fs/hppfs/hppfs_kern.c
+++ b/fs/hppfs/hppfs_kern.c
@@ -1,23 +1,24 @@
 /*
- * Copyright (C) 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
 * Licensed under the GPL
 */
-#include <linux/fs.h>
+#include <linux/ctype.h>
+#include <linux/dcache.h>
 #include <linux/file.h>
-#include <linux/module.h>
+#include <linux/fs.h>
 #include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/list.h>
 #include <linux/kernel.h>
-#include <linux/ctype.h>
+#include <linux/list.h>
-#include <linux/dcache.h>
+#include <linux/module.h>
+#include <linux/mount.h>
+#include <linux/slab.h>
 #include <linux/statfs.h>
+#include <linux/types.h>
 #include <asm/uaccess.h>
-#include <asm/fcntl.h>
 #include "os.h"
-static int init_inode(struct inode *inode, struct dentry *dentry);
+static struct inode *get_inode(struct super_block *, struct dentry *);
 struct hppfs_data {
        struct list_head list;
@@ -51,14 +52,14 @@ 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 ((sb->s_op != &hppfs_sbops) || (dentry->d_parent != sb->s_root))
-                return(0);
+                return 0;
-        for(i = 0; i < dentry->d_name.len; i++){
+        for (i = 0; i < dentry->d_name.len; i++) {
-                if(!isdigit(dentry->d_name.name[i]))
+                if (!isdigit(dentry->d_name.name[i]))
-                        return(0);
+                        return 0;
        }
-        return(1);
+        return 1;
 }
 static char *dentry_name(struct dentry *dentry, int extra)
@@ -70,8 +71,8 @@ static char *dentry_name(struct dentry *dentry, int extra)
        len = 0;
        parent = dentry;
-        while(parent->d_parent != parent){
+        while (parent->d_parent != parent) {
-                if(is_pid(parent))
+                if (is_pid(parent))
                        len += strlen("pid") + 1;
                else len += parent->d_name.len + 1;
                parent = parent->d_parent;
@@ -80,12 +81,13 @@ static char *dentry_name(struct dentry *dentry, int extra)
        root = "proc";
        len += strlen(root);
        name = kmalloc(len + extra + 1, GFP_KERNEL);
-        if(name == NULL) return(NULL);
+        if (name == NULL)
+                return NULL;
        name[len] = '\0';
        parent = dentry;
-        while(parent->d_parent != parent){
+        while (parent->d_parent != parent) {
-                if(is_pid(parent)){
+                if (is_pid(parent)) {
                        seg_name = "pid";
                        seg_len = strlen("pid");
                }
@@ -100,27 +102,25 @@ static char *dentry_name(struct dentry *dentry, int extra)
                parent = parent->d_parent;
        }
        strncpy(name, root, strlen(root));
-        return(name);
+        return name;
 }
-struct dentry_operations hppfs_dentry_ops = {
-};
 static int file_removed(struct dentry *dentry, const char *file)
 {
        char *host_file;
        int extra, fd;
        extra = 0;
-        if(file != NULL) extra += strlen(file) + 1;
+        if (file != NULL)
+                extra += strlen(file) + 1;
        host_file = dentry_name(dentry, extra + strlen("/remove"));
-        if(host_file == NULL){
+        if (host_file == NULL) {
-                printk("file_removed : allocation failed\n");
+                printk(KERN_ERR "file_removed : allocation failed\n");
-                return(-ENOMEM);
+                return -ENOMEM;
        }
-        if(file != NULL){
+        if (file != NULL) {
                strcat(host_file, "/");
                strcat(host_file, file);
        }
@@ -128,45 +128,11 @@ static int file_removed(struct dentry *dentry, const char *file)
        fd = os_open_file(host_file, of_read(OPENFLAGS()), 0);
        kfree(host_file);
-        if(fd > 0){
+        if (fd > 0) {
                os_close_file(fd);
-                return(1);
+                return 1;
-        }
-        return(0);
-}
-static void hppfs_read_inode(struct inode *ino)
-{
-        struct inode *proc_ino;
-        if(HPPFS_I(ino)->proc_dentry == NULL)
-                return;
-        proc_ino = HPPFS_I(ino)->proc_dentry->d_inode;
-        ino->i_uid = proc_ino->i_uid;
-        ino->i_gid = proc_ino->i_gid;
-        ino->i_atime = proc_ino->i_atime;
-        ino->i_mtime = proc_ino->i_mtime;
-        ino->i_ctime = proc_ino->i_ctime;
-        ino->i_ino = proc_ino->i_ino;
-        ino->i_mode = proc_ino->i_mode;
-        ino->i_nlink = proc_ino->i_nlink;
-        ino->i_size = proc_ino->i_size;
-        ino->i_blocks = proc_ino->i_blocks;
-}
-static struct inode *hppfs_iget(struct super_block *sb)
-{
-        struct inode *inode;
-        inode = iget_locked(sb, 0);
-        if (!inode)
-                return ERR_PTR(-ENOMEM);
-        if (inode->i_state & I_NEW) {
-                hppfs_read_inode(inode);
-                unlock_new_inode(inode);
        }
-        return inode;
+        return 0;
 }
 static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
@@ -177,55 +143,45 @@ static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
        int err, deleted;
        deleted = file_removed(dentry, NULL);
-        if(deleted < 0)
+        if (deleted < 0)
-                return(ERR_PTR(deleted));
+                return ERR_PTR(deleted);
-        else if(deleted)
+        else if (deleted)
-                return(ERR_PTR(-ENOENT));
+                return ERR_PTR(-ENOENT);
        err = -ENOMEM;
        parent = HPPFS_I(ino)->proc_dentry;
        mutex_lock(&parent->d_inode->i_mutex);
        proc_dentry = d_lookup(parent, &dentry->d_name);
-        if(proc_dentry == NULL){
+        if (proc_dentry == NULL) {
                proc_dentry = d_alloc(parent, &dentry->d_name);
-                if(proc_dentry == NULL){
+                if (proc_dentry == NULL) {
                        mutex_unlock(&parent->d_inode->i_mutex);
                        goto out;
                }
                new = (*parent->d_inode->i_op->lookup)(parent->d_inode,
                                                       proc_dentry, NULL);
-                if(new){
+                if (new) {
                        dput(proc_dentry);
                        proc_dentry = new;
                }
        }
        mutex_unlock(&parent->d_inode->i_mutex);
-        if(IS_ERR(proc_dentry))
+        if (IS_ERR(proc_dentry))
-                return(proc_dentry);
+                return proc_dentry;
-        inode = hppfs_iget(ino->i_sb);
+        err = -ENOMEM;
-        if (IS_ERR(inode)) {
+        inode = get_inode(ino->i_sb, proc_dentry);
-                err = PTR_ERR(inode);
+        if (!inode)
                goto out_dput;
-        }
-        err = init_inode(inode, proc_dentry);
-        if(err)
-                goto out_put;
-        hppfs_read_inode(inode);
        d_add(dentry, inode);
-        dentry->d_op = &hppfs_dentry_ops;
+        return NULL;
-        return(NULL);
- out_put:
-        iput(inode);
 out_dput:
        dput(proc_dentry);
 out:
-        return(ERR_PTR(err));
+        return ERR_PTR(err);
 }
 static const struct inode_operations hppfs_file_iops = {
@@ -239,15 +195,16 @@ static ssize_t read_proc(struct file *file, char __user *buf, ssize_t count,
        read = file->f_path.dentry->d_inode->i_fop->read;
-        if(!is_user)
+        if (!is_user)
                set_fs(KERNEL_DS);
        n = (*read)(file, buf, count, &file->f_pos);
-        if(!is_user)
+        if (!is_user)
                set_fs(USER_DS);
-        if(ppos) *ppos = file->f_pos;
+        if (ppos)
+                *ppos = file->f_pos;
        return n;
 }
@@ -259,24 +216,23 @@ static ssize_t hppfs_read_file(int fd, char __user *buf, ssize_t count)
        n = -ENOMEM;
        new_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if(new_buf == NULL){
+        if (new_buf == NULL) {
-                printk("hppfs_read_file : kmalloc failed\n");
+                printk(KERN_ERR "hppfs_read_file : kmalloc failed\n");
                goto out;
        }
        n = 0;
-        while(count > 0){
+        while (count > 0) {
                cur = min_t(ssize_t, count, PAGE_SIZE);
                err = os_read_file(fd, new_buf, cur);
-                if(err < 0){
+                if (err < 0) {
-                        printk("hppfs_read : read failed, errno = %d\n",
+                        printk(KERN_ERR "hppfs_read : read failed, "
-                               err);
+                               "errno = %d\n", err);
                        n = err;
                        goto out_free;
-                }
+                } else if (err == 0)
-                else if(err == 0)
                        break;
-                if(copy_to_user(buf, new_buf, err)){
+                if (copy_to_user(buf, new_buf, err)) {
                        n = -EFAULT;
                        goto out_free;
                }
@@ -297,35 +253,36 @@ static ssize_t hppfs_read(struct file *file, char __user *buf, size_t count,
        loff_t off;
        int err;
-        if(hppfs->contents != NULL){
+        if (hppfs->contents != NULL) {
-                if(*ppos >= hppfs->len) return(0);
+                if (*ppos >= hppfs->len)
+                        return 0;
                data = hppfs->contents;
                off = *ppos;
-                while(off >= sizeof(data->contents)){
+                while (off >= sizeof(data->contents)) {
                        data = list_entry(data->list.next, struct hppfs_data,
                                          list);
                        off -= sizeof(data->contents);
                }
-                if(off + count > hppfs->len)
+                if (off + count > hppfs->len)
                        count = hppfs->len - off;
                copy_to_user(buf, &data->contents[off], count);
                *ppos += count;
-        }
+        } else if (hppfs->host_fd != -1) {
-        else if(hppfs->host_fd != -1){
                err = os_seek_file(hppfs->host_fd, *ppos);
-                if(err){
+                if (err) {
-                        printk("hppfs_read : seek failed, errno = %d\n", err);
+                        printk(KERN_ERR "hppfs_read : seek failed, "
-                        return(err);
+                               "errno = %d\n", err);
+                        return err;
                }
                count = hppfs_read_file(hppfs->host_fd, buf, count);
-                if(count > 0)
+                if (count > 0)
                        *ppos += count;
        }
        else count = read_proc(hppfs->proc_file, buf, count, ppos, 1);
-        return(count);
+        return count;
 }
 static ssize_t hppfs_write(struct file *file, const char __user *buf, size_t len,
@@ -342,7 +299,7 @@ static ssize_t hppfs_write(struct file *file, const char __user *buf, size_t len
        err = (*write)(proc_file, buf, len, &proc_file->f_pos);
        file->f_pos = proc_file->f_pos;
-        return(err);
+        return err;
 }
 static int open_host_sock(char *host_file, int *filter_out)
@@ -354,13 +311,13 @@ static int open_host_sock(char *host_file, int *filter_out)
        strcpy(end, "/rw");
        *filter_out = 1;
        fd = os_connect_socket(host_file);
-        if(fd > 0)
+        if (fd > 0)
-                return(fd);
+                return fd;
        strcpy(end, "/r");
        *filter_out = 0;
        fd = os_connect_socket(host_file);
-        return(fd);
+        return fd;
 }
 static void free_contents(struct hppfs_data *head)
@@ -368,9 +325,10 @@ static void free_contents(struct hppfs_data *head)
        struct hppfs_data *data;
        struct list_head *ele, *next;
-        if(head == NULL) return;
+        if (head == NULL)
+                return;
-        list_for_each_safe(ele, next, &head->list){
+        list_for_each_safe(ele, next, &head->list) {
                data = list_entry(ele, struct hppfs_data, list);
                kfree(data);
        }
@@ -387,8 +345,8 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
        err = -ENOMEM;
        data = kmalloc(sizeof(*data), GFP_KERNEL);
-        if(data == NULL){
+        if (data == NULL) {
-                printk("hppfs_get_data : head allocation failed\n");
+                printk(KERN_ERR "hppfs_get_data : head allocation failed\n");
                goto failed;
        }
@@ -397,36 +355,36 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
        head = data;
        *size_out = 0;
-        if(filter){
+        if (filter) {
-                while((n = read_proc(proc_file, data->contents,
+                while ((n = read_proc(proc_file, data->contents,
                                     sizeof(data->contents), NULL, 0)) > 0)
                        os_write_file(fd, data->contents, n);
                err = os_shutdown_socket(fd, 0, 1);
-                if(err){
+                if (err) {
-                        printk("hppfs_get_data : failed to shut down "
+                        printk(KERN_ERR "hppfs_get_data : failed to shut down "
                               "socket\n");
                        goto failed_free;
                }
        }
-        while(1){
+        while (1) {
                n = os_read_file(fd, data->contents, sizeof(data->contents));
-                if(n < 0){
+                if (n < 0) {
                        err = n;
-                        printk("hppfs_get_data : read failed, errno = %d\n",
+                        printk(KERN_ERR "hppfs_get_data : read failed, "
-                               err);
+                               "errno = %d\n", err);
                        goto failed_free;
-                }
+                } else if (n == 0)
-                else if(n == 0)
                        break;
                *size_out += n;
-                if(n < sizeof(data->contents))
+                if (n < sizeof(data->contents))
                        break;
                new = kmalloc(sizeof(*data), GFP_KERNEL);
-                if(new == 0){
+                if (new == 0) {
-                        printk("hppfs_get_data : data allocation failed\n");
+                        printk(KERN_ERR "hppfs_get_data : data allocation "
+                               "failed\n");
                        err = -ENOMEM;
                        goto failed_free;
                }
@@ -435,12 +393,12 @@ static struct hppfs_data *hppfs_get_data(int fd, int filter,
                list_add(&new->list, &data->list);
                data = new;
        }
-        return(head);
+        return head;
 failed_free:
        free_contents(head);
 failed:
-        return(ERR_PTR(err));
+        return ERR_PTR(err);
 }
 static struct hppfs_private *hppfs_data(void)
@@ -448,77 +406,79 @@ static struct hppfs_private *hppfs_data(void)
        struct hppfs_private *data;
        data = kmalloc(sizeof(*data), GFP_KERNEL);
-        if(data == NULL)
+        if (data == NULL)
-                return(data);
+                return data;
        *data = ((struct hppfs_private ) { .host_fd             = -1,
                                           .len                 = -1,
                                           .contents            = NULL } );
-        return(data);
+        return data;
 }
 static int file_mode(int fmode)
 {
-        if(fmode == (FMODE_READ | FMODE_WRITE))
+        if (fmode == (FMODE_READ | FMODE_WRITE))
-                return(O_RDWR);
+                return O_RDWR;
-        if(fmode == FMODE_READ)
+        if (fmode == FMODE_READ)
-                return(O_RDONLY);
+                return O_RDONLY;
-        if(fmode == FMODE_WRITE)
+        if (fmode == FMODE_WRITE)
-                return(O_WRONLY);
+                return O_WRONLY;
-        return(0);
+        return 0;
 }
 static int hppfs_open(struct inode *inode, struct file *file)
 {
        struct hppfs_private *data;
        struct dentry *proc_dentry;
+        struct vfsmount *proc_mnt;
        char *host_file;
        int err, fd, type, filter;
        err = -ENOMEM;
        data = hppfs_data();
-        if(data == NULL)
+        if (data == NULL)
                goto out;
        host_file = dentry_name(file->f_path.dentry, strlen("/rw"));
-        if(host_file == NULL)
+        if (host_file == NULL)
                goto out_free2;
        proc_dentry = HPPFS_I(inode)->proc_dentry;
+        proc_mnt = inode->i_sb->s_fs_info;
        /* XXX This isn't closed anywhere */
-        data->proc_file = dentry_open(dget(proc_dentry), NULL,
+        data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
                                      file_mode(file->f_mode));
        err = PTR_ERR(data->proc_file);
-        if(IS_ERR(data->proc_file))
+        if (IS_ERR(data->proc_file))
                goto out_free1;
        type = os_file_type(host_file);
-        if(type == OS_TYPE_FILE){
+        if (type == OS_TYPE_FILE) {
                fd = os_open_file(host_file, of_read(OPENFLAGS()), 0);
-                if(fd >= 0)
+                if (fd >= 0)
                        data->host_fd = fd;
-                else printk("hppfs_open : failed to open '%s', errno = %d\n",
+                else
-                            host_file, -fd);
+                        printk(KERN_ERR "hppfs_open : failed to open '%s', "
+                               "errno = %d\n", host_file, -fd);
                data->contents = NULL;
-        }
+        } else if (type == OS_TYPE_DIR) {
-        else if(type == OS_TYPE_DIR){
                fd = open_host_sock(host_file, &filter);
-                if(fd > 0){
+                if (fd > 0) {
                        data->contents = hppfs_get_data(fd, filter,
                                                        data->proc_file,
                                                        file, &data->len);
-                        if(!IS_ERR(data->contents))
+                        if (!IS_ERR(data->contents))
                                data->host_fd = fd;
-                }
+                } else
-                else printk("hppfs_open : failed to open a socket in "
+                        printk(KERN_ERR "hppfs_open : failed to open a socket "
-                            "'%s', errno = %d\n", host_file, -fd);
+                               "in '%s', errno = %d\n", host_file, -fd);
        }
        kfree(host_file);
        file->private_data = data;
-        return(0);
+        return 0;
 out_free1:
        kfree(host_file);
@@ -526,34 +486,36 @@ static int hppfs_open(struct inode *inode, struct file *file)
        free_contents(data->contents);
        kfree(data);
 out:
-        return(err);
+        return err;
 }
 static int hppfs_dir_open(struct inode *inode, struct file *file)
 {
        struct hppfs_private *data;
        struct dentry *proc_dentry;
+        struct vfsmount *proc_mnt;
        int err;
        err = -ENOMEM;
        data = hppfs_data();
-        if(data == NULL)
+        if (data == NULL)
                goto out;
        proc_dentry = HPPFS_I(inode)->proc_dentry;
-        data->proc_file = dentry_open(dget(proc_dentry), NULL,
+        proc_mnt = inode->i_sb->s_fs_info;
+        data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
                                      file_mode(file->f_mode));
        err = PTR_ERR(data->proc_file);
-        if(IS_ERR(data->proc_file))
+        if (IS_ERR(data->proc_file))
                goto out_free;
        file->private_data = data;
-        return(0);
+        return 0;
 out_free:
        kfree(data);
 out:
-        return(err);
+        return err;
 }
 static loff_t hppfs_llseek(struct file *file, loff_t off, int where)
@@ -564,13 +526,13 @@ static loff_t hppfs_llseek(struct file *file, loff_t off, int where)
        loff_t ret;
        llseek = proc_file->f_path.dentry->d_inode->i_fop->llseek;
-        if(llseek != NULL){
+        if (llseek != NULL) {
                ret = (*llseek)(proc_file, off, where);
-                if(ret < 0)
+                if (ret < 0)
-                        return(ret);
+                        return ret;
        }
-        return(default_llseek(file, off, where));
+        return default_llseek(file, off, where);
 }
 static const struct file_operations hppfs_file_fops = {
@@ -592,11 +554,11 @@ static int hppfs_filldir(void *d, const char *name, int size,
 {
        struct hppfs_dirent *dirent = d;
-        if(file_removed(dirent->dentry, name))
+        if (file_removed(dirent->dentry, name))
-                return(0);
+                return 0;
-        return((*dirent->filldir)(dirent->vfs_dirent, name, size, offset,
+        return (*dirent->filldir)(dirent->vfs_dirent, name, size, offset,
-                                  inode, type));
+                                  inode, type);
 }
 static int hppfs_readdir(struct file *file, void *ent, filldir_t filldir)
@@ -607,7 +569,8 @@ static int hppfs_readdir(struct file *file, void *ent, filldir_t filldir)
        struct hppfs_dirent dirent = ((struct hppfs_dirent)
                                      { .vfs_dirent     = ent,
                                        .filldir        = filldir,
-                                        .dentry         = file->f_path.dentry } );
+                                        .dentry         = file->f_path.dentry
+                                      });
        int err;
        readdir = proc_file->f_path.dentry->d_inode->i_fop->readdir;
@@ -616,12 +579,12 @@ static int hppfs_readdir(struct file *file, void *ent, filldir_t filldir)
        err = (*readdir)(proc_file, &dirent, hppfs_filldir);
        file->f_pos = proc_file->f_pos;
-        return(err);
+        return err;
 }
 static int hppfs_fsync(struct file *file, struct dentry *dentry, int datasync)
 {
-        return(0);
+        return 0;
 }
 static const struct file_operations hppfs_dir_fops = {
@@ -639,7 +602,7 @@ static int hppfs_statfs(struct dentry *dentry, struct kstatfs *sf)
        sf->f_files = 0;
        sf->f_ffree = 0;
        sf->f_type = HPPFS_SUPER_MAGIC;
-        return(0);
+        return 0;
 }
 static struct inode *hppfs_alloc_inode(struct super_block *sb)
@@ -647,12 +610,12 @@ static struct inode *hppfs_alloc_inode(struct super_block *sb)
        struct hppfs_inode_info *hi;
        hi = kmalloc(sizeof(*hi), GFP_KERNEL);
-        if(hi == NULL)
+        if (!hi)
-                return(NULL);
+                return NULL;
-        *hi = ((struct hppfs_inode_info) { .proc_dentry = NULL });
+        hi->proc_dentry = NULL;
        inode_init_once(&hi->vfs_inode);
-        return(&hi->vfs_inode);
+        return &hi->vfs_inode;
 }
 void hppfs_delete_inode(struct inode *ino)
@@ -665,21 +628,31 @@ 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)
+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_file = dentry_open(dget(proc_dentry), NULL, O_RDONLY);
+        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 PTR_ERR(proc_file);
@@ -694,10 +667,13 @@ 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_file = dentry_open(dget(proc_dentry), NULL, O_RDONLY);
+        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;
@@ -717,70 +693,72 @@ static const struct inode_operations hppfs_link_iops = {
        .follow_link    = hppfs_follow_link,
 };
-static int init_inode(struct inode *inode, struct dentry *dentry)
+static struct inode *get_inode(struct super_block *sb, struct dentry *dentry)
 {
-        if(S_ISDIR(dentry->d_inode->i_mode)){
+        struct inode *proc_ino = dentry->d_inode;
+        struct inode *inode = new_inode(sb);
+        if (!inode)
+                return ERR_PTR(-ENOMEM);
+        if (S_ISDIR(dentry->d_inode->i_mode)) {
                inode->i_op = &hppfs_dir_iops;
                inode->i_fop = &hppfs_dir_fops;
-        }
+        } else if (S_ISLNK(dentry->d_inode->i_mode)) {
-        else if(S_ISLNK(dentry->d_inode->i_mode)){
                inode->i_op = &hppfs_link_iops;
                inode->i_fop = &hppfs_file_fops;
-        }
+        } else {
-        else {
                inode->i_op = &hppfs_file_iops;
                inode->i_fop = &hppfs_file_fops;
        }
        HPPFS_I(inode)->proc_dentry = dentry;
-        return(0);
+        inode->i_uid = proc_ino->i_uid;
+        inode->i_gid = proc_ino->i_gid;
+        inode->i_atime = proc_ino->i_atime;
+        inode->i_mtime = proc_ino->i_mtime;
+        inode->i_ctime = proc_ino->i_ctime;
+        inode->i_ino = proc_ino->i_ino;
+        inode->i_mode = proc_ino->i_mode;
+        inode->i_nlink = proc_ino->i_nlink;
+        inode->i_size = proc_ino->i_size;
+        inode->i_blocks = proc_ino->i_blocks;
+        return 0;
 }
 static int hppfs_fill_super(struct super_block *sb, void *d, int silent)
 {
        struct inode *root_inode;
-        struct file_system_type *procfs;
+        struct vfsmount *proc_mnt;
-        struct super_block *proc_sb;
+        int err = -ENOENT;
-        int err;
-        err = -ENOENT;
+        proc_mnt = do_kern_mount("proc", 0, "proc", NULL);
-        procfs = get_fs_type("proc");
+        if (IS_ERR(proc_mnt))
-        if(procfs == NULL)
                goto out;
-        if(list_empty(&procfs->fs_supers))
-                goto out;
-        proc_sb = list_entry(procfs->fs_supers.next, struct super_block,
-                             s_instances);
        sb->s_blocksize = 1024;
        sb->s_blocksize_bits = 10;
        sb->s_magic = HPPFS_SUPER_MAGIC;
        sb->s_op = &hppfs_sbops;
+        sb->s_fs_info = proc_mnt;
-        root_inode = hppfs_iget(sb);
-        if (IS_ERR(root_inode)) {
-                err = PTR_ERR(root_inode);
-                goto out;
-        }
-        err = init_inode(root_inode, proc_sb->s_root);
-        if(err)
-                goto out_put;
        err = -ENOMEM;
-        sb->s_root = d_alloc_root(root_inode);
+        root_inode = get_inode(sb, proc_mnt->mnt_sb->s_root);
-        if(sb->s_root == NULL)
+        if (!root_inode)
-                goto out_put;
+                goto out_mntput;
-        hppfs_read_inode(root_inode);
+        sb->s_root = d_alloc_root(root_inode);
+        if (!sb->s_root)
+                goto out_iput;
-        return(0);
+        return 0;
- out_put:
+ out_iput:
        iput(root_inode);
+ out_mntput:
+        mntput(proc_mnt);
 out:
        return(err);
 }
@@ -802,7 +780,7 @@ static struct file_system_type hppfs_type = {
 static int __init init_hppfs(void)
 {
-        return(register_filesystem(&hppfs_type));
+        return register_filesystem(&hppfs_type);
 }
 static void __exit exit_hppfs(void)
@@ -813,14 +791,3 @@ static void __exit exit_hppfs(void)
 module_init(init_hppfs)
 module_exit(exit_hppfs)
 MODULE_LICENSE("GPL");
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index eee9487ae47f..6846785fe904 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -954,7 +954,7 @@ struct file *hugetlb_file_setup(const char *name, size_t size)
                        FMODE_WRITE | FMODE_READ,
                        &hugetlbfs_file_operations);
        if (!file)
-                goto out_inode;
+                goto out_dentry; /* inode is already attached */
        return file;
diff --git a/fs/isofs/compress.c b/fs/isofs/compress.c
index 37dbd6404787..defb932eee9a 100644
--- a/fs/isofs/compress.c
+++ b/fs/isofs/compress.c
@@ -72,6 +72,17 @@ static int zisofs_readpage(struct file *file, struct page *page)
        offset = index & ~zisofs_block_page_mask;
        blockindex = offset >> zisofs_block_page_shift;
        maxpage = (inode->i_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+        /*
+         * If this page is wholly outside i_size we just return zero;
+         * do_generic_file_read() will handle this for us
+         */
+        if (page->index >= maxpage) {
+                SetPageUptodate(page);
+                unlock_page(page);
+                return 0;
+        }
        maxpage = min(zisofs_block_pages, maxpage-offset);
        for ( i = 0 ; i < maxpage ; i++, offset++ ) {
diff --git a/fs/jbd/journal.c b/fs/jbd/journal.c
index 3943a8905eb2..0e081d5f32e8 100644
--- a/fs/jbd/journal.c
+++ b/fs/jbd/journal.c
@@ -697,13 +697,14 @@ fail:
 */
 /**
- *  journal_t * journal_init_dev() - creates an initialises a journal structure
+ *  journal_t * journal_init_dev() - creates and initialises a journal structure
 *  @bdev: Block device on which to create the journal
 *  @fs_dev: Device which hold journalled filesystem for this journal.
 *  @start: Block nr Start of journal.
 *  @len:  Length of the journal in blocks.
 *  @blocksize: blocksize of journalling device
- *  @returns: a newly created journal_t *
+ *
+ *  Returns: a newly created journal_t *
 *
 *  journal_init_dev creates a journal which maps a fixed contiguous
 *  range of blocks on an arbitrary block device.
@@ -1619,14 +1620,14 @@ static int journal_init_journal_head_cache(void)
 {
        int retval;
-        J_ASSERT(journal_head_cache == 0);
+        J_ASSERT(journal_head_cache == NULL);
        journal_head_cache = kmem_cache_create("journal_head",
                                sizeof(struct journal_head),
                                0,              /* offset */
                                SLAB_TEMPORARY, /* flags */
                                NULL);          /* ctor */
        retval = 0;
-        if (journal_head_cache == 0) {
+        if (!journal_head_cache) {
                retval = -ENOMEM;
                printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
        }
diff --git a/fs/jbd/recovery.c b/fs/jbd/recovery.c
index 2b8edf4d6eaa..43bc5e5ed064 100644
--- a/fs/jbd/recovery.c
+++ b/fs/jbd/recovery.c
@@ -478,7 +478,7 @@ static int do_one_pass(journal_t *journal,
                                        memcpy(nbh->b_data, obh->b_data,
                                                        journal->j_blocksize);
                                        if (flags & JFS_FLAG_ESCAPE) {
-                                                *((__be32 *)bh->b_data) =
+                                                *((__be32 *)nbh->b_data) =
                                                cpu_to_be32(JFS_MAGIC_NUMBER);
                                        }
diff --git a/fs/jbd/revoke.c b/fs/jbd/revoke.c
index ad2eacf570c6..d5f8eee7c88c 100644
--- a/fs/jbd/revoke.c
+++ b/fs/jbd/revoke.c
@@ -173,13 +173,13 @@ int __init journal_init_revoke_caches(void)
                                           0,
                                           SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
                                           NULL);
-        if (revoke_record_cache == 0)
+        if (!revoke_record_cache)
                return -ENOMEM;
        revoke_table_cache = kmem_cache_create("revoke_table",
                                           sizeof(struct jbd_revoke_table_s),
                                           0, SLAB_TEMPORARY, NULL);
-        if (revoke_table_cache == 0) {
+        if (!revoke_table_cache) {
                kmem_cache_destroy(revoke_record_cache);
                revoke_record_cache = NULL;
                return -ENOMEM;
diff --git a/fs/jbd/transaction.c b/fs/jbd/transaction.c
index 038ed7436199..2c9e8f5d13aa 100644
--- a/fs/jbd/transaction.c
+++ b/fs/jbd/transaction.c
@@ -369,7 +369,7 @@ out:
 /**
- * int journal_restart() - restart a handle .
+ * int journal_restart() - restart a handle.
 * @handle:  handle to restart
 * @nblocks: nr credits requested
 *
@@ -844,8 +844,7 @@ out:
 }
 /**
- * int journal_get_undo_access() -  Notify intent to modify metadata with
+ * int journal_get_undo_access() - Notify intent to modify metadata with non-rewindable consequences
- *     non-rewindable consequences
 * @handle: transaction
 * @bh: buffer to undo
 * @credits: store the number of taken credits here (if not NULL)
@@ -921,12 +920,14 @@ out:
 }
 /**
- * int journal_dirty_data() -  mark a buffer as containing dirty data which
+ * int journal_dirty_data() - mark a buffer as containing dirty data to be flushed
- *                             needs to be flushed before we can commit the
- *                             current transaction.
 * @handle: transaction
 * @bh: bufferhead to mark
 *
+ * Description:
+ * Mark a buffer as containing dirty data which needs to be flushed before
+ * we can commit the current transaction.
+ *
 * The buffer is placed on the transaction's data list and is marked as
 * belonging to the transaction.
 *
@@ -1098,11 +1099,11 @@ no_journal:
 }
 /**
- * int journal_dirty_metadata() -  mark a buffer as containing dirty metadata
+ * int journal_dirty_metadata() - mark a buffer as containing dirty metadata
 * @handle: transaction to add buffer to.
 * @bh: buffer to mark
 *
- * mark dirty metadata which needs to be journaled as part of the current
+ * Mark dirty metadata which needs to be journaled as part of the current
 * transaction.
 *
 * The buffer is placed on the transaction's metadata list and is marked
@@ -1425,7 +1426,8 @@ int journal_stop(handle_t *handle)
        return err;
 }
-/**int journal_force_commit() - force any uncommitted transactions
+/**
+ * int journal_force_commit() - force any uncommitted transactions
 * @journal: journal to force
 *
 * For synchronous operations: force any uncommitted transactions
@@ -1902,13 +1904,12 @@ zap_buffer_unlocked:
 }
 /**
- * void journal_invalidatepage()
+ * void journal_invalidatepage() - invalidate a journal page
- * @journal: journal to use for flush...
+ * @journal: journal to use for flush
 * @page:    page to flush
 * @offset:  length of page to invalidate.
 *
 * Reap page buffers containing data after offset in page.
- *
 */
 void journal_invalidatepage(journal_t *journal,
                      struct page *page,
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 96ba846992e9..954cff001df6 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -219,7 +219,7 @@ static int jbd2_journal_start_thread(journal_t *journal)
        if (IS_ERR(t))
                return PTR_ERR(t);
-        wait_event(journal->j_wait_done_commit, journal->j_task != 0);
+        wait_event(journal->j_wait_done_commit, journal->j_task != NULL);
        return 0;
 }
@@ -231,7 +231,7 @@ static void journal_kill_thread(journal_t *journal)
        while (journal->j_task) {
                wake_up(&journal->j_wait_commit);
                spin_unlock(&journal->j_state_lock);
-                wait_event(journal->j_wait_done_commit, journal->j_task == 0);
+                wait_event(journal->j_wait_done_commit, journal->j_task == NULL);
                spin_lock(&journal->j_state_lock);
        }
        spin_unlock(&journal->j_state_lock);
@@ -1969,14 +1969,14 @@ static int journal_init_jbd2_journal_head_cache(void)
 {
        int retval;
-        J_ASSERT(jbd2_journal_head_cache == 0);
+        J_ASSERT(jbd2_journal_head_cache == NULL);
        jbd2_journal_head_cache = kmem_cache_create("jbd2_journal_head",
                                sizeof(struct journal_head),
                                0,              /* offset */
                                SLAB_TEMPORARY, /* flags */
                                NULL);          /* ctor */
        retval = 0;
-        if (jbd2_journal_head_cache == 0) {
+        if (!jbd2_journal_head_cache) {
                retval = -ENOMEM;
                printk(KERN_EMERG "JBD: no memory for journal_head cache\n");
        }
@@ -2002,14 +2002,14 @@ static struct journal_head *journal_alloc_journal_head(void)
        atomic_inc(&nr_journal_heads);
 #endif
        ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
-        if (ret == 0) {
+        if (!ret) {
                jbd_debug(1, "out of memory for journal_head\n");
                if (time_after(jiffies, last_warning + 5*HZ)) {
                        printk(KERN_NOTICE "ENOMEM in %s, retrying.\n",
                               __FUNCTION__);
                        last_warning = jiffies;
                }
-                while (ret == 0) {
+                while (!ret) {
                        yield();
                        ret = kmem_cache_alloc(jbd2_journal_head_cache, GFP_NOFS);
                }
diff --git a/fs/jbd2/recovery.c b/fs/jbd2/recovery.c
index 146411387ada..5d0405a9e7ca 100644
--- a/fs/jbd2/recovery.c
+++ b/fs/jbd2/recovery.c
@@ -535,7 +535,7 @@ static int do_one_pass(journal_t *journal,
                                        memcpy(nbh->b_data, obh->b_data,
                                                        journal->j_blocksize);
                                        if (flags & JBD2_FLAG_ESCAPE) {
-                                                *((__be32 *)bh->b_data) =
+                                                *((__be32 *)nbh->b_data) =
                                                cpu_to_be32(JBD2_MAGIC_NUMBER);
                                        }
diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index df36f42e19e1..2e1453a5e998 100644
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -174,13 +174,13 @@ int __init jbd2_journal_init_revoke_caches(void)
                                           0,
                                           SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
                                           NULL);
-        if (jbd2_revoke_record_cache == 0)
+        if (!jbd2_revoke_record_cache)
                return -ENOMEM;
        jbd2_revoke_table_cache = kmem_cache_create("jbd2_revoke_table",
                                           sizeof(struct jbd2_revoke_table_s),
                                           0, SLAB_TEMPORARY, NULL);
-        if (jbd2_revoke_table_cache == 0) {
+        if (!jbd2_revoke_table_cache) {
                kmem_cache_destroy(jbd2_revoke_record_cache);
                jbd2_revoke_record_cache = NULL;
                return -ENOMEM;
diff --git a/fs/jffs2/file.c b/fs/jffs2/file.c
index f9c5dd6f4b64..dcc2734e0b5d 100644
--- a/fs/jffs2/file.c
+++ b/fs/jffs2/file.c
@@ -129,7 +129,7 @@ static int jffs2_write_begin(struct file *filp, struct address_space *mapping,
        struct inode *inode = mapping->host;
        struct jffs2_inode_info *f = JFFS2_INODE_INFO(inode);
        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
-        uint32_t pageofs = pos & (PAGE_CACHE_SIZE - 1);
+        uint32_t pageofs = index << PAGE_CACHE_SHIFT;
        int ret = 0;
        pg = __grab_cache_page(mapping, index);
diff --git a/fs/lockd/svc.c b/fs/lockd/svc.c
index 08226464e563..1ed8bd4de941 100644
--- a/fs/lockd/svc.c
+++ b/fs/lockd/svc.c
@@ -153,7 +153,7 @@ lockd(struct svc_rqst *rqstp)
         */
        while ((nlmsvc_users || !signalled()) && nlmsvc_pid == current->pid) {
                long timeout = MAX_SCHEDULE_TIMEOUT;
-                char buf[RPC_MAX_ADDRBUFLEN];
+                RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
                if (signalled()) {
                        flush_signals(current);
diff --git a/fs/locks.c b/fs/locks.c
index f36f0e61558d..43c0af21a0c5 100644
--- a/fs/locks.c
+++ b/fs/locks.c
@@ -1275,13 +1275,13 @@ out:
 EXPORT_SYMBOL(__break_lease);
 /**
- *      lease_get_mtime
+ *      lease_get_mtime - get the last modified time of an inode
 *      @inode: the inode
 *      @time:  pointer to a timespec which will contain the last modified time
 *
 * This is to force NFS clients to flush their caches for files with
 * exclusive leases.  The justification is that if someone has an
- * exclusive lease, then they could be modifiying it.
+ * exclusive lease, then they could be modifying it.
 */
 void lease_get_mtime(struct inode *inode, struct timespec *time)
 {
@@ -1801,17 +1801,21 @@ again:
        if (error)
                goto out;
-        for (;;) {
+        if (filp->f_op && filp->f_op->lock != NULL)
-                error = vfs_lock_file(filp, cmd, file_lock, NULL);
+                error = filp->f_op->lock(filp, cmd, file_lock);
-                if (error != -EAGAIN || cmd == F_SETLK)
+        else {
-                        break;
+                for (;;) {
-                error = wait_event_interruptible(file_lock->fl_wait,
+                        error = posix_lock_file(filp, file_lock, NULL);
-                                !file_lock->fl_next);
+                        if (error != -EAGAIN || cmd == F_SETLK)
-                if (!error)
+                                break;
-                        continue;
+                        error = wait_event_interruptible(file_lock->fl_wait,
+                                        !file_lock->fl_next);
+                        if (!error)
+                                continue;
-                locks_delete_block(file_lock);
+                        locks_delete_block(file_lock);
-                break;
+                        break;
+                }
        }
        /*
@@ -1925,17 +1929,21 @@ again:
        if (error)
                goto out;
-        for (;;) {
+        if (filp->f_op && filp->f_op->lock != NULL)
-                error = vfs_lock_file(filp, cmd, file_lock, NULL);
+                error = filp->f_op->lock(filp, cmd, file_lock);
-                if (error != -EAGAIN || cmd == F_SETLK64)
+        else {
-                        break;
+                for (;;) {
-                error = wait_event_interruptible(file_lock->fl_wait,
+                        error = posix_lock_file(filp, file_lock, NULL);
-                                !file_lock->fl_next);
+                        if (error != -EAGAIN || cmd == F_SETLK64)
-                if (!error)
+                                break;
-                        continue;
+                        error = wait_event_interruptible(file_lock->fl_wait,
+                                        !file_lock->fl_next);
+                        if (!error)
+                                continue;
-                locks_delete_block(file_lock);
+                        locks_delete_block(file_lock);
-                break;
+                        break;
+                }
        }
        /*
diff --git a/fs/mbcache.c b/fs/mbcache.c
index eb31b73e7d69..ec88ff3d04a9 100644
--- a/fs/mbcache.c
+++ b/fs/mbcache.c
@@ -399,11 +399,11 @@ mb_cache_destroy(struct mb_cache *cache)
 * if no more memory was available.
 */
 struct mb_cache_entry *
-mb_cache_entry_alloc(struct mb_cache *cache)
+mb_cache_entry_alloc(struct mb_cache *cache, gfp_t gfp_flags)
 {
        struct mb_cache_entry *ce;
-        ce = kmem_cache_alloc(cache->c_entry_cache, GFP_KERNEL);
+        ce = kmem_cache_alloc(cache->c_entry_cache, gfp_flags);
        if (ce) {
                atomic_inc(&cache->c_entry_count);
                INIT_LIST_HEAD(&ce->e_lru_list);
diff --git a/fs/mpage.c b/fs/mpage.c
index 5df564366f36..235e4d3873a8 100644
--- a/fs/mpage.c
+++ b/fs/mpage.c
@@ -325,16 +325,12 @@ confused:
 }
 /**
- * mpage_readpages - populate an address space with some pages, and
+ * mpage_readpages - populate an address space with some pages & start reads against them
- *                       start reads against them.
- *
 * @mapping: the address_space
 * @pages: The address of a list_head which contains the target pages.  These
 *   pages have their ->index populated and are otherwise uninitialised.
- *
 *   The page at @pages->prev has the lowest file offset, and reads should be
 *   issued in @pages->prev to @pages->next order.
- *
 * @nr_pages: The number of pages at *@pages
 * @get_block: The filesystem's block mapper function.
 *
@@ -360,6 +356,7 @@ confused:
 * So an mpage read of the first 16 blocks of an ext2 file will cause I/O to be
 * submitted in the following order:
 *      12 0 1 2 3 4 5 6 7 8 9 10 11 13 14 15 16
+ *
 * because the indirect block has to be read to get the mappings of blocks
 * 13,14,15,16.  Obviously, this impacts performance.
 *
@@ -656,9 +653,7 @@ out:
 }
 /**
- * mpage_writepages - walk the list of dirty pages of the given
+ * mpage_writepages - walk the list of dirty pages of the given address space & writepage() all of them
- * address space and writepage() all of them.
- * 
 * @mapping: address space structure to write
 * @wbc: subtract the number of written pages from *@wbc->nr_to_write
 * @get_block: the filesystem's block mapper function.
diff --git a/fs/namei.c b/fs/namei.c
index 941c8e8228c0..8cf9bb9c2fc0 100644
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -106,7 +106,7 @@
 * any extra contention...
 */
-static int link_path_walk(const char *name, struct nameidata *nd);
+static int __link_path_walk(const char *name, struct nameidata *nd);
 /* In order to reduce some races, while at the same time doing additional
 * checking and hopefully speeding things up, we copy filenames to the
@@ -563,6 +563,37 @@ walk_init_root(const char *name, struct nameidata *nd)
        return 1;
 }
+/*
+ * Wrapper to retry pathname resolution whenever the underlying
+ * file system returns an ESTALE.
+ *
+ * Retry the whole path once, forcing real lookup requests
+ * instead of relying on the dcache.
+ */
+static __always_inline int link_path_walk(const char *name, struct nameidata *nd)
+{
+        struct path save = nd->path;
+        int result;
+        /* make sure the stuff we saved doesn't go away */
+        dget(save.dentry);
+        mntget(save.mnt);
+        result = __link_path_walk(name, nd);
+        if (result == -ESTALE) {
+                /* nd->path had been dropped */
+                nd->path = save;
+                dget(nd->path.dentry);
+                mntget(nd->path.mnt);
+                nd->flags |= LOOKUP_REVAL;
+                result = __link_path_walk(name, nd);
+        }
+        path_put(&save);
+        return result;
+}
 static __always_inline int __vfs_follow_link(struct nameidata *nd, const char *link)
 {
        int res = 0;
@@ -1020,36 +1051,6 @@ return_err:
        return err;
 }
-/*
- * Wrapper to retry pathname resolution whenever the underlying
- * file system returns an ESTALE.
- *
- * Retry the whole path once, forcing real lookup requests
- * instead of relying on the dcache.
- */
-static int link_path_walk(const char *name, struct nameidata *nd)
-{
-        struct nameidata save = *nd;
-        int result;
-        /* make sure the stuff we saved doesn't go away */
-        dget(save.path.dentry);
-        mntget(save.path.mnt);
-        result = __link_path_walk(name, nd);
-        if (result == -ESTALE) {
-                *nd = save;
-                dget(nd->path.dentry);
-                mntget(nd->path.mnt);
-                nd->flags |= LOOKUP_REVAL;
-                result = __link_path_walk(name, nd);
-        }
-        path_put(&save.path);
-        return result;
-}
 static int path_walk(const char *name, struct nameidata *nd)
 {
        current->total_link_count = 0;
@@ -1364,13 +1365,13 @@ static int __lookup_one_len(const char *name, struct qstr *this,
 }
 /**
- * lookup_one_len:  filesystem helper to lookup single pathname component
+ * lookup_one_len - filesystem helper to lookup single pathname component
 * @name:       pathname component to lookup
 * @base:       base directory to lookup from
 * @len:        maximum length @len should be interpreted to
 *
- * Note that this routine is purely a helper for filesystem useage and should
+ * Note that this routine is purely a helper for filesystem usage and should
- * not be called by generic code.  Also note that by using this function to
+ * not be called by generic code.  Also note that by using this function the
 * nameidata argument is passed to the filesystem methods and a filesystem
 * using this helper needs to be prepared for that.
 */
diff --git a/fs/namespace.c b/fs/namespace.c
index 7953c96a2071..94f026ec990a 100644
--- a/fs/namespace.c
+++ b/fs/namespace.c
@@ -155,15 +155,15 @@ static void __touch_mnt_namespace(struct mnt_namespace *ns)
        }
 }
-static void detach_mnt(struct vfsmount *mnt, struct nameidata *old_nd)
+static void detach_mnt(struct vfsmount *mnt, struct path *old_path)
 {
-        old_nd->path.dentry = mnt->mnt_mountpoint;
+        old_path->dentry = mnt->mnt_mountpoint;
-        old_nd->path.mnt = mnt->mnt_parent;
+        old_path->mnt = mnt->mnt_parent;
        mnt->mnt_parent = mnt;
        mnt->mnt_mountpoint = mnt->mnt_root;
        list_del_init(&mnt->mnt_child);
        list_del_init(&mnt->mnt_hash);
-        old_nd->path.dentry->d_mounted--;
+        old_path->dentry->d_mounted--;
 }
 void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
@@ -174,12 +174,12 @@ void mnt_set_mountpoint(struct vfsmount *mnt, struct dentry *dentry,
        dentry->d_mounted++;
 }
-static void attach_mnt(struct vfsmount *mnt, struct nameidata *nd)
+static void attach_mnt(struct vfsmount *mnt, struct path *path)
 {
-        mnt_set_mountpoint(nd->path.mnt, nd->path.dentry, mnt);
+        mnt_set_mountpoint(path->mnt, path->dentry, mnt);
        list_add_tail(&mnt->mnt_hash, mount_hashtable +
-                        hash(nd->path.mnt, nd->path.dentry));
+                        hash(path->mnt, path->dentry));
-        list_add_tail(&mnt->mnt_child, &nd->path.mnt->mnt_mounts);
+        list_add_tail(&mnt->mnt_child, &path->mnt->mnt_mounts);
 }
 /*
@@ -262,10 +262,8 @@ static struct vfsmount *clone_mnt(struct vfsmount *old, struct dentry *root,
                /* stick the duplicate mount on the same expiry list
                 * as the original if that was on one */
                if (flag & CL_EXPIRE) {
-                        spin_lock(&vfsmount_lock);
                        if (!list_empty(&old->mnt_expire))
                                list_add(&mnt->mnt_expire, &old->mnt_expire);
-                        spin_unlock(&vfsmount_lock);
                }
        }
        return mnt;
@@ -548,6 +546,7 @@ void release_mounts(struct list_head *head)
                        m = mnt->mnt_parent;
                        mnt->mnt_mountpoint = mnt->mnt_root;
                        mnt->mnt_parent = mnt;
+                        m->mnt_ghosts--;
                        spin_unlock(&vfsmount_lock);
                        dput(dentry);
                        mntput(m);
@@ -572,12 +571,16 @@ void umount_tree(struct vfsmount *mnt, int propagate, struct list_head *kill)
                __touch_mnt_namespace(p->mnt_ns);
                p->mnt_ns = NULL;
                list_del_init(&p->mnt_child);
-                if (p->mnt_parent != p)
+                if (p->mnt_parent != p) {
+                        p->mnt_parent->mnt_ghosts++;
                        p->mnt_mountpoint->d_mounted--;
+                }
                change_mnt_propagation(p, MS_PRIVATE);
        }
 }
+static void shrink_submounts(struct vfsmount *mnt, struct list_head *umounts);
 static int do_umount(struct vfsmount *mnt, int flags)
 {
        struct super_block *sb = mnt->mnt_sb;
@@ -650,6 +653,9 @@ static int do_umount(struct vfsmount *mnt, int flags)
        spin_lock(&vfsmount_lock);
        event++;
+        if (!(flags & MNT_DETACH))
+                shrink_submounts(mnt, &umount_list);
        retval = -EBUSY;
        if (flags & MNT_DETACH || !propagate_mount_busy(mnt, 2)) {
                if (!list_empty(&mnt->mnt_list))
@@ -744,7 +750,7 @@ struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
                                        int flag)
 {
        struct vfsmount *res, *p, *q, *r, *s;
-        struct nameidata nd;
+        struct path path;
        if (!(flag & CL_COPY_ALL) && IS_MNT_UNBINDABLE(mnt))
                return NULL;
@@ -769,14 +775,14 @@ struct vfsmount *copy_tree(struct vfsmount *mnt, struct dentry *dentry,
                                q = q->mnt_parent;
                        }
                        p = s;
-                        nd.path.mnt = q;
+                        path.mnt = q;
-                        nd.path.dentry = p->mnt_mountpoint;
+                        path.dentry = p->mnt_mountpoint;
                        q = clone_mnt(p, p->mnt_root, flag);
                        if (!q)
                                goto Enomem;
                        spin_lock(&vfsmount_lock);
                        list_add_tail(&q->mnt_list, &res->mnt_list);
-                        attach_mnt(q, &nd);
+                        attach_mnt(q, &path);
                        spin_unlock(&vfsmount_lock);
                }
        }
@@ -876,11 +882,11 @@ void drop_collected_mounts(struct vfsmount *mnt)
 * in allocations.
 */
 static int attach_recursive_mnt(struct vfsmount *source_mnt,
-                        struct nameidata *nd, struct nameidata *parent_nd)
+                        struct path *path, struct path *parent_path)
 {
        LIST_HEAD(tree_list);
-        struct vfsmount *dest_mnt = nd->path.mnt;
+        struct vfsmount *dest_mnt = path->mnt;
-        struct dentry *dest_dentry = nd->path.dentry;
+        struct dentry *dest_dentry = path->dentry;
        struct vfsmount *child, *p;
        if (propagate_mnt(dest_mnt, dest_dentry, source_mnt, &tree_list))
@@ -892,9 +898,9 @@ static int attach_recursive_mnt(struct vfsmount *source_mnt,
        }
        spin_lock(&vfsmount_lock);
-        if (parent_nd) {
+        if (parent_path) {
-                detach_mnt(source_mnt, parent_nd);
+                detach_mnt(source_mnt, parent_path);
-                attach_mnt(source_mnt, nd);
+                attach_mnt(source_mnt, path);
                touch_mnt_namespace(current->nsproxy->mnt_ns);
        } else {
                mnt_set_mountpoint(dest_mnt, dest_dentry, source_mnt);
@@ -930,7 +936,7 @@ static int graft_tree(struct vfsmount *mnt, struct nameidata *nd)
        err = -ENOENT;
        if (IS_ROOT(nd->path.dentry) || !d_unhashed(nd->path.dentry))
-                err = attach_recursive_mnt(mnt, nd, NULL);
+                err = attach_recursive_mnt(mnt, &nd->path, NULL);
 out_unlock:
        mutex_unlock(&nd->path.dentry->d_inode->i_mutex);
        if (!err)
@@ -1059,7 +1065,8 @@ static inline int tree_contains_unbindable(struct vfsmount *mnt)
 */
 static noinline int do_move_mount(struct nameidata *nd, char *old_name)
 {
-        struct nameidata old_nd, parent_nd;
+        struct nameidata old_nd;
+        struct path parent_path;
        struct vfsmount *p;
        int err = 0;
        if (!capable(CAP_SYS_ADMIN))
@@ -1114,21 +1121,19 @@ static noinline int do_move_mount(struct nameidata *nd, char *old_name)
                if (p == old_nd.path.mnt)
                        goto out1;
-        err = attach_recursive_mnt(old_nd.path.mnt, nd, &parent_nd);
+        err = attach_recursive_mnt(old_nd.path.mnt, &nd->path, &parent_path);
        if (err)
                goto out1;
-        spin_lock(&vfsmount_lock);
        /* if the mount is moved, it should no longer be expire
         * automatically */
        list_del_init(&old_nd.path.mnt->mnt_expire);
-        spin_unlock(&vfsmount_lock);
 out1:
        mutex_unlock(&nd->path.dentry->d_inode->i_mutex);
 out:
        up_write(&namespace_sem);
        if (!err)
-                path_put(&parent_nd.path);
+                path_put(&parent_path);
        path_put(&old_nd.path);
        return err;
 }
@@ -1189,12 +1194,9 @@ int do_add_mount(struct vfsmount *newmnt, struct nameidata *nd,
        if ((err = graft_tree(newmnt, nd)))
                goto unlock;
-        if (fslist) {
+        if (fslist) /* add to the specified expiration list */
-                /* add to the specified expiration list */
-                spin_lock(&vfsmount_lock);
                list_add_tail(&newmnt->mnt_expire, fslist);
-                spin_unlock(&vfsmount_lock);
-        }
        up_write(&namespace_sem);
        return 0;
@@ -1206,75 +1208,6 @@ unlock:
 EXPORT_SYMBOL_GPL(do_add_mount);
-static void expire_mount(struct vfsmount *mnt, struct list_head *mounts,
-                                struct list_head *umounts)
-{
-        spin_lock(&vfsmount_lock);
-        /*
-         * Check if mount is still attached, if not, let whoever holds it deal
-         * with the sucker
-         */
-        if (mnt->mnt_parent == mnt) {
-                spin_unlock(&vfsmount_lock);
-                return;
-        }
-        /*
-         * Check that it is still dead: the count should now be 2 - as
-         * contributed by the vfsmount parent and the mntget above
-         */
-        if (!propagate_mount_busy(mnt, 2)) {
-                /* delete from the namespace */
-                touch_mnt_namespace(mnt->mnt_ns);
-                list_del_init(&mnt->mnt_list);
-                mnt->mnt_ns = NULL;
-                umount_tree(mnt, 1, umounts);
-                spin_unlock(&vfsmount_lock);
-        } else {
-                /*
-                 * Someone brought it back to life whilst we didn't have any
-                 * locks held so return it to the expiration list
-                 */
-                list_add_tail(&mnt->mnt_expire, mounts);
-                spin_unlock(&vfsmount_lock);
-        }
-}
-/*
- * go through the vfsmounts we've just consigned to the graveyard to
- * - check that they're still dead
- * - delete the vfsmount from the appropriate namespace under lock
- * - dispose of the corpse
- */
-static void expire_mount_list(struct list_head *graveyard, struct list_head *mounts)
-{
-        struct mnt_namespace *ns;
-        struct vfsmount *mnt;
-        while (!list_empty(graveyard)) {
-                LIST_HEAD(umounts);
-                mnt = list_first_entry(graveyard, struct vfsmount, mnt_expire);
-                list_del_init(&mnt->mnt_expire);
-                /* don't do anything if the namespace is dead - all the
-                 * vfsmounts from it are going away anyway */
-                ns = mnt->mnt_ns;
-                if (!ns || !ns->root)
-                        continue;
-                get_mnt_ns(ns);
-                spin_unlock(&vfsmount_lock);
-                down_write(&namespace_sem);
-                expire_mount(mnt, mounts, &umounts);
-                up_write(&namespace_sem);
-                release_mounts(&umounts);
-                mntput(mnt);
-                put_mnt_ns(ns);
-                spin_lock(&vfsmount_lock);
-        }
-}
 /*
 * process a list of expirable mountpoints with the intent of discarding any
 * mountpoints that aren't in use and haven't been touched since last we came
@@ -1284,10 +1217,12 @@ void mark_mounts_for_expiry(struct list_head *mounts)
 {
        struct vfsmount *mnt, *next;
        LIST_HEAD(graveyard);
+        LIST_HEAD(umounts);
        if (list_empty(mounts))
                return;
+        down_write(&namespace_sem);
        spin_lock(&vfsmount_lock);
        /* extract from the expiration list every vfsmount that matches the
@@ -1298,16 +1233,19 @@ void mark_mounts_for_expiry(struct list_head *mounts)
         */
        list_for_each_entry_safe(mnt, next, mounts, mnt_expire) {
                if (!xchg(&mnt->mnt_expiry_mark, 1) ||
-                    atomic_read(&mnt->mnt_count) != 1)
+                        propagate_mount_busy(mnt, 1))
                        continue;
-                mntget(mnt);
                list_move(&mnt->mnt_expire, &graveyard);
        }
+        while (!list_empty(&graveyard)) {
-        expire_mount_list(&graveyard, mounts);
+                mnt = list_first_entry(&graveyard, struct vfsmount, mnt_expire);
+                touch_mnt_namespace(mnt->mnt_ns);
+                umount_tree(mnt, 1, &umounts);
+        }
        spin_unlock(&vfsmount_lock);
+        up_write(&namespace_sem);
+        release_mounts(&umounts);
 }
 EXPORT_SYMBOL_GPL(mark_mounts_for_expiry);
@@ -1343,7 +1281,6 @@ resume:
                }
                if (!propagate_mount_busy(mnt, 1)) {
-                        mntget(mnt);
                        list_move_tail(&mnt->mnt_expire, graveyard);
                        found++;
                }
@@ -1363,22 +1300,22 @@ resume:
 * process a list of expirable mountpoints with the intent of discarding any
 * submounts of a specific parent mountpoint
 */
-void shrink_submounts(struct vfsmount *mountpoint, struct list_head *mounts)
+static void shrink_submounts(struct vfsmount *mnt, struct list_head *umounts)
 {
        LIST_HEAD(graveyard);
-        int found;
+        struct vfsmount *m;
-        spin_lock(&vfsmount_lock);
        /* extract submounts of 'mountpoint' from the expiration list */
-        while ((found = select_submounts(mountpoint, &graveyard)) != 0)
+        while (select_submounts(mnt, &graveyard)) {
-                expire_mount_list(&graveyard, mounts);
+                while (!list_empty(&graveyard)) {
+                        m = list_first_entry(&graveyard, struct vfsmount,
-        spin_unlock(&vfsmount_lock);
+                                                mnt_expire);
+                        touch_mnt_namespace(mnt->mnt_ns);
+                        umount_tree(mnt, 1, umounts);
+                }
+        }
 }
-EXPORT_SYMBOL_GPL(shrink_submounts);
 /*
 * Some copy_from_user() implementations do not return the exact number of
 * bytes remaining to copy on a fault.  But copy_mount_options() requires that.
@@ -1683,7 +1620,7 @@ void set_fs_pwd(struct fs_struct *fs, struct path *path)
                path_put(&old_pwd);
 }
-static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd)
+static void chroot_fs_refs(struct path *old_root, struct path *new_root)
 {
        struct task_struct *g, *p;
        struct fs_struct *fs;
@@ -1695,12 +1632,12 @@ static void chroot_fs_refs(struct nameidata *old_nd, struct nameidata *new_nd)
                if (fs) {
                        atomic_inc(&fs->count);
                        task_unlock(p);
-                        if (fs->root.dentry == old_nd->path.dentry
+                        if (fs->root.dentry == old_root->dentry
-                            && fs->root.mnt == old_nd->path.mnt)
+                            && fs->root.mnt == old_root->mnt)
-                                set_fs_root(fs, &new_nd->path);
+                                set_fs_root(fs, new_root);
-                        if (fs->pwd.dentry == old_nd->path.dentry
+                        if (fs->pwd.dentry == old_root->dentry
-                            && fs->pwd.mnt == old_nd->path.mnt)
+                            && fs->pwd.mnt == old_root->mnt)
-                                set_fs_pwd(fs, &new_nd->path);
+                                set_fs_pwd(fs, new_root);
                        put_fs_struct(fs);
                } else
                        task_unlock(p);
@@ -1737,7 +1674,8 @@ asmlinkage long sys_pivot_root(const char __user * new_root,
                               const char __user * put_old)
 {
        struct vfsmount *tmp;
-        struct nameidata new_nd, old_nd, parent_nd, root_parent, user_nd;
+        struct nameidata new_nd, old_nd, user_nd;
+        struct path parent_path, root_parent;
        int error;
        if (!capable(CAP_SYS_ADMIN))
@@ -1811,19 +1749,19 @@ asmlinkage long sys_pivot_root(const char __user * new_root,
                        goto out3;
        } else if (!is_subdir(old_nd.path.dentry, new_nd.path.dentry))
                goto out3;
-        detach_mnt(new_nd.path.mnt, &parent_nd);
+        detach_mnt(new_nd.path.mnt, &parent_path);
        detach_mnt(user_nd.path.mnt, &root_parent);
        /* mount old root on put_old */
-        attach_mnt(user_nd.path.mnt, &old_nd);
+        attach_mnt(user_nd.path.mnt, &old_nd.path);
        /* mount new_root on / */
        attach_mnt(new_nd.path.mnt, &root_parent);
        touch_mnt_namespace(current->nsproxy->mnt_ns);
        spin_unlock(&vfsmount_lock);
-        chroot_fs_refs(&user_nd, &new_nd);
+        chroot_fs_refs(&user_nd.path, &new_nd.path);
        security_sb_post_pivotroot(&user_nd, &new_nd);
        error = 0;
-        path_put(&root_parent.path);
+        path_put(&root_parent);
-        path_put(&parent_nd.path);
+        path_put(&parent_path);
 out2:
        mutex_unlock(&old_nd.path.dentry->d_inode->i_mutex);
        up_write(&namespace_sem);
diff --git a/fs/nfs/callback.c b/fs/nfs/callback.c
index ecc06c619494..66648dd92d97 100644
--- a/fs/nfs/callback.c
+++ b/fs/nfs/callback.c
@@ -93,6 +93,7 @@ static void nfs_callback_svc(struct svc_rqst *rqstp)
                svc_process(rqstp);
        }
+        flush_signals(current);
        svc_exit_thread(rqstp);
        nfs_callback_info.pid = 0;
        complete(&nfs_callback_info.stopped);
@@ -171,7 +172,7 @@ void nfs_callback_down(void)
 static int nfs_callback_authenticate(struct svc_rqst *rqstp)
 {
        struct nfs_client *clp;
-        char buf[RPC_MAX_ADDRBUFLEN];
+        RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
        /* Don't talk to strangers */
        clp = nfs_find_client(svc_addr(rqstp), 4);
diff --git a/fs/nfs/callback_xdr.c b/fs/nfs/callback_xdr.c
index c63eb720b68b..13619d24f023 100644
--- a/fs/nfs/callback_xdr.c
+++ b/fs/nfs/callback_xdr.c
@@ -254,7 +254,7 @@ static __be32 encode_attr_change(struct xdr_stream *xdr, const uint32_t *bitmap,
        if (!(bitmap[0] & FATTR4_WORD0_CHANGE))
                return 0;
        p = xdr_reserve_space(xdr, 8);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                return htonl(NFS4ERR_RESOURCE);
        p = xdr_encode_hyper(p, change);
        return 0;
@@ -267,7 +267,7 @@ static __be32 encode_attr_size(struct xdr_stream *xdr, const uint32_t *bitmap, u
        if (!(bitmap[0] & FATTR4_WORD0_SIZE))
                return 0;
        p = xdr_reserve_space(xdr, 8);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                return htonl(NFS4ERR_RESOURCE);
        p = xdr_encode_hyper(p, size);
        return 0;
@@ -278,7 +278,7 @@ static __be32 encode_attr_time(struct xdr_stream *xdr, const struct timespec *ti
        __be32 *p;
        p = xdr_reserve_space(xdr, 12);
-        if (unlikely(p == 0))
+        if (unlikely(!p))
                return htonl(NFS4ERR_RESOURCE);
        p = xdr_encode_hyper(p, time->tv_sec);
        *p = htonl(time->tv_nsec);
diff --git a/fs/nfs/delegation.c b/fs/nfs/delegation.c
index b9eadd18ba70..00a5e4405e16 100644
--- a/fs/nfs/delegation.c
+++ b/fs/nfs/delegation.c
@@ -49,7 +49,7 @@ static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_
        struct file_lock *fl;
        int status;
-        for (fl = inode->i_flock; fl != 0; fl = fl->fl_next) {
+        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
                if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
                        continue;
                if (nfs_file_open_context(fl->fl_file) != ctx)
diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
index ae04892a5e5d..6cea7479c5b4 100644
--- a/fs/nfs/dir.c
+++ b/fs/nfs/dir.c
@@ -710,6 +710,8 @@ int nfs_lookup_verify_inode(struct inode *inode, struct nameidata *nd)
 {
        struct nfs_server *server = NFS_SERVER(inode);
+        if (test_bit(NFS_INO_MOUNTPOINT, &NFS_I(inode)->flags))
+                return 0;
        if (nd != NULL) {
                /* VFS wants an on-the-wire revalidation */
                if (nd->flags & LOOKUP_REVAL)
diff --git a/fs/nfs/file.c b/fs/nfs/file.c
index ef57a5ae5904..5d2e9d9a4e28 100644
--- a/fs/nfs/file.c
+++ b/fs/nfs/file.c
@@ -64,7 +64,11 @@ const struct file_operations nfs_file_operations = {
        .write          = do_sync_write,
        .aio_read       = nfs_file_read,
        .aio_write      = nfs_file_write,
+#ifdef CONFIG_MMU
        .mmap           = nfs_file_mmap,
+#else
+        .mmap           = generic_file_mmap,
+#endif
        .open           = nfs_file_open,
        .flush          = nfs_file_flush,
        .release        = nfs_file_release,
diff --git a/fs/nfs/idmap.c b/fs/nfs/idmap.c
index 8ae5dba2d4e5..86147b0ab2cf 100644
--- a/fs/nfs/idmap.c
+++ b/fs/nfs/idmap.c
@@ -309,7 +309,7 @@ nfs_idmap_name(struct idmap *idmap, struct idmap_hashtable *h,
        mutex_lock(&idmap->idmap_im_lock);
        he = idmap_lookup_id(h, id);
-        if (he != 0) {
+        if (he) {
                memcpy(name, he->ih_name, he->ih_namelen);
                ret = he->ih_namelen;
                goto out;
diff --git a/fs/nfs/inode.c b/fs/nfs/inode.c
index 966a8850aa30..6f88d7c77ac9 100644
--- a/fs/nfs/inode.c
+++ b/fs/nfs/inode.c
@@ -299,6 +299,7 @@ nfs_fhget(struct super_block *sb, struct nfs_fh *fh, struct nfs_fattr *fattr)
                                else
                                        inode->i_op = &nfs_mountpoint_inode_operations;
                                inode->i_fop = NULL;
+                                set_bit(NFS_INO_MOUNTPOINT, &nfsi->flags);
                        }
                } else if (S_ISLNK(inode->i_mode))
                        inode->i_op = &nfs_symlink_inode_operations;
@@ -505,6 +506,7 @@ static struct nfs_open_context *alloc_nfs_open_context(struct vfsmount *mnt, str
                ctx->cred = get_rpccred(cred);
                ctx->state = NULL;
                ctx->lockowner = current->files;
+                ctx->flags = 0;
                ctx->error = 0;
                ctx->dir_cookie = 0;
                atomic_set(&ctx->count, 1);
@@ -1003,8 +1005,9 @@ static int nfs_update_inode(struct inode *inode, struct nfs_fattr *fattr)
        server = NFS_SERVER(inode);
        /* Update the fsid? */
-        if (S_ISDIR(inode->i_mode)
+        if (S_ISDIR(inode->i_mode) &&
-                        && !nfs_fsid_equal(&server->fsid, &fattr->fsid))
+                        !nfs_fsid_equal(&server->fsid, &fattr->fsid) &&
+                        !test_bit(NFS_INO_MOUNTPOINT, &nfsi->flags))
                server->fsid = fattr->fsid;
        /*
diff --git a/fs/nfs/internal.h b/fs/nfs/internal.h
index 0f5619611b8d..931992763e68 100644
--- a/fs/nfs/internal.h
+++ b/fs/nfs/internal.h
@@ -3,6 +3,7 @@
 */
 #include <linux/mount.h>
+#include <linux/security.h>
 struct nfs_string;
@@ -57,6 +58,8 @@ struct nfs_parsed_mount_data {
                char                    *export_path;
                int                     protocol;
        } nfs_server;
+        struct security_mnt_opts lsm_opts;
 };
 /* client.c */
diff --git a/fs/nfs/nfs4state.c b/fs/nfs/nfs4state.c
index 6233eb5e98c1..b962397004c1 100644
--- a/fs/nfs/nfs4state.c
+++ b/fs/nfs/nfs4state.c
@@ -785,7 +785,7 @@ static int nfs4_reclaim_locks(struct nfs4_state_recovery_ops *ops, struct nfs4_s
        struct file_lock *fl;
        int status = 0;
-        for (fl = inode->i_flock; fl != 0; fl = fl->fl_next) {
+        for (fl = inode->i_flock; fl != NULL; fl = fl->fl_next) {
                if (!(fl->fl_flags & (FL_POSIX|FL_FLOCK)))
                        continue;
                if (nfs_file_open_context(fl->fl_file)->state != state)
diff --git a/fs/nfs/read.c b/fs/nfs/read.c
index 3d7d9631e125..5a70be589bbe 100644
--- a/fs/nfs/read.c
+++ b/fs/nfs/read.c
@@ -533,7 +533,10 @@ readpage_async_filler(void *data, struct page *page)
        if (len < PAGE_CACHE_SIZE)
                zero_user_segment(page, len, PAGE_CACHE_SIZE);
-        nfs_pageio_add_request(desc->pgio, new);
+        if (!nfs_pageio_add_request(desc->pgio, new)) {
+                error = desc->pgio->pg_error;
+                goto out_unlock;
+        }
        return 0;
 out_error:
        error = PTR_ERR(new);
diff --git a/fs/nfs/super.c b/fs/nfs/super.c
index 1fb381843650..f9219024f31a 100644
--- a/fs/nfs/super.c
+++ b/fs/nfs/super.c
@@ -589,8 +589,6 @@ static void nfs_umount_begin(struct vfsmount *vfsmnt, int flags)
        struct nfs_server *server = NFS_SB(vfsmnt->mnt_sb);
        struct rpc_clnt *rpc;
-        shrink_submounts(vfsmnt, &nfs_automount_list);
        if (!(flags & MNT_FORCE))
                return;
        /* -EIO all pending I/O */
@@ -632,7 +630,7 @@ static int nfs_verify_server_address(struct sockaddr *addr)
        switch (addr->sa_family) {
        case AF_INET: {
                struct sockaddr_in *sa = (struct sockaddr_in *)addr;
-                return sa->sin_addr.s_addr != INADDR_ANY;
+                return sa->sin_addr.s_addr != htonl(INADDR_ANY);
        }
        case AF_INET6: {
                struct in6_addr *sa = &((struct sockaddr_in6 *)addr)->sin6_addr;
@@ -684,8 +682,9 @@ static void nfs_parse_server_address(char *value,
 static int nfs_parse_mount_options(char *raw,
                                   struct nfs_parsed_mount_data *mnt)
 {
-        char *p, *string;
+        char *p, *string, *secdata;
        unsigned short port = 0;
+        int rc;
        if (!raw) {
                dfprintk(MOUNT, "NFS: mount options string was NULL.\n");
@@ -693,6 +692,20 @@ static int nfs_parse_mount_options(char *raw,
        }
        dfprintk(MOUNT, "NFS: nfs mount opts='%s'\n", raw);
+        secdata = alloc_secdata();
+        if (!secdata)
+                goto out_nomem;
+        rc = security_sb_copy_data(raw, secdata);
+        if (rc)
+                goto out_security_failure;
+        rc = security_sb_parse_opts_str(secdata, &mnt->lsm_opts);
+        if (rc)
+                goto out_security_failure;
+        free_secdata(secdata);
        while ((p = strsep(&raw, ",")) != NULL) {
                substring_t args[MAX_OPT_ARGS];
                int option, token;
@@ -1042,7 +1055,10 @@ static int nfs_parse_mount_options(char *raw,
 out_nomem:
        printk(KERN_INFO "NFS: not enough memory to parse option\n");
        return 0;
+out_security_failure:
+        free_secdata(secdata);
+        printk(KERN_INFO "NFS: security options invalid: %d\n", rc);
+        return 0;
 out_unrec_vers:
        printk(KERN_INFO "NFS: unrecognized NFS version number\n");
        return 0;
@@ -1214,6 +1230,33 @@ static int nfs_validate_mount_data(void *options,
                args->namlen            = data->namlen;
                args->bsize             = data->bsize;
                args->auth_flavors[0]   = data->pseudoflavor;
+                /*
+                 * The legacy version 6 binary mount data from userspace has a
+                 * field used only to transport selinux information into the
+                 * the kernel.  To continue to support that functionality we
+                 * have a touch of selinux knowledge here in the NFS code. The
+                 * userspace code converted context=blah to just blah so we are
+                 * converting back to the full string selinux understands.
+                 */
+                if (data->context[0]){
+#ifdef CONFIG_SECURITY_SELINUX
+                        int rc;
+                        char *opts_str = kmalloc(sizeof(data->context) + 8, GFP_KERNEL);
+                        if (!opts_str)
+                                return -ENOMEM;
+                        strcpy(opts_str, "context=");
+                        data->context[NFS_MAX_CONTEXT_LEN] = '\0';
+                        strcat(opts_str, &data->context[0]);
+                        rc = security_sb_parse_opts_str(opts_str, &args->lsm_opts);
+                        kfree(opts_str);
+                        if (rc)
+                                return rc;
+#else
+                        return -EINVAL;
+#endif
+                }
                break;
        default: {
                unsigned int len;
@@ -1476,6 +1519,8 @@ static int nfs_get_sb(struct file_system_type *fs_type,
        };
        int error;
+        security_init_mnt_opts(&data.lsm_opts);
        /* Validate the mount data */
        error = nfs_validate_mount_data(raw_data, &data, &mntfh, dev_name);
        if (error < 0)
@@ -1515,6 +1560,10 @@ static int nfs_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;
@@ -1523,12 +1572,15 @@ static int nfs_get_sb(struct file_system_type *fs_type,
 out:
        kfree(data.nfs_server.hostname);
        kfree(data.mount_server.hostname);
+        security_free_mnt_opts(&data.lsm_opts);
        return error;
 out_err_nosb:
        nfs_free_server(server);
        goto out;
+error_splat_root:
+        dput(mntroot);
 error_splat_super:
        up_write(&s->s_umount);
        deactivate_super(s);
@@ -1608,6 +1660,9 @@ static int nfs_xdev_get_sb(struct file_system_type *fs_type, int flags,
        mnt->mnt_sb = s;
        mnt->mnt_root = mntroot;
+        /* clone any lsm security options from the parent to the new sb */
+        security_sb_clone_mnt_opts(data->sb, s);
        dprintk("<-- nfs_xdev_get_sb() = 0\n");
        return 0;
@@ -1850,6 +1905,8 @@ static int nfs4_get_sb(struct file_system_type *fs_type,
        };
        int error;
+        security_init_mnt_opts(&data.lsm_opts);
        /* Validate the mount data */
        error = nfs4_validate_mount_data(raw_data, &data, dev_name);
        if (error < 0)
@@ -1898,6 +1955,7 @@ out:
        kfree(data.client_address);
        kfree(data.nfs_server.export_path);
        kfree(data.nfs_server.hostname);
+        security_free_mnt_opts(&data.lsm_opts);
        return error;
 out_free:
diff --git a/fs/nfs/write.c b/fs/nfs/write.c
index f55c437124a2..bed63416a55b 100644
--- a/fs/nfs/write.c
+++ b/fs/nfs/write.c
@@ -39,6 +39,7 @@ static struct nfs_page * nfs_update_request(struct nfs_open_context*,
                                            unsigned int, unsigned int);
 static void nfs_pageio_init_write(struct nfs_pageio_descriptor *desc,
                                  struct inode *inode, int ioflags);
+static void nfs_redirty_request(struct nfs_page *req);
 static const struct rpc_call_ops nfs_write_partial_ops;
 static const struct rpc_call_ops nfs_write_full_ops;
 static const struct rpc_call_ops nfs_commit_ops;
@@ -288,7 +289,12 @@ static int nfs_page_async_flush(struct nfs_pageio_descriptor *pgio,
                BUG();
        }
        spin_unlock(&inode->i_lock);
-        nfs_pageio_add_request(pgio, req);
+        if (!nfs_pageio_add_request(pgio, req)) {
+                nfs_redirty_request(req);
+                nfs_end_page_writeback(page);
+                nfs_clear_page_tag_locked(req);
+                return pgio->pg_error;
+        }
        return 0;
 }
@@ -734,7 +740,7 @@ int nfs_updatepage(struct file *file, struct page *page,
         */
        if (nfs_write_pageuptodate(page, inode) &&
                        inode->i_flock == NULL &&
-                        !(file->f_mode & O_SYNC)) {
+                        !(file->f_flags & O_SYNC)) {
                count = max(count + offset, nfs_page_length(page));
                offset = 0;
        }
diff --git a/fs/nfsd/nfsfh.c b/fs/nfsd/nfsfh.c
index 0130b345234d..3e6b3f41ee1f 100644
--- a/fs/nfsd/nfsfh.c
+++ b/fs/nfsd/nfsfh.c
@@ -101,7 +101,7 @@ static __be32 nfsd_setuser_and_check_port(struct svc_rqst *rqstp,
 {
        /* Check if the request originated from a secure port. */
        if (!rqstp->rq_secure && EX_SECURE(exp)) {
-                char buf[RPC_MAX_ADDRBUFLEN];
+                RPC_IFDEBUG(char buf[RPC_MAX_ADDRBUFLEN]);
                dprintk(KERN_WARNING
                       "nfsd: request from insecure port %s!\n",
                       svc_print_addr(rqstp, buf, sizeof(buf)));
@@ -232,6 +232,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
                fhp->fh_dentry = dentry;
                fhp->fh_export = exp;
                nfsd_nr_verified++;
+                cache_get(&exp->h);
        } else {
                /*
                 * just rechecking permissions
@@ -241,6 +242,7 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
                dprintk("nfsd: fh_verify - just checking\n");
                dentry = fhp->fh_dentry;
                exp = fhp->fh_export;
+                cache_get(&exp->h);
                /*
                 * Set user creds for this exportpoint; necessary even
                 * in the "just checking" case because this may be a
@@ -252,8 +254,6 @@ fh_verify(struct svc_rqst *rqstp, struct svc_fh *fhp, int type, int access)
                if (error)
                        goto out;
        }
-        cache_get(&exp->h);
        error = nfsd_mode_check(rqstp, dentry->d_inode->i_mode, type);
        if (error)
diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
index 82243127eebf..90383ed61005 100644
--- a/fs/ocfs2/aops.c
+++ b/fs/ocfs2/aops.c
@@ -257,7 +257,7 @@ static int ocfs2_readpage_inline(struct inode *inode, struct page *page)
        struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
        BUG_ON(!PageLocked(page));
-        BUG_ON(!OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL);
+        BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
        ret = ocfs2_read_block(osb, OCFS2_I(inode)->ip_blkno, &di_bh,
                               OCFS2_BH_CACHED, inode);
diff --git a/fs/ocfs2/cluster/tcp.c b/fs/ocfs2/cluster/tcp.c
index ee50c9610e7f..b8057c51b205 100644
--- a/fs/ocfs2/cluster/tcp.c
+++ b/fs/ocfs2/cluster/tcp.c
@@ -451,9 +451,9 @@ static void o2net_set_nn_state(struct o2net_node *nn,
                /* delay if we're withing a RECONNECT_DELAY of the
                 * last attempt */
                delay = (nn->nn_last_connect_attempt +
-                         msecs_to_jiffies(o2net_reconnect_delay(sc->sc_node)))
+                         msecs_to_jiffies(o2net_reconnect_delay(NULL)))
                        - jiffies;
-                if (delay > msecs_to_jiffies(o2net_reconnect_delay(sc->sc_node)))
+                if (delay > msecs_to_jiffies(o2net_reconnect_delay(NULL)))
                        delay = 0;
                mlog(ML_CONN, "queueing conn attempt in %lu jiffies\n", delay);
                queue_delayed_work(o2net_wq, &nn->nn_connect_work, delay);
@@ -1552,12 +1552,11 @@ static void o2net_connect_expired(struct work_struct *work)
        spin_lock(&nn->nn_lock);
        if (!nn->nn_sc_valid) {
-                struct o2nm_node *node = nn->nn_sc->sc_node;
                mlog(ML_ERROR, "no connection established with node %u after "
                     "%u.%u seconds, giving up and returning errors.\n",
                     o2net_num_from_nn(nn),
-                     o2net_idle_timeout(node) / 1000,
+                     o2net_idle_timeout(NULL) / 1000,
-                     o2net_idle_timeout(node) % 1000);
+                     o2net_idle_timeout(NULL) % 1000);
                o2net_set_nn_state(nn, NULL, 0, -ENOTCONN);
        }
diff --git a/fs/ocfs2/dir.c b/fs/ocfs2/dir.c
index e280833ceb9a..8a1875848080 100644
--- a/fs/ocfs2/dir.c
+++ b/fs/ocfs2/dir.c
@@ -390,9 +390,8 @@ static int __ocfs2_delete_entry(handle_t *handle, struct inode *dir,
                                goto bail;
                        }
                        if (pde)
-                                pde->rec_len =
+                                le16_add_cpu(&pde->rec_len,
-                                        cpu_to_le16(le16_to_cpu(pde->rec_len) +
+                                                le16_to_cpu(de->rec_len));
-                                                    le16_to_cpu(de->rec_len));
                        else
                                de->inode = 0;
                        dir->i_version++;
diff --git a/fs/ocfs2/dlm/dlmcommon.h b/fs/ocfs2/dlm/dlmcommon.h
index 9843ee17ea27..dc8ea666efdb 100644
--- a/fs/ocfs2/dlm/dlmcommon.h
+++ b/fs/ocfs2/dlm/dlmcommon.h
@@ -176,6 +176,7 @@ struct dlm_mig_lockres_priv
 {
        struct dlm_lock_resource *lockres;
        u8 real_master;
+        u8 extra_ref;
 };
 struct dlm_assert_master_priv
@@ -602,17 +603,19 @@ enum dlm_query_join_response_code {
        JOIN_PROTOCOL_MISMATCH,
 };
+struct dlm_query_join_packet {
+        u8 code;        /* Response code.  dlm_minor and fs_minor
+                           are only valid if this is JOIN_OK */
+        u8 dlm_minor;   /* The minor version of the protocol the
+                           dlm is speaking. */
+        u8 fs_minor;    /* The minor version of the protocol the
+                           filesystem is speaking. */
+        u8 reserved;
+};
 union dlm_query_join_response {
        u32 intval;
-        struct {
+        struct dlm_query_join_packet packet;
-                u8 code;        /* Response code.  dlm_minor and fs_minor
-                                   are only valid if this is JOIN_OK */
-                u8 dlm_minor;   /* The minor version of the protocol the
-                                   dlm is speaking. */
-                u8 fs_minor;    /* The minor version of the protocol the
-                                   filesystem is speaking. */
-                u8 reserved;
-        } packet;
 };
 struct dlm_lock_request
diff --git a/fs/ocfs2/dlm/dlmconvert.c b/fs/ocfs2/dlm/dlmconvert.c
index ecb4d997221e..75997b4deaf3 100644
--- a/fs/ocfs2/dlm/dlmconvert.c
+++ b/fs/ocfs2/dlm/dlmconvert.c
@@ -487,7 +487,7 @@ int dlm_convert_lock_handler(struct o2net_msg *msg, u32 len, void *data,
                               "cookie=%u:%llu\n",
                     dlm_get_lock_cookie_node(be64_to_cpu(cnv->cookie)),
                     dlm_get_lock_cookie_seq(be64_to_cpu(cnv->cookie)));
-                __dlm_print_one_lock_resource(res);
+                dlm_print_one_lock_resource(res);
                goto leave;
        }
diff --git a/fs/ocfs2/dlm/dlmdomain.c b/fs/ocfs2/dlm/dlmdomain.c
index 638d2ebb892b..0879d86113e3 100644
--- a/fs/ocfs2/dlm/dlmdomain.c
+++ b/fs/ocfs2/dlm/dlmdomain.c
@@ -713,14 +713,46 @@ static int dlm_query_join_proto_check(char *proto_type, int node,
        return rc;
 }
+/*
+ * struct dlm_query_join_packet is made up of four one-byte fields.  They
+ * are effectively in big-endian order already.  However, little-endian
+ * machines swap them before putting the packet on the wire (because
+ * query_join's response is a status, and that status is treated as a u32
+ * on the wire).  Thus, a big-endian and little-endian machines will treat
+ * this structure differently.
+ *
+ * The solution is to have little-endian machines swap the structure when
+ * converting from the structure to the u32 representation.  This will
+ * result in the structure having the correct format on the wire no matter
+ * the host endian format.
+ */
+static void dlm_query_join_packet_to_wire(struct dlm_query_join_packet *packet,
+                                          u32 *wire)
+{
+        union dlm_query_join_response response;
+        response.packet = *packet;
+        *wire = cpu_to_be32(response.intval);
+}
+static void dlm_query_join_wire_to_packet(u32 wire,
+                                          struct dlm_query_join_packet *packet)
+{
+        union dlm_query_join_response response;
+        response.intval = cpu_to_be32(wire);
+        *packet = response.packet;
+}
 static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                                  void **ret_data)
 {
        struct dlm_query_join_request *query;
-        union dlm_query_join_response response = {
+        struct dlm_query_join_packet packet = {
-                .packet.code = JOIN_DISALLOW,
+                .code = JOIN_DISALLOW,
        };
        struct dlm_ctxt *dlm = NULL;
+        u32 response;
        u8 nodenum;
        query = (struct dlm_query_join_request *) msg->buf;
@@ -737,11 +769,11 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                mlog(0, "node %u is not in our live map yet\n",
                     query->node_idx);
-                response.packet.code = JOIN_DISALLOW;
+                packet.code = JOIN_DISALLOW;
                goto respond;
        }
-        response.packet.code = JOIN_OK_NO_MAP;
+        packet.code = JOIN_OK_NO_MAP;
        spin_lock(&dlm_domain_lock);
        dlm = __dlm_lookup_domain_full(query->domain, query->name_len);
@@ -760,7 +792,7 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                                mlog(0, "disallow join as node %u does not "
                                     "have node %u in its nodemap\n",
                                     query->node_idx, nodenum);
-                                response.packet.code = JOIN_DISALLOW;
+                                packet.code = JOIN_DISALLOW;
                                goto unlock_respond;
                        }
                }
@@ -780,23 +812,23 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                        /*If this is a brand new context and we
                         * haven't started our join process yet, then
                         * the other node won the race. */
-                        response.packet.code = JOIN_OK_NO_MAP;
+                        packet.code = JOIN_OK_NO_MAP;
                } else if (dlm->joining_node != DLM_LOCK_RES_OWNER_UNKNOWN) {
                        /* Disallow parallel joins. */
-                        response.packet.code = JOIN_DISALLOW;
+                        packet.code = JOIN_DISALLOW;
                } else if (dlm->reco.state & DLM_RECO_STATE_ACTIVE) {
                        mlog(0, "node %u trying to join, but recovery "
                             "is ongoing.\n", bit);
-                        response.packet.code = JOIN_DISALLOW;
+                        packet.code = JOIN_DISALLOW;
                } else if (test_bit(bit, dlm->recovery_map)) {
                        mlog(0, "node %u trying to join, but it "
                             "still needs recovery.\n", bit);
-                        response.packet.code = JOIN_DISALLOW;
+                        packet.code = JOIN_DISALLOW;
                } else if (test_bit(bit, dlm->domain_map)) {
                        mlog(0, "node %u trying to join, but it "
                             "is still in the domain! needs recovery?\n",
                             bit);
-                        response.packet.code = JOIN_DISALLOW;
+                        packet.code = JOIN_DISALLOW;
                } else {
                        /* Alright we're fully a part of this domain
                         * so we keep some state as to who's joining
@@ -807,19 +839,15 @@ static int dlm_query_join_handler(struct o2net_msg *msg, u32 len, void *data,
                        if (dlm_query_join_proto_check("DLM", bit,
                                                       &dlm->dlm_locking_proto,
                                                       &query->dlm_proto)) {
-                                response.packet.code =
+                                packet.code = JOIN_PROTOCOL_MISMATCH;
-                                        JOIN_PROTOCOL_MISMATCH;
                        } else if (dlm_query_join_proto_check("fs", bit,
                                                              &dlm->fs_locking_proto,
                                                              &query->fs_proto)) {
-                                response.packet.code =
+                                packet.code = JOIN_PROTOCOL_MISMATCH;
-                                        JOIN_PROTOCOL_MISMATCH;
                        } else {
-                                response.packet.dlm_minor =
+                                packet.dlm_minor = query->dlm_proto.pv_minor;
-                                        query->dlm_proto.pv_minor;
+                                packet.fs_minor = query->fs_proto.pv_minor;
-                                response.packet.fs_minor =
+                                packet.code = JOIN_OK;
-                                        query->fs_proto.pv_minor;
-                                response.packet.code = JOIN_OK;
                                __dlm_set_joining_node(dlm, query->node_idx);
                        }
                }
@@ -830,9 +858,10 @@ unlock_respond:
        spin_unlock(&dlm_domain_lock);
 respond:
-        mlog(0, "We respond with %u\n", response.packet.code);
+        mlog(0, "We respond with %u\n", packet.code);
-        return response.intval;
+        dlm_query_join_packet_to_wire(&packet, &response);
+        return response;
 }
 static int dlm_assert_joined_handler(struct o2net_msg *msg, u32 len, void *data,
@@ -937,7 +966,7 @@ static int dlm_send_join_cancels(struct dlm_ctxt *dlm,
                         sizeof(unsigned long))) {
                mlog(ML_ERROR,
                     "map_size %u != BITS_TO_LONGS(O2NM_MAX_NODES) %u\n",
-                     map_size, BITS_TO_LONGS(O2NM_MAX_NODES));
+                     map_size, (unsigned)BITS_TO_LONGS(O2NM_MAX_NODES));
                return -EINVAL;
        }
@@ -968,7 +997,8 @@ static int dlm_request_join(struct dlm_ctxt *dlm,
 {
        int status;
        struct dlm_query_join_request join_msg;
-        union dlm_query_join_response join_resp;
+        struct dlm_query_join_packet packet;
+        u32 join_resp;
        mlog(0, "querying node %d\n", node);
@@ -984,11 +1014,12 @@ static int dlm_request_join(struct dlm_ctxt *dlm,
        status = o2net_send_message(DLM_QUERY_JOIN_MSG, DLM_MOD_KEY, &join_msg,
                                    sizeof(join_msg), node,
-                                    &join_resp.intval);
+                                    &join_resp);
        if (status < 0 && status != -ENOPROTOOPT) {
                mlog_errno(status);
                goto bail;
        }
+        dlm_query_join_wire_to_packet(join_resp, &packet);
        /* -ENOPROTOOPT from the net code means the other side isn't
            listening for our message type -- that's fine, it means
@@ -997,10 +1028,10 @@ static int dlm_request_join(struct dlm_ctxt *dlm,
        if (status == -ENOPROTOOPT) {
                status = 0;
                *response = JOIN_OK_NO_MAP;
-        } else if (join_resp.packet.code == JOIN_DISALLOW ||
+        } else if (packet.code == JOIN_DISALLOW ||
-                   join_resp.packet.code == JOIN_OK_NO_MAP) {
+                   packet.code == JOIN_OK_NO_MAP) {
-                *response = join_resp.packet.code;
+                *response = packet.code;
-        } else if (join_resp.packet.code == JOIN_PROTOCOL_MISMATCH) {
+        } else if (packet.code == JOIN_PROTOCOL_MISMATCH) {
                mlog(ML_NOTICE,
                     "This node requested DLM locking protocol %u.%u and "
                     "filesystem locking protocol %u.%u.  At least one of "
@@ -1012,14 +1043,12 @@ static int dlm_request_join(struct dlm_ctxt *dlm,
                     dlm->fs_locking_proto.pv_minor,
                     node);
                status = -EPROTO;
-                *response = join_resp.packet.code;
+                *response = packet.code;
-        } else if (join_resp.packet.code == JOIN_OK) {
+        } else if (packet.code == JOIN_OK) {
-                *response = join_resp.packet.code;
+                *response = packet.code;
                /* Use the same locking protocol as the remote node */
-                dlm->dlm_locking_proto.pv_minor =
+                dlm->dlm_locking_proto.pv_minor = packet.dlm_minor;
-                        join_resp.packet.dlm_minor;
+                dlm->fs_locking_proto.pv_minor = packet.fs_minor;
-                dlm->fs_locking_proto.pv_minor =
-                        join_resp.packet.fs_minor;
                mlog(0,
                     "Node %d responds JOIN_OK with DLM locking protocol "
                     "%u.%u and fs locking protocol %u.%u\n",
@@ -1031,11 +1060,11 @@ static int dlm_request_join(struct dlm_ctxt *dlm,
        } else {
                status = -EINVAL;
                mlog(ML_ERROR, "invalid response %d from node %u\n",
-                     join_resp.packet.code, node);
+                     packet.code, node);
        }
        mlog(0, "status %d, node %d response is %d\n", status, node,
-                  *response);
+             *response);
 bail:
        return status;
diff --git a/fs/ocfs2/dlm/dlmmaster.c b/fs/ocfs2/dlm/dlmmaster.c
index a54d33d95ada..ea6b89577860 100644
--- a/fs/ocfs2/dlm/dlmmaster.c
+++ b/fs/ocfs2/dlm/dlmmaster.c
@@ -1663,7 +1663,12 @@ way_up_top:
                dlm_put_mle(tmpmle);
        }
 send_response:
+        /*
+         * __dlm_lookup_lockres() grabbed a reference to this lockres.
+         * The reference is released by dlm_assert_master_worker() under
+         * the call to dlm_dispatch_assert_master().  If
+         * dlm_assert_master_worker() isn't called, we drop it here.
+         */
        if (dispatch_assert) {
                if (response != DLM_MASTER_RESP_YES)
                        mlog(ML_ERROR, "invalid response %d\n", response);
@@ -1678,7 +1683,11 @@ send_response:
                if (ret < 0) {
                        mlog(ML_ERROR, "failed to dispatch assert master work\n");
                        response = DLM_MASTER_RESP_ERROR;
+                        dlm_lockres_put(res);
                }
+        } else {
+                if (res)
+                        dlm_lockres_put(res);
        }
        dlm_put(dlm);
@@ -1695,9 +1704,9 @@ send_response:
 * can periodically run all locks owned by this node
 * and re-assert across the cluster...
 */
-int dlm_do_assert_master(struct dlm_ctxt *dlm,
+static int dlm_do_assert_master(struct dlm_ctxt *dlm,
-                         struct dlm_lock_resource *res,
+                                struct dlm_lock_resource *res,
-                         void *nodemap, u32 flags)
+                                void *nodemap, u32 flags)
 {
        struct dlm_assert_master assert;
        int to, tmpret;
@@ -2348,7 +2357,7 @@ int dlm_deref_lockres_handler(struct o2net_msg *msg, u32 len, void *data,
                        mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref "
                        "but it is already dropped!\n", dlm->name,
                        res->lockname.len, res->lockname.name, node);
-                        __dlm_print_one_lock_resource(res);
+                        dlm_print_one_lock_resource(res);
                }
                ret = 0;
                goto done;
@@ -2408,7 +2417,7 @@ static void dlm_deref_lockres_worker(struct dlm_work_item *item, void *data)
                mlog(ML_ERROR, "%s:%.*s: node %u trying to drop ref "
                     "but it is already dropped!\n", dlm->name,
                     res->lockname.len, res->lockname.name, node);
-                __dlm_print_one_lock_resource(res);
+                dlm_print_one_lock_resource(res);
        }
        dlm_lockres_put(res);
@@ -2933,6 +2942,9 @@ static void dlm_remove_nonlocal_locks(struct dlm_ctxt *dlm,
                                dlm_lockres_clear_refmap_bit(lock->ml.node, res);
                                list_del_init(&lock->list);
                                dlm_lock_put(lock);
+                                /* In a normal unlock, we would have added a
+                                 * DLM_UNLOCK_FREE_LOCK action. Force it. */
+                                dlm_lock_put(lock);
                        }
                }
                queue++;
diff --git a/fs/ocfs2/dlm/dlmrecovery.c b/fs/ocfs2/dlm/dlmrecovery.c
index 91f747b8a538..bcb9260c3735 100644
--- a/fs/ocfs2/dlm/dlmrecovery.c
+++ b/fs/ocfs2/dlm/dlmrecovery.c
@@ -519,9 +519,9 @@ static int dlm_do_recovery(struct dlm_ctxt *dlm)
        return 0;
 master_here:
-        mlog(0, "(%d) mastering recovery of %s:%u here(this=%u)!\n",
+        mlog(ML_NOTICE, "(%d) Node %u is the Recovery Master for the Dead Node "
-             task_pid_nr(dlm->dlm_reco_thread_task),
+             "%u for Domain %s\n", task_pid_nr(dlm->dlm_reco_thread_task),
-             dlm->name, dlm->reco.dead_node, dlm->node_num);
+             dlm->node_num, dlm->reco.dead_node, dlm->name);
        status = dlm_remaster_locks(dlm, dlm->reco.dead_node);
        if (status < 0) {
@@ -1191,7 +1191,7 @@ static int dlm_add_lock_to_array(struct dlm_lock *lock,
                            (ml->type == LKM_EXMODE ||
                             memcmp(mres->lvb, lock->lksb->lvb, DLM_LVB_LEN))) {
                                mlog(ML_ERROR, "mismatched lvbs!\n");
-                                __dlm_print_one_lock_resource(lock->lockres);
+                                dlm_print_one_lock_resource(lock->lockres);
                                BUG();
                        }
                        memcpy(mres->lvb, lock->lksb->lvb, DLM_LVB_LEN);
@@ -1327,6 +1327,7 @@ int dlm_mig_lockres_handler(struct o2net_msg *msg, u32 len, void *data,
                (struct dlm_migratable_lockres *)msg->buf;
        int ret = 0;
        u8 real_master;
+        u8 extra_refs = 0;
        char *buf = NULL;
        struct dlm_work_item *item = NULL;
        struct dlm_lock_resource *res = NULL;
@@ -1404,16 +1405,28 @@ int dlm_mig_lockres_handler(struct o2net_msg *msg, u32 len, void *data,
                __dlm_insert_lockres(dlm, res);
                spin_unlock(&dlm->spinlock);
+                /* Add an extra ref for this lock-less lockres lest the
+                 * dlm_thread purges it before we get the chance to add
+                 * locks to it */
+                dlm_lockres_get(res);
+                /* There are three refs that need to be put.
+                 * 1. Taken above.
+                 * 2. kref_init in dlm_new_lockres()->dlm_init_lockres().
+                 * 3. dlm_lookup_lockres()
+                 * The first one is handled at the end of this function. The
+                 * other two are handled in the worker thread after locks have
+                 * been attached. Yes, we don't wait for purge time to match
+                 * kref_init. The lockres will still have atleast one ref
+                 * added because it is in the hash __dlm_insert_lockres() */
+                extra_refs++;
                /* now that the new lockres is inserted,
                 * make it usable by other processes */
                spin_lock(&res->spinlock);
                res->state &= ~DLM_LOCK_RES_IN_PROGRESS;
                spin_unlock(&res->spinlock);
                wake_up(&res->wq);
-                /* add an extra ref for just-allocated lockres 
-                 * otherwise the lockres will be purged immediately */
-                dlm_lockres_get(res);
        }
        /* at this point we have allocated everything we need,
@@ -1443,12 +1456,17 @@ int dlm_mig_lockres_handler(struct o2net_msg *msg, u32 len, void *data,
        dlm_init_work_item(dlm, item, dlm_mig_lockres_worker, buf);
        item->u.ml.lockres = res; /* already have a ref */
        item->u.ml.real_master = real_master;
+        item->u.ml.extra_ref = extra_refs;
        spin_lock(&dlm->work_lock);
        list_add_tail(&item->list, &dlm->work_list);
        spin_unlock(&dlm->work_lock);
        queue_work(dlm->dlm_worker, &dlm->dispatched_work);
 leave:
+        /* One extra ref taken needs to be put here */
+        if (extra_refs)
+                dlm_lockres_put(res);
        dlm_put(dlm);
        if (ret < 0) {
                if (buf)
@@ -1464,17 +1482,19 @@ leave:
 static void dlm_mig_lockres_worker(struct dlm_work_item *item, void *data)
 {
-        struct dlm_ctxt *dlm = data;
+        struct dlm_ctxt *dlm;
        struct dlm_migratable_lockres *mres;
        int ret = 0;
        struct dlm_lock_resource *res;
        u8 real_master;
+        u8 extra_ref;
        dlm = item->dlm;
        mres = (struct dlm_migratable_lockres *)data;
        res = item->u.ml.lockres;
        real_master = item->u.ml.real_master;
+        extra_ref = item->u.ml.extra_ref;
        if (real_master == DLM_LOCK_RES_OWNER_UNKNOWN) {
                /* this case is super-rare. only occurs if
@@ -1517,6 +1537,12 @@ again:
        }
 leave:
+        /* See comment in dlm_mig_lockres_handler() */
+        if (res) {
+                if (extra_ref)
+                        dlm_lockres_put(res);
+                dlm_lockres_put(res);
+        }
        kfree(data);
        mlog_exit(ret);
 }
@@ -1644,7 +1670,8 @@ int dlm_master_requery_handler(struct o2net_msg *msg, u32 len, void *data,
                                /* retry!? */
                                BUG();
                        }
-                }
+                } else /* put.. incase we are not the master */
+                        dlm_lockres_put(res);
                spin_unlock(&res->spinlock);
        }
        spin_unlock(&dlm->spinlock);
@@ -1921,6 +1948,7 @@ void dlm_move_lockres_to_recovery_list(struct dlm_ctxt *dlm,
                     "Recovering res %s:%.*s, is already on recovery list!\n",
                     dlm->name, res->lockname.len, res->lockname.name);
                list_del_init(&res->recovering);
+                dlm_lockres_put(res);
        }
        /* We need to hold a reference while on the recovery list */
        dlm_lockres_get(res);
@@ -2130,11 +2158,16 @@ static void dlm_free_dead_locks(struct dlm_ctxt *dlm,
        assert_spin_locked(&dlm->spinlock);
        assert_spin_locked(&res->spinlock);
+        /* We do two dlm_lock_put(). One for removing from list and the other is
+         * to force the DLM_UNLOCK_FREE_LOCK action so as to free the locks */
        /* TODO: check pending_asts, pending_basts here */
        list_for_each_entry_safe(lock, next, &res->granted, list) {
                if (lock->ml.node == dead_node) {
                        list_del_init(&lock->list);
                        dlm_lock_put(lock);
+                        /* Can't schedule DLM_UNLOCK_FREE_LOCK - do manually */
+                        dlm_lock_put(lock);
                        freed++;
                }
        }
@@ -2142,6 +2175,8 @@ static void dlm_free_dead_locks(struct dlm_ctxt *dlm,
                if (lock->ml.node == dead_node) {
                        list_del_init(&lock->list);
                        dlm_lock_put(lock);
+                        /* Can't schedule DLM_UNLOCK_FREE_LOCK - do manually */
+                        dlm_lock_put(lock);
                        freed++;
                }
        }
@@ -2149,6 +2184,8 @@ static void dlm_free_dead_locks(struct dlm_ctxt *dlm,
                if (lock->ml.node == dead_node) {
                        list_del_init(&lock->list);
                        dlm_lock_put(lock);
+                        /* Can't schedule DLM_UNLOCK_FREE_LOCK - do manually */
+                        dlm_lock_put(lock);
                        freed++;
                }
        }
diff --git a/fs/ocfs2/dlm/dlmthread.c b/fs/ocfs2/dlm/dlmthread.c
index cebd089f8955..4060bb328bc8 100644
--- a/fs/ocfs2/dlm/dlmthread.c
+++ b/fs/ocfs2/dlm/dlmthread.c
@@ -176,12 +176,14 @@ static int dlm_purge_lockres(struct dlm_ctxt *dlm,
             res->lockname.name, master);
        if (!master) {
+                /* drop spinlock...  retake below */
+                spin_unlock(&dlm->spinlock);
                spin_lock(&res->spinlock);
                /* This ensures that clear refmap is sent after the set */
                __dlm_wait_on_lockres_flags(res, DLM_LOCK_RES_SETREF_INPROG);
                spin_unlock(&res->spinlock);
-                /* drop spinlock to do messaging, retake below */
-                spin_unlock(&dlm->spinlock);
                /* clear our bit from the master's refmap, ignore errors */
                ret = dlm_drop_lockres_ref(dlm, res);
                if (ret < 0) {
diff --git a/fs/ocfs2/dlmglue.c b/fs/ocfs2/dlmglue.c
index 351130c9b734..1f1873bf41fb 100644
--- a/fs/ocfs2/dlmglue.c
+++ b/fs/ocfs2/dlmglue.c
@@ -2409,7 +2409,7 @@ static int ocfs2_dlm_seq_show(struct seq_file *m, void *v)
        return 0;
 }
-static struct seq_operations ocfs2_dlm_seq_ops = {
+static const struct seq_operations ocfs2_dlm_seq_ops = {
        .start =        ocfs2_dlm_seq_start,
        .stop =         ocfs2_dlm_seq_stop,
        .next =         ocfs2_dlm_seq_next,
@@ -3042,7 +3042,7 @@ static int ocfs2_data_convert_worker(struct ocfs2_lock_res *lockres,
        inode = ocfs2_lock_res_inode(lockres);
        mapping = inode->i_mapping;
-        if (S_ISREG(inode->i_mode))
+        if (!S_ISREG(inode->i_mode))
                goto out;
        /*
@@ -3219,8 +3219,8 @@ static int ocfs2_dentry_convert_worker(struct ocfs2_lock_res *lockres,
        return UNBLOCK_CONTINUE_POST;
 }
-void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
+static void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
-                                struct ocfs2_lock_res *lockres)
+                                       struct ocfs2_lock_res *lockres)
 {
        int status;
        struct ocfs2_unblock_ctl ctl = {0, 0,};
@@ -3356,7 +3356,7 @@ static int ocfs2_downconvert_thread_should_wake(struct ocfs2_super *osb)
        return should_wake;
 }
-int ocfs2_downconvert_thread(void *arg)
+static int ocfs2_downconvert_thread(void *arg)
 {
        int status = 0;
        struct ocfs2_super *osb = arg;
diff --git a/fs/ocfs2/dlmglue.h b/fs/ocfs2/dlmglue.h
index 1d5b0699d0a9..e3cf902404b4 100644
--- a/fs/ocfs2/dlmglue.h
+++ b/fs/ocfs2/dlmglue.h
@@ -109,8 +109,6 @@ void ocfs2_simple_drop_lockres(struct ocfs2_super *osb,
                               struct ocfs2_lock_res *lockres);
 /* for the downconvert thread */
-void ocfs2_process_blocked_lock(struct ocfs2_super *osb,
-                                struct ocfs2_lock_res *lockres);
 void ocfs2_wake_downconvert_thread(struct ocfs2_super *osb);
 struct ocfs2_dlm_debug *ocfs2_new_dlm_debug(void);
diff --git a/fs/ocfs2/heartbeat.c b/fs/ocfs2/heartbeat.c
index c0efd9489fe8..0758daf64da0 100644
--- a/fs/ocfs2/heartbeat.c
+++ b/fs/ocfs2/heartbeat.c
@@ -49,10 +49,15 @@ static inline void __ocfs2_node_map_set_bit(struct ocfs2_node_map *map,
 static inline void __ocfs2_node_map_clear_bit(struct ocfs2_node_map *map,
                                              int bit);
 static inline int __ocfs2_node_map_is_empty(struct ocfs2_node_map *map);
-static void __ocfs2_node_map_dup(struct ocfs2_node_map *target,
-                                 struct ocfs2_node_map *from);
+/* special case -1 for now
-static void __ocfs2_node_map_set(struct ocfs2_node_map *target,
+ * TODO: should *really* make sure the calling func never passes -1!!  */
-                                 struct ocfs2_node_map *from);
+static void ocfs2_node_map_init(struct ocfs2_node_map *map)
+{
+        map->num_nodes = OCFS2_NODE_MAP_MAX_NODES;
+        memset(map->map, 0, BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES) *
+               sizeof(unsigned long));
+}
 void ocfs2_init_node_maps(struct ocfs2_super *osb)
 {
@@ -136,15 +141,6 @@ void ocfs2_stop_heartbeat(struct ocfs2_super *osb)
                mlog_errno(ret);
 }
-/* special case -1 for now
- * TODO: should *really* make sure the calling func never passes -1!!  */
-void ocfs2_node_map_init(struct ocfs2_node_map *map)
-{
-        map->num_nodes = OCFS2_NODE_MAP_MAX_NODES;
-        memset(map->map, 0, BITS_TO_LONGS(OCFS2_NODE_MAP_MAX_NODES) *
-               sizeof(unsigned long));
-}
 static inline void __ocfs2_node_map_set_bit(struct ocfs2_node_map *map,
                                            int bit)
 {
@@ -216,6 +212,8 @@ int ocfs2_node_map_is_empty(struct ocfs2_super *osb,
        return ret;
 }
+#if 0
 static void __ocfs2_node_map_dup(struct ocfs2_node_map *target,
                                 struct ocfs2_node_map *from)
 {
@@ -254,6 +252,8 @@ static void __ocfs2_node_map_set(struct ocfs2_node_map *target,
                target->map[i] = from->map[i];
 }
+#endif  /*  0  */
 /* Returns whether the recovery bit was actually set - it may not be
 * if a node is still marked as needing recovery */
 int ocfs2_recovery_map_set(struct ocfs2_super *osb,
diff --git a/fs/ocfs2/heartbeat.h b/fs/ocfs2/heartbeat.h
index 56859211888a..eac63aed7611 100644
--- a/fs/ocfs2/heartbeat.h
+++ b/fs/ocfs2/heartbeat.h
@@ -33,7 +33,6 @@ void ocfs2_stop_heartbeat(struct ocfs2_super *osb);
 /* node map functions - used to keep track of mounted and in-recovery
 * nodes. */
-void ocfs2_node_map_init(struct ocfs2_node_map *map);
 int ocfs2_node_map_is_empty(struct ocfs2_super *osb,
                            struct ocfs2_node_map *map);
 void ocfs2_node_map_set_bit(struct ocfs2_super *osb,
@@ -57,9 +56,5 @@ int ocfs2_recovery_map_set(struct ocfs2_super *osb,
                           int num);
 void ocfs2_recovery_map_clear(struct ocfs2_super *osb,
                              int num);
-/* returns 1 if bit is the only bit set in target, 0 otherwise */
-int ocfs2_node_map_is_only(struct ocfs2_super *osb,
-                           struct ocfs2_node_map *target,
-                           int bit);
 #endif /* OCFS2_HEARTBEAT_H */
diff --git a/fs/ocfs2/localalloc.c b/fs/ocfs2/localalloc.c
index add1ffdc5c6c..ab83fd562429 100644
--- a/fs/ocfs2/localalloc.c
+++ b/fs/ocfs2/localalloc.c
@@ -120,9 +120,6 @@ int ocfs2_load_local_alloc(struct ocfs2_super *osb)
        mlog_entry_void();
-        if (ocfs2_mount_local(osb))
-                goto bail;
        if (osb->local_alloc_size == 0)
                goto bail;
@@ -588,8 +585,7 @@ int ocfs2_claim_local_alloc_bits(struct ocfs2_super *osb,
        while(bits_wanted--)
                ocfs2_set_bit(start++, bitmap);
-        alloc->id1.bitmap1.i_used = cpu_to_le32(*num_bits +
+        le32_add_cpu(&alloc->id1.bitmap1.i_used, *num_bits);
-                                le32_to_cpu(alloc->id1.bitmap1.i_used));
        status = ocfs2_journal_dirty(handle, osb->local_alloc_bh);
        if (status < 0) {
diff --git a/fs/ocfs2/resize.c b/fs/ocfs2/resize.c
index 37835ffcb039..8166968e9015 100644
--- a/fs/ocfs2/resize.c
+++ b/fs/ocfs2/resize.c
@@ -597,7 +597,7 @@ int ocfs2_group_add(struct inode *inode, struct ocfs2_new_group_input *input)
                memset(cr, 0, sizeof(struct ocfs2_chain_rec));
        }
-        cr->c_blkno = le64_to_cpu(input->group);
+        cr->c_blkno = cpu_to_le64(input->group);
        le32_add_cpu(&cr->c_total, input->clusters * cl_bpc);
        le32_add_cpu(&cr->c_free, input->frees * cl_bpc);
diff --git a/fs/open.c b/fs/open.c
index 54198538b67e..3fa4e4ffce4c 100644
--- a/fs/open.c
+++ b/fs/open.c
@@ -335,7 +335,7 @@ asmlinkage long sys_ftruncate(unsigned int fd, unsigned long length)
 {
        long ret = do_sys_ftruncate(fd, length, 1);
        /* avoid REGPARM breakage on x86: */
-        prevent_tail_call(ret);
+        asmlinkage_protect(2, ret, fd, length);
        return ret;
 }
@@ -350,7 +350,7 @@ asmlinkage long sys_ftruncate64(unsigned int fd, loff_t length)
 {
        long ret = do_sys_ftruncate(fd, length, 0);
        /* avoid REGPARM breakage on x86: */
-        prevent_tail_call(ret);
+        asmlinkage_protect(2, ret, fd, length);
        return ret;
 }
 #endif
@@ -903,6 +903,18 @@ struct file *dentry_open(struct dentry *dentry, struct vfsmount *mnt, int flags)
        int error;
        struct file *f;
+        /*
+         * We must always pass in a valid mount pointer.   Historically
+         * callers got away with not passing it, but we must enforce this at
+         * the earliest possible point now to avoid strange problems deep in the
+         * filesystem stack.
+         */
+        if (!mnt) {
+                printk(KERN_WARNING "%s called with NULL vfsmount\n", __func__);
+                dump_stack();
+                return ERR_PTR(-EINVAL);
+        }
        error = -ENFILE;
        f = get_empty_filp();
        if (f == NULL) {
@@ -1055,7 +1067,7 @@ asmlinkage long sys_open(const char __user *filename, int flags, int mode)
        ret = do_sys_open(AT_FDCWD, filename, flags, mode);
        /* avoid REGPARM breakage on x86: */
-        prevent_tail_call(ret);
+        asmlinkage_protect(3, ret, filename, flags, mode);
        return ret;
 }
@@ -1069,7 +1081,7 @@ asmlinkage long sys_openat(int dfd, const char __user *filename, int flags,
        ret = do_sys_open(dfd, filename, flags, mode);
        /* avoid REGPARM breakage on x86: */
-        prevent_tail_call(ret);
+        asmlinkage_protect(4, ret, dfd, filename, flags, mode);
        return ret;
 }
diff --git a/fs/pipe.c b/fs/pipe.c
index 3c185b6527bc..8be381bbcb54 100644
--- a/fs/pipe.c
+++ b/fs/pipe.c
@@ -957,13 +957,10 @@ struct file *create_write_pipe(void)
        struct dentry *dentry;
        struct qstr name = { .name = "" };
-        f = get_empty_filp();
-        if (!f)
-                return ERR_PTR(-ENFILE);
        err = -ENFILE;
        inode = get_pipe_inode();
        if (!inode)
-                goto err_file;
+                goto err;
        err = -ENOMEM;
        dentry = d_alloc(pipe_mnt->mnt_sb->s_root, &name);
@@ -978,22 +975,24 @@ struct file *create_write_pipe(void)
         */
        dentry->d_flags &= ~DCACHE_UNHASHED;
        d_instantiate(dentry, inode);
-        f->f_path.mnt = mntget(pipe_mnt);
-        f->f_path.dentry = dentry;
+        err = -ENFILE;
+        f = alloc_file(pipe_mnt, dentry, FMODE_WRITE, &write_pipe_fops);
+        if (!f)
+                goto err_dentry;
        f->f_mapping = inode->i_mapping;
        f->f_flags = O_WRONLY;
-        f->f_op = &write_pipe_fops;
-        f->f_mode = FMODE_WRITE;
        f->f_version = 0;
        return f;
+ err_dentry:
+        dput(dentry);
 err_inode:
        free_pipe_info(inode);
        iput(inode);
- err_file:
+ err:
-        put_filp(f);
        return ERR_PTR(err);
 }
diff --git a/fs/pnode.c b/fs/pnode.c
index 05ba692bc540..1d8f5447f3f7 100644
--- a/fs/pnode.c
+++ b/fs/pnode.c
@@ -225,7 +225,7 @@ out:
 */
 static inline int do_refcount_check(struct vfsmount *mnt, int count)
 {
-        int mycount = atomic_read(&mnt->mnt_count);
+        int mycount = atomic_read(&mnt->mnt_count) - mnt->mnt_ghosts;
        return (mycount > count);
 }
diff --git a/fs/proc/base.c b/fs/proc/base.c
index 88f8edf18258..81d7d145292a 100644
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -314,9 +314,12 @@ static int proc_pid_schedstat(struct task_struct *task, char *buffer)
 static int lstats_show_proc(struct seq_file *m, void *v)
 {
        int i;
-        struct task_struct *task = m->private;
+        struct inode *inode = m->private;
-        seq_puts(m, "Latency Top version : v0.1\n");
+        struct task_struct *task = get_proc_task(inode);
+        if (!task)
+                return -ESRCH;
+        seq_puts(m, "Latency Top version : v0.1\n");
        for (i = 0; i < 32; i++) {
                if (task->latency_record[i].backtrace[0]) {
                        int q;
@@ -341,32 +344,24 @@ static int lstats_show_proc(struct seq_file *m, void *v)
                }
        }
+        put_task_struct(task);
        return 0;
 }
 static int lstats_open(struct inode *inode, struct file *file)
 {
-        int ret;
+        return single_open(file, lstats_show_proc, inode);
-        struct seq_file *m;
-        struct task_struct *task = get_proc_task(inode);
-        ret = single_open(file, lstats_show_proc, NULL);
-        if (!ret) {
-                m = file->private_data;
-                m->private = task;
-        }
-        return ret;
 }
 static ssize_t lstats_write(struct file *file, const char __user *buf,
                            size_t count, loff_t *offs)
 {
-        struct seq_file *m;
+        struct task_struct *task = get_proc_task(file->f_dentry->d_inode);
-        struct task_struct *task;
-        m = file->private_data;
+        if (!task)
-        task = m->private;
+                return -ESRCH;
        clear_all_latency_tracing(task);
+        put_task_struct(task);
        return count;
 }
@@ -416,6 +411,7 @@ static const struct limit_names lnames[RLIM_NLIMITS] = {
        [RLIMIT_MSGQUEUE] = {"Max msgqueue size", "bytes"},
        [RLIMIT_NICE] = {"Max nice priority", NULL},
        [RLIMIT_RTPRIO] = {"Max realtime priority", NULL},
+        [RLIMIT_RTTIME] = {"Max realtime timeout", "us"},
 };
 /* Display limits for a process */
@@ -1040,6 +1036,26 @@ static const struct file_operations proc_loginuid_operations = {
        .read           = proc_loginuid_read,
        .write          = proc_loginuid_write,
 };
+static ssize_t proc_sessionid_read(struct file * file, char __user * buf,
+                                  size_t count, loff_t *ppos)
+{
+        struct inode * inode = file->f_path.dentry->d_inode;
+        struct task_struct *task = get_proc_task(inode);
+        ssize_t length;
+        char tmpbuf[TMPBUFLEN];
+        if (!task)
+                return -ESRCH;
+        length = scnprintf(tmpbuf, TMPBUFLEN, "%u",
+                                audit_get_sessionid(task));
+        put_task_struct(task);
+        return simple_read_from_buffer(buf, count, ppos, tmpbuf, length);
+}
+static const struct file_operations proc_sessionid_operations = {
+        .read           = proc_sessionid_read,
+};
 #endif
 #ifdef CONFIG_FAULT_INJECTION
@@ -2273,6 +2289,9 @@ static const struct pid_entry tgid_base_stuff[] = {
        DIR("task",       S_IRUGO|S_IXUGO, task),
        DIR("fd",         S_IRUSR|S_IXUSR, fd),
        DIR("fdinfo",     S_IRUSR|S_IXUSR, fdinfo),
+#ifdef CONFIG_NET
+        DIR("net",        S_IRUGO|S_IXUGO, net),
+#endif
        REG("environ",    S_IRUSR, environ),
        INF("auxv",       S_IRUSR, pid_auxv),
        ONE("status",     S_IRUGO, pid_status),
@@ -2320,6 +2339,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),
 #endif
 #ifdef CONFIG_FAULT_INJECTION
        REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
@@ -2650,6 +2670,7 @@ static const struct pid_entry tid_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),
 #endif
 #ifdef CONFIG_FAULT_INJECTION
        REG("make-it-fail", S_IRUGO|S_IWUSR, fault_inject),
diff --git a/fs/proc/generic.c b/fs/proc/generic.c
index 68971e66cd41..a36ad3c75cf4 100644
--- a/fs/proc/generic.c
+++ b/fs/proc/generic.c
@@ -377,15 +377,14 @@ static struct dentry_operations proc_dentry_operations =
 * Don't create negative dentries here, return -ENOENT by hand
 * instead.
 */
-struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
+struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *dir,
+                struct dentry *dentry)
 {
        struct inode *inode = NULL;
-        struct proc_dir_entry * de;
        int error = -ENOENT;
        lock_kernel();
        spin_lock(&proc_subdir_lock);
-        de = PDE(dir);
        if (de) {
                for (de = de->subdir; de ; de = de->next) {
                        if (de->namelen != dentry->d_name.len)
@@ -393,8 +392,6 @@ struct dentry *proc_lookup(struct inode * dir, struct dentry *dentry, struct nam
                        if (!memcmp(dentry->d_name.name, de->name, de->namelen)) {
                                unsigned int ino;
-                                if (de->shadow_proc)
-                                        de = de->shadow_proc(current, de);
                                ino = de->low_ino;
                                de_get(de);
                                spin_unlock(&proc_subdir_lock);
@@ -417,6 +414,12 @@ out_unlock:
        return ERR_PTR(error);
 }
+struct dentry *proc_lookup(struct inode *dir, struct dentry *dentry,
+                struct nameidata *nd)
+{
+        return proc_lookup_de(PDE(dir), dir, dentry);
+}
 /*
 * This returns non-zero if at EOF, so that the /proc
 * root directory can use this and check if it should
@@ -426,10 +429,9 @@ out_unlock:
 * value of the readdir() call, as long as it's non-negative
 * for success..
 */
-int proc_readdir(struct file * filp,
+int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent,
-        void * dirent, filldir_t filldir)
+                filldir_t filldir)
 {
-        struct proc_dir_entry * de;
        unsigned int ino;
        int i;
        struct inode *inode = filp->f_path.dentry->d_inode;
@@ -438,7 +440,6 @@ int proc_readdir(struct file * filp,
        lock_kernel();
        ino = inode->i_ino;
-        de = PDE(inode);
        if (!de) {
                ret = -EINVAL;
                goto out;
@@ -499,6 +500,13 @@ out:	unlock_kernel();
        return ret;     
 }
+int proc_readdir(struct file *filp, void *dirent, filldir_t filldir)
+{
+        struct inode *inode = filp->f_path.dentry->d_inode;
+        return proc_readdir_de(PDE(inode), filp, dirent, filldir);
+}
 /*
 * These are the generic /proc directory operations. They
 * use the in-memory "struct proc_dir_entry" tree to parse
diff --git a/fs/proc/internal.h b/fs/proc/internal.h
index 1c81c8f1aeed..bc72f5c8c47d 100644
--- a/fs/proc/internal.h
+++ b/fs/proc/internal.h
@@ -64,6 +64,8 @@ extern const struct file_operations proc_numa_maps_operations;
 extern const struct file_operations proc_smaps_operations;
 extern const struct file_operations proc_clear_refs_operations;
 extern const struct file_operations proc_pagemap_operations;
+extern const struct file_operations proc_net_operations;
+extern const struct inode_operations proc_net_inode_operations;
 void free_proc_entry(struct proc_dir_entry *de);
@@ -83,3 +85,8 @@ static inline int proc_fd(struct inode *inode)
 {
        return PROC_I(inode)->fd;
 }
+struct dentry *proc_lookup_de(struct proc_dir_entry *de, struct inode *ino,
+                struct dentry *dentry);
+int proc_readdir_de(struct proc_dir_entry *de, struct file *filp, void *dirent,
+                filldir_t filldir);
diff --git a/fs/proc/proc_misc.c b/fs/proc/proc_misc.c
index 468805d40e2b..2d563979cb02 100644
--- a/fs/proc/proc_misc.c
+++ b/fs/proc/proc_misc.c
@@ -32,6 +32,7 @@
 #include <linux/interrupt.h>
 #include <linux/swap.h>
 #include <linux/slab.h>
+#include <linux/genhd.h>
 #include <linux/smp.h>
 #include <linux/signal.h>
 #include <linux/module.h>
@@ -377,7 +378,6 @@ static int stram_read_proc(char *page, char **start, off_t off,
 #endif
 #ifdef CONFIG_BLOCK
-extern const struct seq_operations partitions_op;
 static int partitions_open(struct inode *inode, struct file *file)
 {
        return seq_open(file, &partitions_op);
@@ -389,7 +389,6 @@ static const struct file_operations proc_partitions_operations = {
        .release        = seq_release,
 };
-extern const struct seq_operations diskstats_op;
 static int diskstats_open(struct inode *inode, struct file *file)
 {
        return seq_open(file, &diskstats_op);
diff --git a/fs/proc/proc_net.c b/fs/proc/proc_net.c
index 14e9b5aaf863..4caa5f774fb7 100644
--- a/fs/proc/proc_net.c
+++ b/fs/proc/proc_net.c
@@ -63,6 +63,82 @@ int seq_release_net(struct inode *ino, struct file *f)
 }
 EXPORT_SYMBOL_GPL(seq_release_net);
+static struct net *get_proc_task_net(struct inode *dir)
+{
+        struct task_struct *task;
+        struct nsproxy *ns;
+        struct net *net = NULL;
+        rcu_read_lock();
+        task = pid_task(proc_pid(dir), PIDTYPE_PID);
+        if (task != NULL) {
+                ns = task_nsproxy(task);
+                if (ns != NULL)
+                        net = get_net(ns->net_ns);
+        }
+        rcu_read_unlock();
+        return net;
+}
+static struct dentry *proc_tgid_net_lookup(struct inode *dir,
+                struct dentry *dentry, struct nameidata *nd)
+{
+        struct dentry *de;
+        struct net *net;
+        de = ERR_PTR(-ENOENT);
+        net = get_proc_task_net(dir);
+        if (net != NULL) {
+                de = proc_lookup_de(net->proc_net, dir, dentry);
+                put_net(net);
+        }
+        return de;
+}
+static int proc_tgid_net_getattr(struct vfsmount *mnt, struct dentry *dentry,
+                struct kstat *stat)
+{
+        struct inode *inode = dentry->d_inode;
+        struct net *net;
+        net = get_proc_task_net(inode);
+        generic_fillattr(inode, stat);
+        if (net != NULL) {
+                stat->nlink = net->proc_net->nlink;
+                put_net(net);
+        }
+        return 0;
+}
+const struct inode_operations proc_net_inode_operations = {
+        .lookup         = proc_tgid_net_lookup,
+        .getattr        = proc_tgid_net_getattr,
+};
+static int proc_tgid_net_readdir(struct file *filp, void *dirent,
+                filldir_t filldir)
+{
+        int ret;
+        struct net *net;
+        ret = -EINVAL;
+        net = get_proc_task_net(filp->f_path.dentry->d_inode);
+        if (net != NULL) {
+                ret = proc_readdir_de(net->proc_net, filp, dirent, filldir);
+                put_net(net);
+        }
+        return ret;
+}
+const struct file_operations proc_net_operations = {
+        .read           = generic_read_dir,
+        .readdir        = proc_tgid_net_readdir,
+};
 struct proc_dir_entry *proc_net_fops_create(struct net *net,
        const char *name, mode_t mode, const struct file_operations *fops)
@@ -83,14 +159,6 @@ struct net *get_proc_net(const struct inode *inode)
 }
 EXPORT_SYMBOL_GPL(get_proc_net);
-static struct proc_dir_entry *shadow_pde;
-static struct proc_dir_entry *proc_net_shadow(struct task_struct *task,
-                                                struct proc_dir_entry *de)
-{
-        return task->nsproxy->net_ns->proc_net;
-}
 struct proc_dir_entry *proc_net_mkdir(struct net *net, const char *name,
                struct proc_dir_entry *parent)
 {
@@ -104,45 +172,39 @@ EXPORT_SYMBOL_GPL(proc_net_mkdir);
 static __net_init int proc_net_ns_init(struct net *net)
 {
-        struct proc_dir_entry *root, *netd, *net_statd;
+        struct proc_dir_entry *netd, *net_statd;
        int err;
        err = -ENOMEM;
-        root = kzalloc(sizeof(*root), GFP_KERNEL);
+        netd = kzalloc(sizeof(*netd), GFP_KERNEL);
-        if (!root)
+        if (!netd)
                goto out;
-        err = -EEXIST;
+        netd->data = net;
-        netd = proc_net_mkdir(net, "net", root);
+        netd->nlink = 2;
-        if (!netd)
+        netd->name = "net";
-                goto free_root;
+        netd->namelen = 3;
+        netd->parent = &proc_root;
        err = -EEXIST;
        net_statd = proc_net_mkdir(net, "stat", netd);
        if (!net_statd)
                goto free_net;
-        root->data = net;
-        net->proc_net_root = root;
        net->proc_net = netd;
        net->proc_net_stat = net_statd;
-        err = 0;
+        return 0;
+free_net:
+        kfree(netd);
 out:
        return err;
-free_net:
-        remove_proc_entry("net", root);
-free_root:
-        kfree(root);
-        goto out;
 }
 static __net_exit void proc_net_ns_exit(struct net *net)
 {
        remove_proc_entry("stat", net->proc_net);
-        remove_proc_entry("net", net->proc_net_root);
+        kfree(net->proc_net);
-        kfree(net->proc_net_root);
 }
 static struct pernet_operations __net_initdata proc_net_ns_ops = {
@@ -152,8 +214,7 @@ static struct pernet_operations __net_initdata proc_net_ns_ops = {
 int __init proc_net_init(void)
 {
-        shadow_pde = proc_mkdir("net", NULL);
+        proc_symlink("net", NULL, "self/net");
-        shadow_pde->shadow_proc = proc_net_shadow;
        return register_pernet_subsys(&proc_net_ns_ops);
 }
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index 49958cffbd8d..9dfb5ff24209 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -527,13 +527,21 @@ struct pagemapread {
        char __user *out, *end;
 };
-#define PM_ENTRY_BYTES sizeof(u64)
+#define PM_ENTRY_BYTES      sizeof(u64)
-#define PM_RESERVED_BITS    3
+#define PM_STATUS_BITS      3
-#define PM_RESERVED_OFFSET  (64 - PM_RESERVED_BITS)
+#define PM_STATUS_OFFSET    (64 - PM_STATUS_BITS)
-#define PM_RESERVED_MASK    (((1LL<<PM_RESERVED_BITS)-1) << PM_RESERVED_OFFSET)
+#define PM_STATUS_MASK      (((1LL << PM_STATUS_BITS) - 1) << PM_STATUS_OFFSET)
-#define PM_SPECIAL(nr)      (((nr) << PM_RESERVED_OFFSET) | PM_RESERVED_MASK)
+#define PM_STATUS(nr)       (((nr) << PM_STATUS_OFFSET) & PM_STATUS_MASK)
-#define PM_NOT_PRESENT      PM_SPECIAL(1LL)
+#define PM_PSHIFT_BITS      6
-#define PM_SWAP             PM_SPECIAL(2LL)
+#define PM_PSHIFT_OFFSET    (PM_STATUS_OFFSET - PM_PSHIFT_BITS)
+#define PM_PSHIFT_MASK      (((1LL << PM_PSHIFT_BITS) - 1) << PM_PSHIFT_OFFSET)
+#define PM_PSHIFT(x)        (((u64) (x) << PM_PSHIFT_OFFSET) & PM_PSHIFT_MASK)
+#define PM_PFRAME_MASK      ((1LL << PM_PSHIFT_OFFSET) - 1)
+#define PM_PFRAME(x)        ((x) & PM_PFRAME_MASK)
+#define PM_PRESENT          PM_STATUS(4LL)
+#define PM_SWAP             PM_STATUS(2LL)
+#define PM_NOT_PRESENT      PM_PSHIFT(PAGE_SHIFT)
 #define PM_END_OF_BUFFER    1
 static int add_to_pagemap(unsigned long addr, u64 pfn,
@@ -574,7 +582,7 @@ static int pagemap_pte_hole(unsigned long start, unsigned long end,
 u64 swap_pte_to_pagemap_entry(pte_t pte)
 {
        swp_entry_t e = pte_to_swp_entry(pte);
-        return PM_SWAP | swp_type(e) | (swp_offset(e) << MAX_SWAPFILES_SHIFT);
+        return swp_type(e) | (swp_offset(e) << MAX_SWAPFILES_SHIFT);
 }
 static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
@@ -588,9 +596,11 @@ static int pagemap_pte_range(pmd_t *pmd, unsigned long addr, unsigned long end,
                u64 pfn = PM_NOT_PRESENT;
                pte = pte_offset_map(pmd, addr);
                if (is_swap_pte(*pte))
-                        pfn = swap_pte_to_pagemap_entry(*pte);
+                        pfn = PM_PFRAME(swap_pte_to_pagemap_entry(*pte))
+                                | PM_PSHIFT(PAGE_SHIFT) | PM_SWAP;
                else if (pte_present(*pte))
-                        pfn = pte_pfn(*pte);
+                        pfn = PM_PFRAME(pte_pfn(*pte))
+                                | PM_PSHIFT(PAGE_SHIFT) | PM_PRESENT;
                /* unmap so we're not in atomic when we copy to userspace */
                pte_unmap(pte);
                err = add_to_pagemap(addr, pfn, pm);
@@ -611,12 +621,20 @@ static struct mm_walk pagemap_walk = {
 /*
 * /proc/pid/pagemap - an array mapping virtual pages to pfns
 *
- * For each page in the address space, this file contains one 64-bit
+ * For each page in the address space, this file contains one 64-bit entry
- * entry representing the corresponding physical page frame number
+ * consisting of the following:
- * (PFN) if the page is present. If there is a swap entry for the
+ *
- * physical page, then an encoding of the swap file number and the
+ * Bits 0-55  page frame number (PFN) if present
- * page's offset into the swap file are returned. If no page is
+ * Bits 0-4   swap type if swapped
- * present at all, PM_NOT_PRESENT is returned. This allows determining
+ * Bits 5-55  swap offset if swapped
+ * Bits 55-60 page shift (page size = 1<<page shift)
+ * Bit  61    reserved for future use
+ * Bit  62    page swapped
+ * Bit  63    page present
+ *
+ * If the page is not present but in swap, then the PFN contains an
+ * encoding of the swap file number and the page's offset into the
+ * swap. Unmapped pages return a null PFN. This allows determining
 * precisely which pages are mapped (or in swap) and comparing mapped
 * pages between processes.
 *
@@ -640,17 +658,17 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
        ret = -EACCES;
        if (!ptrace_may_attach(task))
-                goto out;
+                goto out_task;
        ret = -EINVAL;
        /* file position must be aligned */
        if (*ppos % PM_ENTRY_BYTES)
-                goto out;
+                goto out_task;
        ret = 0;
        mm = get_task_mm(task);
        if (!mm)
-                goto out;
+                goto out_task;
        ret = -ENOMEM;
        uaddr = (unsigned long)buf & PAGE_MASK;
@@ -658,7 +676,7 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
        pagecount = (PAGE_ALIGN(uend) - uaddr) / PAGE_SIZE;
        pages = kmalloc(pagecount * sizeof(struct page *), GFP_KERNEL);
        if (!pages)
-                goto out_task;
+                goto out_mm;
        down_read(&current->mm->mmap_sem);
        ret = get_user_pages(current, current->mm, uaddr, pagecount,
@@ -668,6 +686,12 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
        if (ret < 0)
                goto out_free;
+        if (ret != pagecount) {
+                pagecount = ret;
+                ret = -EFAULT;
+                goto out_pages;
+        }
        pm.out = buf;
        pm.end = buf + count;
@@ -699,15 +723,17 @@ static ssize_t pagemap_read(struct file *file, char __user *buf,
                        ret = pm.out - buf;
        }
+out_pages:
        for (; pagecount; pagecount--) {
                page = pages[pagecount-1];
                if (!PageReserved(page))
                        SetPageDirty(page);
                page_cache_release(page);
        }
-        mmput(mm);
 out_free:
        kfree(pages);
+out_mm:
+        mmput(mm);
 out_task:
        put_task_struct(task);
 out:
diff --git a/fs/reiserfs/do_balan.c b/fs/reiserfs/do_balan.c
index f85c5cf4934c..7ee4208793b6 100644
--- a/fs/reiserfs/do_balan.c
+++ b/fs/reiserfs/do_balan.c
@@ -283,7 +283,7 @@ static int balance_leaf(struct tree_balance *tb, struct item_head *ih,	/* item h
                return balance_leaf_when_delete(tb, flag);
        zeros_num = 0;
-        if (flag == M_INSERT && body == 0)
+        if (flag == M_INSERT && !body)
                zeros_num = ih_item_len(ih);
        pos_in_item = tb->tb_path->pos_in_item;
@@ -1728,7 +1728,7 @@ struct buffer_head *get_FEB(struct tree_balance *tb)
        struct buffer_info bi;
        for (i = 0; i < MAX_FEB_SIZE; i++)
-                if (tb->FEB[i] != 0)
+                if (tb->FEB[i] != NULL)
                        break;
        if (i == MAX_FEB_SIZE)
@@ -1827,7 +1827,7 @@ int get_left_neighbor_position(struct tree_balance *tb, int h)
 {
        int Sh_position = PATH_H_POSITION(tb->tb_path, h + 1);
-        RFALSE(PATH_H_PPARENT(tb->tb_path, h) == 0 || tb->FL[h] == 0,
+        RFALSE(PATH_H_PPARENT(tb->tb_path, h) == NULL || tb->FL[h] == NULL,
               "vs-12325: FL[%d](%p) or F[%d](%p) does not exist",
               h, tb->FL[h], h, PATH_H_PPARENT(tb->tb_path, h));
@@ -1841,7 +1841,7 @@ int get_right_neighbor_position(struct tree_balance *tb, int h)
 {
        int Sh_position = PATH_H_POSITION(tb->tb_path, h + 1);
-        RFALSE(PATH_H_PPARENT(tb->tb_path, h) == 0 || tb->FR[h] == 0,
+        RFALSE(PATH_H_PPARENT(tb->tb_path, h) == NULL || tb->FR[h] == NULL,
               "vs-12330: F[%d](%p) or FR[%d](%p) does not exist",
               h, PATH_H_PPARENT(tb->tb_path, h), h, tb->FR[h]);
diff --git a/fs/reiserfs/fix_node.c b/fs/reiserfs/fix_node.c
index 0ee35c6c9b72..07d05e0842b7 100644
--- a/fs/reiserfs/fix_node.c
+++ b/fs/reiserfs/fix_node.c
@@ -153,7 +153,7 @@ static void create_virtual_node(struct tree_balance *tb, int h)
        if (vn->vn_mode == M_INSERT) {
                struct virtual_item *vi = vn->vn_vi + vn->vn_affected_item_num;
-                RFALSE(vn->vn_ins_ih == 0,
+                RFALSE(vn->vn_ins_ih == NULL,
                       "vs-8040: item header of inserted item is not specified");
                vi->vi_item_len = tb->insert_size[0];
                vi->vi_ih = vn->vn_ins_ih;
@@ -857,7 +857,8 @@ static int get_lfree(struct tree_balance *tb, int h)
        struct buffer_head *l, *f;
        int order;
-        if ((f = PATH_H_PPARENT(tb->tb_path, h)) == 0 || (l = tb->FL[h]) == 0)
+        if ((f = PATH_H_PPARENT(tb->tb_path, h)) == NULL ||
+            (l = tb->FL[h]) == NULL)
                return 0;
        if (f == l)
@@ -878,7 +879,8 @@ static int get_rfree(struct tree_balance *tb, int h)
        struct buffer_head *r, *f;
        int order;
-        if ((f = PATH_H_PPARENT(tb->tb_path, h)) == 0 || (r = tb->FR[h]) == 0)
+        if ((f = PATH_H_PPARENT(tb->tb_path, h)) == NULL ||
+            (r = tb->FR[h]) == NULL)
                return 0;
        if (f == r)
diff --git a/fs/reiserfs/lbalance.c b/fs/reiserfs/lbalance.c
index 281f8061ac58..6de060a6aa7f 100644
--- a/fs/reiserfs/lbalance.c
+++ b/fs/reiserfs/lbalance.c
@@ -626,7 +626,7 @@ static void leaf_define_dest_src_infos(int shift_mode, struct tree_balance *tb,
                               "vs-10250: leaf_define_dest_src_infos: shift type is unknown (%d)",
                               shift_mode);
        }
-        RFALSE(src_bi->bi_bh == 0 || dest_bi->bi_bh == 0,
+        RFALSE(!src_bi->bi_bh || !dest_bi->bi_bh,
               "vs-10260: mode==%d, source (%p) or dest (%p) buffer is initialized incorrectly",
               shift_mode, src_bi->bi_bh, dest_bi->bi_bh);
 }
diff --git a/fs/reiserfs/namei.c b/fs/reiserfs/namei.c
index b378eea332ca..8867533cb727 100644
--- a/fs/reiserfs/namei.c
+++ b/fs/reiserfs/namei.c
@@ -452,7 +452,7 @@ static int reiserfs_add_entry(struct reiserfs_transaction_handle *th,
        buflen = DEH_SIZE + ROUND_UP(namelen);
        if (buflen > sizeof(small_buf)) {
                buffer = kmalloc(buflen, GFP_NOFS);
-                if (buffer == 0)
+                if (!buffer)
                        return -ENOMEM;
        } else
                buffer = small_buf;
diff --git a/fs/reiserfs/super.c b/fs/reiserfs/super.c
index 6841452e0dea..393cc22c1717 100644
--- a/fs/reiserfs/super.c
+++ b/fs/reiserfs/super.c
@@ -2031,7 +2031,7 @@ static int reiserfs_quota_on(struct super_block *sb, int type, int format_id,
                return -EXDEV;
        }
        /* We must not pack tails for quota files on reiserfs for quota IO to work */
-        if (!REISERFS_I(nd.path.dentry->d_inode)->i_flags & i_nopack_mask) {
+        if (!(REISERFS_I(nd.path.dentry->d_inode)->i_flags & i_nopack_mask)) {
                reiserfs_warning(sb,
                                 "reiserfs: Quota file must have tail packing disabled.");
                path_put(&nd.path);
diff --git a/fs/reiserfs/xattr.c b/fs/reiserfs/xattr.c
index eba037b3338f..344b9b96cc56 100644
--- a/fs/reiserfs/xattr.c
+++ b/fs/reiserfs/xattr.c
@@ -191,28 +191,11 @@ static struct dentry *get_xa_file_dentry(const struct inode *inode,
        dput(xadir);
        if (err)
                xafile = ERR_PTR(err);
-        return xafile;
-}
-/* Opens a file pointer to the attribute associated with inode */
-static struct file *open_xa_file(const struct inode *inode, const char *name,
-                                 int flags)
-{
-        struct dentry *xafile;
-        struct file *fp;
-        xafile = get_xa_file_dentry(inode, name, flags);
-        if (IS_ERR(xafile))
-                return ERR_PTR(PTR_ERR(xafile));
        else if (!xafile->d_inode) {
                dput(xafile);
-                return ERR_PTR(-ENODATA);
+                xafile = ERR_PTR(-ENODATA);
        }
+        return xafile;
-        fp = dentry_open(xafile, NULL, O_RDWR);
-        /* dentry_open dputs the dentry if it fails */
-        return fp;
 }
 /*
@@ -228,9 +211,8 @@ static struct file *open_xa_file(const struct inode *inode, const char *name,
 * we're called with i_mutex held, so there are no worries about the directory
 * changing underneath us.
 */
-static int __xattr_readdir(struct file *filp, void *dirent, filldir_t filldir)
+static int __xattr_readdir(struct inode *inode, void *dirent, filldir_t filldir)
 {
-        struct inode *inode = filp->f_path.dentry->d_inode;
        struct cpu_key pos_key; /* key of current position in the directory (key of directory entry) */
        INITIALIZE_PATH(path_to_entry);
        struct buffer_head *bh;
@@ -374,23 +356,16 @@ static int __xattr_readdir(struct file *filp, void *dirent, filldir_t filldir)
 *
 */
 static
-int xattr_readdir(struct file *file, filldir_t filler, void *buf)
+int xattr_readdir(struct inode *inode, filldir_t filler, void *buf)
 {
-        struct inode *inode = file->f_path.dentry->d_inode;
+        int res = -ENOENT;
-        int res = -ENOTDIR;
-        if (!file->f_op || !file->f_op->readdir)
-                goto out;
        mutex_lock_nested(&inode->i_mutex, I_MUTEX_XATTR);
-//        down(&inode->i_zombie);
-        res = -ENOENT;
        if (!IS_DEADDIR(inode)) {
                lock_kernel();
-                res = __xattr_readdir(file, buf, filler);
+                res = __xattr_readdir(inode, buf, filler);
                unlock_kernel();
        }
-//        up(&inode->i_zombie);
        mutex_unlock(&inode->i_mutex);
-      out:
        return res;
 }
@@ -442,7 +417,7 @@ reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
                   size_t buffer_size, int flags)
 {
        int err = 0;
-        struct file *fp;
+        struct dentry *dentry;
        struct page *page;
        char *data;
        struct address_space *mapping;
@@ -460,18 +435,18 @@ reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
                xahash = xattr_hash(buffer, buffer_size);
      open_file:
-        fp = open_xa_file(inode, name, flags);
+        dentry = get_xa_file_dentry(inode, name, flags);
-        if (IS_ERR(fp)) {
+        if (IS_ERR(dentry)) {
-                err = PTR_ERR(fp);
+                err = PTR_ERR(dentry);
                goto out;
        }
-        xinode = fp->f_path.dentry->d_inode;
+        xinode = dentry->d_inode;
        REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
        /* we need to copy it off.. */
        if (xinode->i_nlink > 1) {
-                fput(fp);
+                dput(dentry);
                err = reiserfs_xattr_del(inode, name);
                if (err < 0)
                        goto out;
@@ -485,7 +460,7 @@ reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
        newattrs.ia_size = buffer_size;
        newattrs.ia_valid = ATTR_SIZE | ATTR_CTIME;
        mutex_lock_nested(&xinode->i_mutex, I_MUTEX_XATTR);
-        err = notify_change(fp->f_path.dentry, &newattrs);
+        err = notify_change(dentry, &newattrs);
        if (err)
                goto out_filp;
@@ -518,15 +493,14 @@ reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
                        rxh->h_hash = cpu_to_le32(xahash);
                }
-                err = reiserfs_prepare_write(fp, page, page_offset,
+                err = reiserfs_prepare_write(NULL, page, page_offset,
                                            page_offset + chunk + skip);
                if (!err) {
                        if (buffer)
                                memcpy(data + skip, buffer + buffer_pos, chunk);
-                        err =
+                        err = reiserfs_commit_write(NULL, page, page_offset,
-                            reiserfs_commit_write(fp, page, page_offset,
+                                                    page_offset + chunk +
-                                                  page_offset + chunk +
+                                                    skip);
-                                                  skip);
                }
                unlock_page(page);
                reiserfs_put_page(page);
@@ -548,7 +522,7 @@ reiserfs_xattr_set(struct inode *inode, const char *name, const void *buffer,
      out_filp:
        mutex_unlock(&xinode->i_mutex);
-        fput(fp);
+        dput(dentry);
      out:
        return err;
@@ -562,7 +536,7 @@ reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
                   size_t buffer_size)
 {
        ssize_t err = 0;
-        struct file *fp;
+        struct dentry *dentry;
        size_t isize;
        size_t file_pos = 0;
        size_t buffer_pos = 0;
@@ -578,13 +552,13 @@ reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
        if (get_inode_sd_version(inode) == STAT_DATA_V1)
                return -EOPNOTSUPP;
-        fp = open_xa_file(inode, name, FL_READONLY);
+        dentry = get_xa_file_dentry(inode, name, FL_READONLY);
-        if (IS_ERR(fp)) {
+        if (IS_ERR(dentry)) {
-                err = PTR_ERR(fp);
+                err = PTR_ERR(dentry);
                goto out;
        }
-        xinode = fp->f_path.dentry->d_inode;
+        xinode = dentry->d_inode;
        isize = xinode->i_size;
        REISERFS_I(inode)->i_flags |= i_has_xattr_dir;
@@ -652,7 +626,7 @@ reiserfs_xattr_get(const struct inode *inode, const char *name, void *buffer,
        }
      out_dput:
-        fput(fp);
+        dput(dentry);
      out:
        return err;
@@ -742,7 +716,6 @@ reiserfs_delete_xattrs_filler(void *buf, const char *name, int namelen,
 /* This is called w/ inode->i_mutex downed */
 int reiserfs_delete_xattrs(struct inode *inode)
 {
-        struct file *fp;
        struct dentry *dir, *root;
        int err = 0;
@@ -763,15 +736,8 @@ int reiserfs_delete_xattrs(struct inode *inode)
                return 0;
        }
-        fp = dentry_open(dir, NULL, O_RDWR);
-        if (IS_ERR(fp)) {
-                err = PTR_ERR(fp);
-                /* dentry_open dputs the dentry if it fails */
-                goto out;
-        }
        lock_kernel();
-        err = xattr_readdir(fp, reiserfs_delete_xattrs_filler, dir);
+        err = xattr_readdir(dir->d_inode, reiserfs_delete_xattrs_filler, dir);
        if (err) {
                unlock_kernel();
                goto out_dir;
@@ -791,7 +757,7 @@ int reiserfs_delete_xattrs(struct inode *inode)
        unlock_kernel();
      out_dir:
-        fput(fp);
+        dput(dir);
      out:
        if (!err)
@@ -833,7 +799,6 @@ reiserfs_chown_xattrs_filler(void *buf, const char *name, int namelen,
 int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
 {
-        struct file *fp;
        struct dentry *dir;
        int err = 0;
        struct reiserfs_chown_buf buf;
@@ -857,13 +822,6 @@ int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
                goto out;
        }
-        fp = dentry_open(dir, NULL, O_RDWR);
-        if (IS_ERR(fp)) {
-                err = PTR_ERR(fp);
-                /* dentry_open dputs the dentry if it fails */
-                goto out;
-        }
        lock_kernel();
        attrs->ia_valid &= (ATTR_UID | ATTR_GID | ATTR_CTIME);
@@ -871,7 +829,7 @@ int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
        buf.attrs = attrs;
        buf.inode = inode;
-        err = xattr_readdir(fp, reiserfs_chown_xattrs_filler, &buf);
+        err = xattr_readdir(dir->d_inode, reiserfs_chown_xattrs_filler, &buf);
        if (err) {
                unlock_kernel();
                goto out_dir;
@@ -881,7 +839,7 @@ int reiserfs_chown_xattrs(struct inode *inode, struct iattr *attrs)
        unlock_kernel();
      out_dir:
-        fput(fp);
+        dput(dir);
      out:
        attrs->ia_valid = ia_valid;
@@ -1029,7 +987,6 @@ reiserfs_listxattr_filler(void *buf, const char *name, int namelen,
 */
 ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
 {
-        struct file *fp;
        struct dentry *dir;
        int err = 0;
        struct reiserfs_listxattr_buf buf;
@@ -1052,13 +1009,6 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
                goto out;
        }
-        fp = dentry_open(dir, NULL, O_RDWR);
-        if (IS_ERR(fp)) {
-                err = PTR_ERR(fp);
-                /* dentry_open dputs the dentry if it fails */
-                goto out;
-        }
        buf.r_buf = buffer;
        buf.r_size = buffer ? size : 0;
        buf.r_pos = 0;
@@ -1066,7 +1016,7 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
        REISERFS_I(dentry->d_inode)->i_flags |= i_has_xattr_dir;
-        err = xattr_readdir(fp, reiserfs_listxattr_filler, &buf);
+        err = xattr_readdir(dir->d_inode, reiserfs_listxattr_filler, &buf);
        if (err)
                goto out_dir;
@@ -1076,7 +1026,7 @@ ssize_t reiserfs_listxattr(struct dentry * dentry, char *buffer, size_t size)
                err = buf.r_pos;
      out_dir:
-        fput(fp);
+        dput(dir);
      out:
        reiserfs_read_unlock_xattr_i(dentry->d_inode);
diff --git a/fs/romfs/inode.c b/fs/romfs/inode.c
index 00b6f0a518c8..3f13d491c7c7 100644
--- a/fs/romfs/inode.c
+++ b/fs/romfs/inode.c
@@ -340,8 +340,9 @@ static struct dentry *
 romfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
 {
        unsigned long offset, maxoff;
-        int fslen, res;
+        long res;
-        struct inode *inode;
+        int fslen;
+        struct inode *inode = NULL;
        char fsname[ROMFS_MAXFN];       /* XXX dynamic? */
        struct romfs_inode ri;
        const char *name;               /* got from dentry */
@@ -351,7 +352,7 @@ romfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
        offset = dir->i_ino & ROMFH_MASK;
        lock_kernel();
        if (romfs_copyfrom(dir, &ri, offset, ROMFH_SIZE) <= 0)
-                goto out;
+                goto error;
        maxoff = romfs_maxsize(dir->i_sb);
        offset = be32_to_cpu(ri.spec) & ROMFH_MASK;
@@ -364,9 +365,9 @@ romfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
        for(;;) {
                if (!offset || offset >= maxoff)
-                        goto out0;
+                        goto success; /* negative success */
                if (romfs_copyfrom(dir, &ri, offset, ROMFH_SIZE) <= 0)
-                        goto out;
+                        goto error;
                /* try to match the first 16 bytes of name */
                fslen = romfs_strnlen(dir, offset+ROMFH_SIZE, ROMFH_SIZE);
@@ -397,23 +398,14 @@ romfs_lookup(struct inode *dir, struct dentry *dentry, struct nameidata *nd)
        inode = romfs_iget(dir->i_sb, offset);
        if (IS_ERR(inode)) {
                res = PTR_ERR(inode);
-                goto out;
+                goto error;
        }
-        /*
+success:
-         * it's a bit funky, _lookup needs to return an error code
+        d_add(dentry, inode);
-         * (negative) or a NULL, both as a dentry.  ENOENT should not
-         * be returned, instead we need to create a negative dentry by
-         * d_add(dentry, NULL); and return 0 as no error.
-         * (Although as I see, it only matters on writable file
-         * systems).
-         */
-out0:   inode = NULL;
        res = 0;
-        d_add (dentry, inode);
+error:
+        unlock_kernel();
-out:    unlock_kernel();
        return ERR_PTR(res);
 }
diff --git a/fs/signalfd.c b/fs/signalfd.c
index cb2b63ae0bf4..8ead0db35933 100644
--- a/fs/signalfd.c
+++ b/fs/signalfd.c
@@ -111,9 +111,14 @@ static int signalfd_copyinfo(struct signalfd_siginfo __user *uinfo,
                err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
                err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
                break;
-        default: /* this is just in case for now ... */
+        default:
+                /*
+                 * This case catches also the signals queued by sigqueue().
+                 */
                err |= __put_user(kinfo->si_pid, &uinfo->ssi_pid);
                err |= __put_user(kinfo->si_uid, &uinfo->ssi_uid);
+                err |= __put_user((long) kinfo->si_ptr, &uinfo->ssi_ptr);
+                err |= __put_user(kinfo->si_int, &uinfo->ssi_int);
                break;
        }
diff --git a/fs/smbfs/smbiod.c b/fs/smbfs/smbiod.c
index fae8e85af0ed..6bd9b691a463 100644
--- a/fs/smbfs/smbiod.c
+++ b/fs/smbfs/smbiod.c
@@ -206,7 +206,7 @@ int smbiod_retry(struct smb_sb_info *server)
        smb_close_socket(server);
-        if (pid == 0) {
+        if (!pid) {
                /* FIXME: this is fatal, umount? */
                printk(KERN_ERR "smb_retry: no connection process\n");
                server->state = CONN_RETRIED;
diff --git a/fs/splice.c b/fs/splice.c
index 9b559ee711a8..eeb1a86a7014 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -320,7 +320,7 @@ __generic_file_splice_read(struct file *in, loff_t *ppos,
                                break;
                        error = add_to_page_cache_lru(page, mapping, index,
-                                              GFP_KERNEL);
+                                                mapping_gfp_mask(mapping));
                        if (unlikely(error)) {
                                page_cache_release(page);
                                if (error == -EEXIST)
@@ -370,8 +370,10 @@ __generic_file_splice_read(struct file *in, loff_t *ppos,
                         * for an in-flight io page
                         */
                        if (flags & SPLICE_F_NONBLOCK) {
-                                if (TestSetPageLocked(page))
+                                if (TestSetPageLocked(page)) {
+                                        error = -EAGAIN;
                                        break;
+                                }
                        } else
                                lock_page(page);
@@ -479,9 +481,8 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
                                 struct pipe_inode_info *pipe, size_t len,
                                 unsigned int flags)
 {
-        ssize_t spliced;
-        int ret;
        loff_t isize, left;
+        int ret;
        isize = i_size_read(in->f_mapping->host);
        if (unlikely(*ppos >= isize))
@@ -491,29 +492,9 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
        if (unlikely(left < len))
                len = left;
-        ret = 0;
+        ret = __generic_file_splice_read(in, ppos, pipe, len, flags);
-        spliced = 0;
+        if (ret > 0)
-        while (len && !spliced) {
-                ret = __generic_file_splice_read(in, ppos, pipe, len, flags);
-                if (ret < 0)
-                        break;
-                else if (!ret) {
-                        if (spliced)
-                                break;
-                        if (flags & SPLICE_F_NONBLOCK) {
-                                ret = -EAGAIN;
-                                break;
-                        }
-                }
                *ppos += ret;
-                len -= ret;
-                spliced += ret;
-        }
-        if (spliced)
-                return spliced;
        return ret;
 }
@@ -1669,6 +1650,13 @@ static int link_pipe(struct pipe_inode_info *ipipe,
                i++;
        } while (len);
+        /*
+         * return EAGAIN if we have the potential of some data in the
+         * future, otherwise just return 0
+         */
+        if (!ret && ipipe->waiting_writers && (flags & SPLICE_F_NONBLOCK))
+                ret = -EAGAIN;
        inode_double_unlock(ipipe->inode, opipe->inode);
        /*
@@ -1709,11 +1697,8 @@ static long do_tee(struct file *in, struct file *out, size_t len,
                ret = link_ipipe_prep(ipipe, flags);
                if (!ret) {
                        ret = link_opipe_prep(opipe, flags);
-                        if (!ret) {
+                        if (!ret)
                                ret = link_pipe(ipipe, opipe, len, flags);
-                                if (!ret && (flags & SPLICE_F_NONBLOCK))
-                                        ret = -EAGAIN;
-                        }
                }
        }
diff --git a/fs/super.c b/fs/super.c
index 88811f60c8de..09008dbd264e 100644
--- a/fs/super.c
+++ b/fs/super.c
@@ -556,11 +556,11 @@ out:
 }
 /**
- *      mark_files_ro
+ *      mark_files_ro - mark all files read-only
 *      @sb: superblock in question
 *
- *      All files are marked read/only.  We don't care about pending
+ *      All files are marked read-only.  We don't care about pending
- *      delete files so this should be used in 'force' mode only
+ *      delete files so this should be used in 'force' mode only.
 */
 static void mark_files_ro(struct super_block *sb)
@@ -870,12 +870,12 @@ vfs_kern_mount(struct file_system_type *type, int flags, const char *name, void
        if (!mnt)
                goto out;
-        if (data) {
+        if (data && !(type->fs_flags & FS_BINARY_MOUNTDATA)) {
                secdata = alloc_secdata();
                if (!secdata)
                        goto out_mnt;
-                error = security_sb_copy_data(type, data, secdata);
+                error = security_sb_copy_data(data, secdata);
                if (error)
                        goto out_free_secdata;
        }
@@ -945,6 +945,7 @@ do_kern_mount(const char *fstype, int flags, const char *name, void *data)
        put_filesystem(type);
        return mnt;
 }
+EXPORT_SYMBOL_GPL(do_kern_mount);
 struct vfsmount *kern_mount_data(struct file_system_type *type, void *data)
 {
diff --git a/fs/sysfs/file.c b/fs/sysfs/file.c
index a271c87c4472..baa663e69388 100644
--- a/fs/sysfs/file.c
+++ b/fs/sysfs/file.c
@@ -12,6 +12,7 @@
 #include <linux/module.h>
 #include <linux/kobject.h>
+#include <linux/kallsyms.h>
 #include <linux/namei.h>
 #include <linux/poll.h>
 #include <linux/list.h>
@@ -86,7 +87,12 @@ static int fill_read_buffer(struct dentry * dentry, struct sysfs_buffer * buffer
         * The code works fine with PAGE_SIZE return but it's likely to
         * indicate truncated result or overflow in normal use cases.
         */
-        BUG_ON(count >= (ssize_t)PAGE_SIZE);
+        if (count >= (ssize_t)PAGE_SIZE) {
+                print_symbol("fill_read_buffer: %s returned bad count\n",
+                        (unsigned long)ops->show);
+                /* Try to struggle along */
+                count = PAGE_SIZE - 1;
+        }
        if (count >= 0) {
                buffer->needs_read_fill = 0;
                buffer->count = count;
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 1fca381f0ce2..1e7598fb9787 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -315,8 +315,8 @@ static void ufs_change_blocknr(struct inode *inode, sector_t beg,
                        }
                        UFSD(" change from %llu to %llu, pos %u\n",
-                             (unsigned long long)pos + oldb,
+                             (unsigned long long)(pos + oldb),
-                             (unsigned long long)pos + newb, pos);
+                             (unsigned long long)(pos + newb), pos);
                        bh->b_blocknr = newb + pos;
                        unmap_underlying_metadata(bh->b_bdev,
diff --git a/fs/ufs/util.h b/fs/ufs/util.h
index b26fc4dec1e7..23ceed8c8fb9 100644
--- a/fs/ufs/util.h
+++ b/fs/ufs/util.h
@@ -58,7 +58,7 @@ ufs_set_fs_state(struct super_block *sb, struct ufs_super_block_first *usb1,
 {
        switch (UFS_SB(sb)->s_flags & UFS_ST_MASK) {
        case UFS_ST_SUNOS:
-                if (fs32_to_cpu(sb, usb3->fs_postblformat == UFS_42POSTBLFMT)) {
+                if (fs32_to_cpu(sb, usb3->fs_postblformat) == UFS_42POSTBLFMT) {
                        usb1->fs_u0.fs_sun.fs_state = cpu_to_fs32(sb, value);
                        break;
                }
diff --git a/fs/xfs/Makefile-linux-2.6 b/fs/xfs/Makefile-linux-2.6
deleted file mode 100644
index e69de29bb2d1..000000000000
--- a/fs/xfs/Makefile-linux-2.6
+++ /dev/null
diff --git a/fs/xfs/linux-2.6/xfs_ioctl.c b/fs/xfs/linux-2.6/xfs_ioctl.c
index a9952e490ac9..f34bd010eb51 100644
--- a/fs/xfs/linux-2.6/xfs_ioctl.c
+++ b/fs/xfs/linux-2.6/xfs_ioctl.c
@@ -732,7 +732,7 @@ xfs_ioctl(
                 * Only allow the sys admin to reserve space unless
                 * unwritten extents are enabled.
                 */
-                if (!XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb) &&
+                if (!xfs_sb_version_hasextflgbit(&mp->m_sb) &&
                    !capable(CAP_SYS_ADMIN))
                        return -EPERM;
diff --git a/fs/xfs/linux-2.6/xfs_super.c b/fs/xfs/linux-2.6/xfs_super.c
index 21dfc9da235e..8831d9518790 100644
--- a/fs/xfs/linux-2.6/xfs_super.c
+++ b/fs/xfs/linux-2.6/xfs_super.c
@@ -171,7 +171,7 @@ xfs_parseargs(
        char                    *this_char, *value, *eov;
        int                     dsunit, dswidth, vol_dsunit, vol_dswidth;
        int                     iosize;
-        int                     ikeep = 0;
+        int                     dmapi_implies_ikeep = 1;
        args->flags |= XFSMNT_BARRIER;
        args->flags2 |= XFSMNT2_COMPAT_IOSIZE;
@@ -302,10 +302,10 @@ xfs_parseargs(
                } else if (!strcmp(this_char, MNTOPT_NOBARRIER)) {
                        args->flags &= ~XFSMNT_BARRIER;
                } else if (!strcmp(this_char, MNTOPT_IKEEP)) {
-                        ikeep = 1;
+                        args->flags |= XFSMNT_IKEEP;
-                        args->flags &= ~XFSMNT_IDELETE;
                } else if (!strcmp(this_char, MNTOPT_NOIKEEP)) {
-                        args->flags |= XFSMNT_IDELETE;
+                        dmapi_implies_ikeep = 0;
+                        args->flags &= ~XFSMNT_IKEEP;
                } else if (!strcmp(this_char, MNTOPT_LARGEIO)) {
                        args->flags2 &= ~XFSMNT2_COMPAT_IOSIZE;
                } else if (!strcmp(this_char, MNTOPT_NOLARGEIO)) {
@@ -410,8 +410,8 @@ xfs_parseargs(
         * Note that if "ikeep" or "noikeep" mount options are
         * supplied, then they are honored.
         */
-        if (!(args->flags & XFSMNT_DMAPI) && !ikeep)
+        if ((args->flags & XFSMNT_DMAPI) && dmapi_implies_ikeep)
-                args->flags |= XFSMNT_IDELETE;
+                args->flags |= XFSMNT_IKEEP;
        if ((args->flags & XFSMNT_NOALIGN) != XFSMNT_NOALIGN) {
                if (dsunit) {
@@ -446,6 +446,7 @@ xfs_showargs(
 {
        static struct proc_xfs_info xfs_info_set[] = {
                /* the few simple ones we can get from the mount struct */
+                { XFS_MOUNT_IKEEP,              "," MNTOPT_IKEEP },
                { XFS_MOUNT_WSYNC,              "," MNTOPT_WSYNC },
                { XFS_MOUNT_INO64,              "," MNTOPT_INO64 },
                { XFS_MOUNT_NOALIGN,            "," MNTOPT_NOALIGN },
@@ -461,7 +462,6 @@ xfs_showargs(
        };
        static struct proc_xfs_info xfs_info_unset[] = {
                /* the few simple ones we can get from the mount struct */
-                { XFS_MOUNT_IDELETE,            "," MNTOPT_IKEEP },
                { XFS_MOUNT_COMPAT_IOSIZE,      "," MNTOPT_LARGEIO },
                { XFS_MOUNT_BARRIER,            "," MNTOPT_NOBARRIER },
                { XFS_MOUNT_SMALL_INUMS,        "," MNTOPT_64BITINODE },
diff --git a/fs/xfs/quota/xfs_qm.c b/fs/xfs/quota/xfs_qm.c
index 1f3da5b8657b..8e9c5ae6504d 100644
--- a/fs/xfs/quota/xfs_qm.c
+++ b/fs/xfs/quota/xfs_qm.c
@@ -1405,13 +1405,13 @@ xfs_qm_qino_alloc(
 #if defined(DEBUG) && defined(XFS_LOUD_RECOVERY)
                unsigned oldv = mp->m_sb.sb_versionnum;
 #endif
-                ASSERT(!XFS_SB_VERSION_HASQUOTA(&mp->m_sb));
+                ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
                ASSERT((sbfields & (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
                                   XFS_SB_GQUOTINO | XFS_SB_QFLAGS)) ==
                       (XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO |
                        XFS_SB_GQUOTINO | XFS_SB_QFLAGS));
-                XFS_SB_VERSION_ADDQUOTA(&mp->m_sb);
+                xfs_sb_version_addquota(&mp->m_sb);
                mp->m_sb.sb_uquotino = NULLFSINO;
                mp->m_sb.sb_gquotino = NULLFSINO;
@@ -1954,7 +1954,7 @@ xfs_qm_init_quotainos(
        /*
         * Get the uquota and gquota inodes
         */
-        if (XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
+        if (xfs_sb_version_hasquota(&mp->m_sb)) {
                if (XFS_IS_UQUOTA_ON(mp) &&
                    mp->m_sb.sb_uquotino != NULLFSINO) {
                        ASSERT(mp->m_sb.sb_uquotino > 0);
diff --git a/fs/xfs/quota/xfs_qm_bhv.c b/fs/xfs/quota/xfs_qm_bhv.c
index 97bb32937585..f4f6c4c861d7 100644
--- a/fs/xfs/quota/xfs_qm_bhv.c
+++ b/fs/xfs/quota/xfs_qm_bhv.c
@@ -118,7 +118,7 @@ xfs_qm_newmount(
        *quotaflags = 0;
        *needquotamount = B_FALSE;
-        quotaondisk = XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
+        quotaondisk = xfs_sb_version_hasquota(&mp->m_sb) &&
                                (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_ACCT);
        if (quotaondisk) {
diff --git a/fs/xfs/quota/xfs_qm_syscalls.c b/fs/xfs/quota/xfs_qm_syscalls.c
index 2cc5886cfe85..d2b8be7e75f9 100644
--- a/fs/xfs/quota/xfs_qm_syscalls.c
+++ b/fs/xfs/quota/xfs_qm_syscalls.c
@@ -377,7 +377,7 @@ xfs_qm_scall_trunc_qfiles(
        if (!capable(CAP_SYS_ADMIN))
                return XFS_ERROR(EPERM);
        error = 0;
-        if (!XFS_SB_VERSION_HASQUOTA(&mp->m_sb) || flags == 0) {
+        if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0) {
                qdprintk("qtrunc flags=%x m_qflags=%x\n", flags, mp->m_qflags);
                return XFS_ERROR(EINVAL);
        }
@@ -522,7 +522,7 @@ xfs_qm_scall_getqstat(
        memset(out, 0, sizeof(fs_quota_stat_t));
        out->qs_version = FS_QSTAT_VERSION;
-        if (! XFS_SB_VERSION_HASQUOTA(&mp->m_sb)) {
+        if (!xfs_sb_version_hasquota(&mp->m_sb)) {
                out->qs_uquota.qfs_ino = NULLFSINO;
                out->qs_gquota.qfs_ino = NULLFSINO;
                return (0);
diff --git a/fs/xfs/xfs_attr_leaf.c b/fs/xfs/xfs_attr_leaf.c
index b08e2a2a8add..96ba6aa4ed8c 100644
--- a/fs/xfs/xfs_attr_leaf.c
+++ b/fs/xfs/xfs_attr_leaf.c
@@ -227,10 +227,10 @@ STATIC void
 xfs_sbversion_add_attr2(xfs_mount_t *mp, xfs_trans_t *tp)
 {
        if ((mp->m_flags & XFS_MOUNT_ATTR2) &&
-            !(XFS_SB_VERSION_HASATTR2(&mp->m_sb))) {
+            !(xfs_sb_version_hasattr2(&mp->m_sb))) {
                spin_lock(&mp->m_sb_lock);
-                if (!XFS_SB_VERSION_HASATTR2(&mp->m_sb)) {
+                if (!xfs_sb_version_hasattr2(&mp->m_sb)) {
-                        XFS_SB_VERSION_ADDATTR2(&mp->m_sb);
+                        xfs_sb_version_addattr2(&mp->m_sb);
                        spin_unlock(&mp->m_sb_lock);
                        xfs_mod_sb(tp, XFS_SB_VERSIONNUM | XFS_SB_FEATURES2);
                } else
diff --git a/fs/xfs/xfs_bit.c b/fs/xfs/xfs_bit.c
index 48228848f5ae..fab0b6d5a41b 100644
--- a/fs/xfs/xfs_bit.c
+++ b/fs/xfs/xfs_bit.c
@@ -25,6 +25,109 @@
 * XFS bit manipulation routines, used in non-realtime code.
 */
+#ifndef HAVE_ARCH_HIGHBIT
+/*
+ * Index of high bit number in byte, -1 for none set, 0..7 otherwise.
+ */
+static const char xfs_highbit[256] = {
+       -1, 0, 1, 1, 2, 2, 2, 2,                 /* 00 .. 07 */
+        3, 3, 3, 3, 3, 3, 3, 3,                 /* 08 .. 0f */
+        4, 4, 4, 4, 4, 4, 4, 4,                 /* 10 .. 17 */
+        4, 4, 4, 4, 4, 4, 4, 4,                 /* 18 .. 1f */
+        5, 5, 5, 5, 5, 5, 5, 5,                 /* 20 .. 27 */
+        5, 5, 5, 5, 5, 5, 5, 5,                 /* 28 .. 2f */
+        5, 5, 5, 5, 5, 5, 5, 5,                 /* 30 .. 37 */
+        5, 5, 5, 5, 5, 5, 5, 5,                 /* 38 .. 3f */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 40 .. 47 */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 48 .. 4f */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 50 .. 57 */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 58 .. 5f */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 60 .. 67 */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 68 .. 6f */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 70 .. 77 */
+        6, 6, 6, 6, 6, 6, 6, 6,                 /* 78 .. 7f */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* 80 .. 87 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* 88 .. 8f */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* 90 .. 97 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* 98 .. 9f */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* a0 .. a7 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* a8 .. af */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* b0 .. b7 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* b8 .. bf */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* c0 .. c7 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* c8 .. cf */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* d0 .. d7 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* d8 .. df */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* e0 .. e7 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* e8 .. ef */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* f0 .. f7 */
+        7, 7, 7, 7, 7, 7, 7, 7,                 /* f8 .. ff */
+};
+#endif
+/*
+ * xfs_highbit32: get high bit set out of 32-bit argument, -1 if none set.
+ */
+inline int
+xfs_highbit32(
+        __uint32_t      v)
+{
+#ifdef HAVE_ARCH_HIGHBIT
+        return highbit32(v);
+#else
+        int             i;
+        if (v & 0xffff0000)
+                if (v & 0xff000000)
+                        i = 24;
+                else
+                        i = 16;
+        else if (v & 0x0000ffff)
+                if (v & 0x0000ff00)
+                        i = 8;
+                else
+                        i = 0;
+        else
+                return -1;
+        return i + xfs_highbit[(v >> i) & 0xff];
+#endif
+}
+/*
+ * xfs_lowbit64: get low bit set out of 64-bit argument, -1 if none set.
+ */
+int
+xfs_lowbit64(
+        __uint64_t      v)
+{
+        __uint32_t      w = (__uint32_t)v;
+        int             n = 0;
+        if (w) {        /* lower bits */
+                n = ffs(w);
+        } else {        /* upper bits */
+                w = (__uint32_t)(v >> 32);
+                if (w && (n = ffs(w)))
+                        n += 32;
+        }
+        return n - 1;
+}
+/*
+ * xfs_highbit64: get high bit set out of 64-bit argument, -1 if none set.
+ */
+int
+xfs_highbit64(
+        __uint64_t      v)
+{
+        __uint32_t      h = (__uint32_t)(v >> 32);
+        if (h)
+                return xfs_highbit32(h) + 32;
+        return xfs_highbit32((__uint32_t)v);
+}
 /*
 * Return whether bitmap is empty.
 * Size is number of words in the bitmap, which is padded to word boundary
diff --git a/fs/xfs/xfs_bit.h b/fs/xfs/xfs_bit.h
index 325a007dec91..082641a9782c 100644
--- a/fs/xfs/xfs_bit.h
+++ b/fs/xfs/xfs_bit.h
@@ -47,30 +47,13 @@ static inline __uint64_t xfs_mask64lo(int n)
 }
 /* Get high bit set out of 32-bit argument, -1 if none set */
-static inline int xfs_highbit32(__uint32_t v)
+extern int xfs_highbit32(__uint32_t v);
-{
-        return fls(v) - 1;
-}
-/* Get high bit set out of 64-bit argument, -1 if none set */
-static inline int xfs_highbit64(__uint64_t v)
-{
-        return fls64(v) - 1;
-}
-/* Get low bit set out of 32-bit argument, -1 if none set */
-static inline int xfs_lowbit32(__uint32_t v)
-{
-        __uint32_t t = v;
-        return (t) ? find_first_bit((unsigned long *)&t, 32) : -1;
-}
 /* Get low bit set out of 64-bit argument, -1 if none set */
-static inline int xfs_lowbit64(__uint64_t v)
+extern int xfs_lowbit64(__uint64_t v);
-{
-        __uint64_t t = v;
+/* Get high bit set out of 64-bit argument, -1 if none set */
-        return (t) ? find_first_bit((unsigned long *)&t, 64) : -1;
+extern int xfs_highbit64(__uint64_t);
-}
 /* Return whether bitmap is empty (1 == empty) */
 extern int xfs_bitmap_empty(uint *map, uint size);
diff --git a/fs/xfs/xfs_bmap.c b/fs/xfs/xfs_bmap.c
index 1c0a5a585a82..2def273855a2 100644
--- a/fs/xfs/xfs_bmap.c
+++ b/fs/xfs/xfs_bmap.c
@@ -4047,17 +4047,17 @@ xfs_bmap_add_attrfork(
                xfs_trans_log_inode(tp, ip, logflags);
        if (error)
                goto error2;
-        if (!XFS_SB_VERSION_HASATTR(&mp->m_sb) ||
+        if (!xfs_sb_version_hasattr(&mp->m_sb) ||
-           (!XFS_SB_VERSION_HASATTR2(&mp->m_sb) && version == 2)) {
+           (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2)) {
                __int64_t sbfields = 0;
                spin_lock(&mp->m_sb_lock);
-                if (!XFS_SB_VERSION_HASATTR(&mp->m_sb)) {
+                if (!xfs_sb_version_hasattr(&mp->m_sb)) {
-                        XFS_SB_VERSION_ADDATTR(&mp->m_sb);
+                        xfs_sb_version_addattr(&mp->m_sb);
                        sbfields |= XFS_SB_VERSIONNUM;
                }
-                if (!XFS_SB_VERSION_HASATTR2(&mp->m_sb) && version == 2) {
+                if (!xfs_sb_version_hasattr2(&mp->m_sb) && version == 2) {
-                        XFS_SB_VERSION_ADDATTR2(&mp->m_sb);
+                        xfs_sb_version_addattr2(&mp->m_sb);
                        sbfields |= (XFS_SB_VERSIONNUM | XFS_SB_FEATURES2);
                }
                if (sbfields) {
@@ -5043,7 +5043,7 @@ xfs_bmapi(
                         * A wasdelay extent has been initialized, so
                         * shouldn't be flagged as unwritten.
                         */
-                        if (wr && XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
+                        if (wr && xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                                if (!wasdelay && (flags & XFS_BMAPI_PREALLOC))
                                        got.br_state = XFS_EXT_UNWRITTEN;
                        }
@@ -5483,7 +5483,7 @@ xfs_bunmapi(
                         * get rid of part of a realtime extent.
                         */
                        if (del.br_state == XFS_EXT_UNWRITTEN ||
-                            !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
+                            !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                                /*
                                 * This piece is unwritten, or we're not
                                 * using unwritten extents.  Skip over it.
@@ -5535,7 +5535,7 @@ xfs_bunmapi(
                        } else if ((del.br_startoff == start &&
                                    (del.br_state == XFS_EXT_UNWRITTEN ||
                                     xfs_trans_get_block_res(tp) == 0)) ||
-                                   !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
+                                   !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                                /*
                                 * Can't make it unwritten.  There isn't
                                 * a full extent here so just skip it.
diff --git a/fs/xfs/xfs_bmap_btree.h b/fs/xfs/xfs_bmap_btree.h
index 2d950e975918..cd0d4b4bb816 100644
--- a/fs/xfs/xfs_bmap_btree.h
+++ b/fs/xfs/xfs_bmap_btree.h
@@ -120,7 +120,7 @@ typedef enum {
 * Extent state and extent format macros.
 */
 #define XFS_EXTFMT_INODE(x)     \
-        (XFS_SB_VERSION_HASEXTFLGBIT(&((x)->i_mount->m_sb)) ? \
+        (xfs_sb_version_hasextflgbit(&((x)->i_mount->m_sb)) ? \
                XFS_EXTFMT_HASSTATE : XFS_EXTFMT_NOSTATE)
 #define ISUNWRITTEN(x)  ((x)->br_state == XFS_EXT_UNWRITTEN)
diff --git a/fs/xfs/xfs_clnt.h b/fs/xfs/xfs_clnt.h
index d16c1b971074..d5d1e60ee224 100644
--- a/fs/xfs/xfs_clnt.h
+++ b/fs/xfs/xfs_clnt.h
@@ -86,7 +86,7 @@ struct xfs_mount_args {
 #define XFSMNT_NOUUID           0x01000000      /* Ignore fs uuid */
 #define XFSMNT_DMAPI            0x02000000      /* enable dmapi/xdsm */
 #define XFSMNT_BARRIER          0x04000000      /* use write barriers */
-#define XFSMNT_IDELETE          0x08000000      /* inode cluster delete */
+#define XFSMNT_IKEEP            0x08000000      /* inode cluster delete */
 #define XFSMNT_SWALLOC          0x10000000      /* turn on stripe width
                                                 * allocation */
 #define XFSMNT_DIRSYNC          0x40000000      /* sync creat,link,unlink,rename
diff --git a/fs/xfs/xfs_dir2.c b/fs/xfs/xfs_dir2.c
index be7c4251fa61..e92e73f0e6af 100644
--- a/fs/xfs/xfs_dir2.c
+++ b/fs/xfs/xfs_dir2.c
@@ -49,7 +49,7 @@ void
 xfs_dir_mount(
        xfs_mount_t     *mp)
 {
-        ASSERT(XFS_SB_VERSION_HASDIRV2(&mp->m_sb));
+        ASSERT(xfs_sb_version_hasdirv2(&mp->m_sb));
        ASSERT((1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog)) <=
               XFS_MAX_BLOCKSIZE);
        mp->m_dirblksize = 1 << (mp->m_sb.sb_blocklog + mp->m_sb.sb_dirblklog);
diff --git a/fs/xfs/xfs_fsops.c b/fs/xfs/xfs_fsops.c
index eadc1591c795..d3a0f538d6a6 100644
--- a/fs/xfs/xfs_fsops.c
+++ b/fs/xfs/xfs_fsops.c
@@ -77,36 +77,36 @@ xfs_fs_geometry(
        if (new_version >= 3) {
                geo->version = XFS_FSOP_GEOM_VERSION;
                geo->flags =
-                        (XFS_SB_VERSION_HASATTR(&mp->m_sb) ?
+                        (xfs_sb_version_hasattr(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_ATTR : 0) |
-                        (XFS_SB_VERSION_HASNLINK(&mp->m_sb) ?
+                        (xfs_sb_version_hasnlink(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_NLINK : 0) |
-                        (XFS_SB_VERSION_HASQUOTA(&mp->m_sb) ?
+                        (xfs_sb_version_hasquota(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_QUOTA : 0) |
-                        (XFS_SB_VERSION_HASALIGN(&mp->m_sb) ?
+                        (xfs_sb_version_hasalign(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_IALIGN : 0) |
-                        (XFS_SB_VERSION_HASDALIGN(&mp->m_sb) ?
+                        (xfs_sb_version_hasdalign(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_DALIGN : 0) |
-                        (XFS_SB_VERSION_HASSHARED(&mp->m_sb) ?
+                        (xfs_sb_version_hasshared(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_SHARED : 0) |
-                        (XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb) ?
+                        (xfs_sb_version_hasextflgbit(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_EXTFLG : 0) |
-                        (XFS_SB_VERSION_HASDIRV2(&mp->m_sb) ?
+                        (xfs_sb_version_hasdirv2(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_DIRV2 : 0) |
-                        (XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
+                        (xfs_sb_version_hassector(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_SECTOR : 0) |
                        (xfs_sb_version_haslazysbcount(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_LAZYSB : 0) |
-                        (XFS_SB_VERSION_HASATTR2(&mp->m_sb) ?
+                        (xfs_sb_version_hasattr2(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_ATTR2 : 0);
-                geo->logsectsize = XFS_SB_VERSION_HASSECTOR(&mp->m_sb) ?
+                geo->logsectsize = xfs_sb_version_hassector(&mp->m_sb) ?
                                mp->m_sb.sb_logsectsize : BBSIZE;
                geo->rtsectsize = mp->m_sb.sb_blocksize;
                geo->dirblocksize = mp->m_dirblksize;
        }
        if (new_version >= 4) {
                geo->flags |=
-                        (XFS_SB_VERSION_HASLOGV2(&mp->m_sb) ?
+                        (xfs_sb_version_haslogv2(&mp->m_sb) ?
                                XFS_FSOP_GEOM_FLAGS_LOGV2 : 0);
                geo->logsunit = mp->m_sb.sb_logsunit;
        }
diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index c5836b951d0c..5a146cb22980 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -191,7 +191,7 @@ xfs_ialloc_ag_alloc(
                        ASSERT(!(args.mp->m_flags & XFS_MOUNT_NOALIGN));
                        args.alignment = args.mp->m_dalign;
                        isaligned = 1;
-                } else if (XFS_SB_VERSION_HASALIGN(&args.mp->m_sb) &&
+                } else if (xfs_sb_version_hasalign(&args.mp->m_sb) &&
                           args.mp->m_sb.sb_inoalignmt >=
                           XFS_B_TO_FSBT(args.mp,
                                XFS_INODE_CLUSTER_SIZE(args.mp)))
@@ -230,7 +230,7 @@ xfs_ialloc_ag_alloc(
                args.agbno = be32_to_cpu(agi->agi_root);
                args.fsbno = XFS_AGB_TO_FSB(args.mp,
                                be32_to_cpu(agi->agi_seqno), args.agbno);
-                if (XFS_SB_VERSION_HASALIGN(&args.mp->m_sb) &&
+                if (xfs_sb_version_hasalign(&args.mp->m_sb) &&
                        args.mp->m_sb.sb_inoalignmt >=
                        XFS_B_TO_FSBT(args.mp, XFS_INODE_CLUSTER_SIZE(args.mp)))
                                args.alignment = args.mp->m_sb.sb_inoalignmt;
@@ -271,7 +271,7 @@ xfs_ialloc_ag_alloc(
         * use the old version so that old kernels will continue to be
         * able to use the file system.
         */
-        if (XFS_SB_VERSION_HASNLINK(&args.mp->m_sb))
+        if (xfs_sb_version_hasnlink(&args.mp->m_sb))
                version = XFS_DINODE_VERSION_2;
        else
                version = XFS_DINODE_VERSION_1;
@@ -1053,7 +1053,7 @@ xfs_difree(
        /*
         * When an inode cluster is free, it becomes eligible for removal
         */
-        if ((mp->m_flags & XFS_MOUNT_IDELETE) &&
+        if (!(mp->m_flags & XFS_MOUNT_IKEEP) &&
            (rec.ir_freecount == XFS_IALLOC_INODES(mp))) {
                *delete = 1;
diff --git a/fs/xfs/xfs_iget.c b/fs/xfs/xfs_iget.c
index f01b07687faf..8e09b71f4104 100644
--- a/fs/xfs/xfs_iget.c
+++ b/fs/xfs/xfs_iget.c
@@ -235,6 +235,7 @@ finish_inode:
         */
        new_icl = kmem_zone_alloc(xfs_icluster_zone, KM_SLEEP);
        if (radix_tree_preload(GFP_KERNEL)) {
+                xfs_idestroy(ip);
                delay(1);
                goto again;
        }
diff --git a/fs/xfs/xfs_inode.c b/fs/xfs/xfs_inode.c
index a550546a7083..f43a6e01d68f 100644
--- a/fs/xfs/xfs_inode.c
+++ b/fs/xfs/xfs_inode.c
@@ -1147,7 +1147,7 @@ xfs_ialloc(
         * the inode version number now.  This way we only do the conversion
         * here rather than here and in the flush/logging code.
         */
-        if (XFS_SB_VERSION_HASNLINK(&tp->t_mountp->m_sb) &&
+        if (xfs_sb_version_hasnlink(&tp->t_mountp->m_sb) &&
            ip->i_d.di_version == XFS_DINODE_VERSION_1) {
                ip->i_d.di_version = XFS_DINODE_VERSION_2;
                /*
@@ -3434,9 +3434,9 @@ xfs_iflush_int(
         * has been updated, then make the conversion permanent.
         */
        ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1 ||
-               XFS_SB_VERSION_HASNLINK(&mp->m_sb));
+               xfs_sb_version_hasnlink(&mp->m_sb));
        if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
-                if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) {
+                if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
                        /*
                         * Convert it back.
                         */
diff --git a/fs/xfs/xfs_inode_item.c b/fs/xfs/xfs_inode_item.c
index 034ca7202295..2c775b4ae9e6 100644
--- a/fs/xfs/xfs_inode_item.c
+++ b/fs/xfs/xfs_inode_item.c
@@ -296,9 +296,9 @@ xfs_inode_item_format(
         */
        mp = ip->i_mount;
        ASSERT(ip->i_d.di_version == XFS_DINODE_VERSION_1 ||
-               XFS_SB_VERSION_HASNLINK(&mp->m_sb));
+               xfs_sb_version_hasnlink(&mp->m_sb));
        if (ip->i_d.di_version == XFS_DINODE_VERSION_1) {
-                if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) {
+                if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
                        /*
                         * Convert it back.
                         */
diff --git a/fs/xfs/xfs_itable.c b/fs/xfs/xfs_itable.c
index 658aab6b1bbf..f615e04364f4 100644
--- a/fs/xfs/xfs_itable.c
+++ b/fs/xfs/xfs_itable.c
@@ -45,7 +45,7 @@ xfs_internal_inum(
        xfs_ino_t       ino)
 {
        return (ino == mp->m_sb.sb_rbmino || ino == mp->m_sb.sb_rsumino ||
-                (XFS_SB_VERSION_HASQUOTA(&mp->m_sb) &&
+                (xfs_sb_version_hasquota(&mp->m_sb) &&
                 (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino)));
 }
diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index a75edca1860f..31f2b04f2c97 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -1090,7 +1090,7 @@ xlog_get_iclog_buffer_size(xfs_mount_t	*mp,
                        size >>= 1;
                }
-                if (XFS_SB_VERSION_HASLOGV2(&mp->m_sb)) {
+                if (xfs_sb_version_haslogv2(&mp->m_sb)) {
                        /* # headers = size / 32K
                         * one header holds cycles from 32K of data
                         */
@@ -1186,13 +1186,13 @@ xlog_alloc_log(xfs_mount_t	*mp,
        log->l_grant_reserve_cycle = 1;
        log->l_grant_write_cycle = 1;
-        if (XFS_SB_VERSION_HASSECTOR(&mp->m_sb)) {
+        if (xfs_sb_version_hassector(&mp->m_sb)) {
                log->l_sectbb_log = mp->m_sb.sb_logsectlog - BBSHIFT;
                ASSERT(log->l_sectbb_log <= mp->m_sectbb_log);
                /* for larger sector sizes, must have v2 or external log */
                ASSERT(log->l_sectbb_log == 0 ||
                        log->l_logBBstart == 0 ||
-                        XFS_SB_VERSION_HASLOGV2(&mp->m_sb));
+                        xfs_sb_version_haslogv2(&mp->m_sb));
                ASSERT(mp->m_sb.sb_logsectlog >= BBSHIFT);
        }
        log->l_sectbb_mask = (1 << log->l_sectbb_log) - 1;
@@ -1247,7 +1247,7 @@ xlog_alloc_log(xfs_mount_t	*mp,
                memset(head, 0, sizeof(xlog_rec_header_t));
                head->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
                head->h_version = cpu_to_be32(
-                        XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? 2 : 1);
+                        xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
                head->h_size = cpu_to_be32(log->l_iclog_size);
                /* new fields */
                head->h_fmt = cpu_to_be32(XLOG_FMT);
@@ -1402,7 +1402,7 @@ xlog_sync(xlog_t		*log,
        int             roundoff;       /* roundoff to BB or stripe */
        int             split = 0;      /* split write into two regions */
        int             error;
-        int             v2 = XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb);
+        int             v2 = xfs_sb_version_haslogv2(&log->l_mp->m_sb);
        XFS_STATS_INC(xs_log_writes);
        ASSERT(iclog->ic_refcnt == 0);
@@ -2881,7 +2881,7 @@ xlog_state_switch_iclogs(xlog_t		*log,
        log->l_curr_block += BTOBB(eventual_size)+BTOBB(log->l_iclog_hsize);
        /* Round up to next log-sunit */
-        if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) &&
+        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
            log->l_mp->m_sb.sb_logsunit > 1) {
                __uint32_t sunit_bb = BTOBB(log->l_mp->m_sb.sb_logsunit);
                log->l_curr_block = roundup(log->l_curr_block, sunit_bb);
@@ -3334,7 +3334,7 @@ xlog_ticket_get(xlog_t		*log,
        unit_bytes += sizeof(xlog_op_header_t) * num_headers;
        /* for roundoff padding for transaction data and one for commit record */
-        if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) &&
+        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb) &&
            log->l_mp->m_sb.sb_logsunit > 1) {
                /* log su roundoff */
                unit_bytes += 2*log->l_mp->m_sb.sb_logsunit;
diff --git a/fs/xfs/xfs_log_priv.h b/fs/xfs/xfs_log_priv.h
index e008233ee249..c6244cc733c0 100644
--- a/fs/xfs/xfs_log_priv.h
+++ b/fs/xfs/xfs_log_priv.h
@@ -49,10 +49,10 @@ struct xfs_mount;
 #define XLOG_HEADER_SIZE        512
 #define XLOG_REC_SHIFT(log) \
-        BTOBB(1 << (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? \
+        BTOBB(1 << (xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? \
         XLOG_MAX_RECORD_BSHIFT : XLOG_BIG_RECORD_BSHIFT))
 #define XLOG_TOTAL_REC_SHIFT(log) \
-        BTOBB(XLOG_MAX_ICLOGS << (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? \
+        BTOBB(XLOG_MAX_ICLOGS << (xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? \
         XLOG_MAX_RECORD_BSHIFT : XLOG_BIG_RECORD_BSHIFT))
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index b82d5d4d2462..b2b70eba282c 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -478,7 +478,7 @@ xlog_find_verify_log_record(
         * reset last_blk.  Only when last_blk points in the middle of a log
         * record do we update last_blk.
         */
-        if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
+        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
                uint    h_size = be32_to_cpu(head->h_size);
                xhdrs = h_size / XLOG_HEADER_CYCLE_SIZE;
@@ -888,7 +888,7 @@ xlog_find_tail(
         * unmount record if there is one, so we pass the lsn of the
         * unmount record rather than the block after it.
         */
-        if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
+        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
                int     h_size = be32_to_cpu(rhead->h_size);
                int     h_version = be32_to_cpu(rhead->h_version);
@@ -1101,7 +1101,7 @@ xlog_add_record(
        recp->h_magicno = cpu_to_be32(XLOG_HEADER_MAGIC_NUM);
        recp->h_cycle = cpu_to_be32(cycle);
        recp->h_version = cpu_to_be32(
-                        XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb) ? 2 : 1);
+                        xfs_sb_version_haslogv2(&log->l_mp->m_sb) ? 2 : 1);
        recp->h_lsn = cpu_to_be64(xlog_assign_lsn(cycle, block));
        recp->h_tail_lsn = cpu_to_be64(xlog_assign_lsn(tail_cycle, tail_block));
        recp->h_fmt = cpu_to_be32(XLOG_FMT);
@@ -3348,7 +3348,7 @@ xlog_pack_data(
                dp += BBSIZE;
        }
-        if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
+        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
                xhdr = (xlog_in_core_2_t *)&iclog->ic_header;
                for ( ; i < BTOBB(size); i++) {
                        j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
@@ -3388,7 +3388,7 @@ xlog_unpack_data_checksum(
                            be32_to_cpu(rhead->h_chksum), chksum);
                    cmn_err(CE_DEBUG,
 "XFS: Disregard message if filesystem was created with non-DEBUG kernel");
-                    if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
+                    if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
                            cmn_err(CE_DEBUG,
                                "XFS: LogR this is a LogV2 filesystem\n");
                    }
@@ -3415,7 +3415,7 @@ xlog_unpack_data(
                dp += BBSIZE;
        }
-        if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
+        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
                xhdr = (xlog_in_core_2_t *)rhead;
                for ( ; i < BTOBB(be32_to_cpu(rhead->h_len)); i++) {
                        j = i / (XLOG_HEADER_CYCLE_SIZE / BBSIZE);
@@ -3494,7 +3494,7 @@ xlog_do_recovery_pass(
         * Read the header of the tail block and get the iclog buffer size from
         * h_size.  Use this to tell how many sectors make up the log header.
         */
-        if (XFS_SB_VERSION_HASLOGV2(&log->l_mp->m_sb)) {
+        if (xfs_sb_version_haslogv2(&log->l_mp->m_sb)) {
                /*
                 * When using variable length iclogs, read first sector of
                 * iclog header and extract the header size from it.  Get a
@@ -3838,7 +3838,7 @@ xlog_do_recover(
        sbp = &log->l_mp->m_sb;
        xfs_sb_from_disk(sbp, XFS_BUF_TO_SBP(bp));
        ASSERT(sbp->sb_magicnum == XFS_SB_MAGIC);
-        ASSERT(XFS_SB_GOOD_VERSION(sbp));
+        ASSERT(xfs_sb_good_version(sbp));
        xfs_buf_relse(bp);
        /* We've re-read the superblock so re-initialize per-cpu counters */
diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index 6409b3762995..8ed164eb9544 100644
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -44,7 +44,7 @@
 #include "xfs_quota.h"
 #include "xfs_fsops.h"
-STATIC void     xfs_mount_log_sbunit(xfs_mount_t *, __int64_t);
+STATIC void     xfs_mount_log_sb(xfs_mount_t *, __int64_t);
 STATIC int      xfs_uuid_mount(xfs_mount_t *);
 STATIC void     xfs_uuid_unmount(xfs_mount_t *mp);
 STATIC void     xfs_unmountfs_wait(xfs_mount_t *);
@@ -119,6 +119,7 @@ static const struct {
    { offsetof(xfs_sb_t, sb_logsectsize),0 },
    { offsetof(xfs_sb_t, sb_logsunit),   0 },
    { offsetof(xfs_sb_t, sb_features2),  0 },
+    { offsetof(xfs_sb_t, sb_bad_features2), 0 },
    { sizeof(xfs_sb_t),                  0 }
 };
@@ -225,7 +226,7 @@ xfs_mount_validate_sb(
                return XFS_ERROR(EWRONGFS);
        }
-        if (!XFS_SB_GOOD_VERSION(sbp)) {
+        if (!xfs_sb_good_version(sbp)) {
                xfs_fs_mount_cmn_err(flags, "bad version");
                return XFS_ERROR(EWRONGFS);
        }
@@ -300,7 +301,7 @@ xfs_mount_validate_sb(
        /*
         * Version 1 directory format has never worked on Linux.
         */
-        if (unlikely(!XFS_SB_VERSION_HASDIRV2(sbp))) {
+        if (unlikely(!xfs_sb_version_hasdirv2(sbp))) {
                xfs_fs_mount_cmn_err(flags,
                        "file system using version 1 directory format");
                return XFS_ERROR(ENOSYS);
@@ -449,6 +450,7 @@ xfs_sb_from_disk(
        to->sb_logsectsize = be16_to_cpu(from->sb_logsectsize);
        to->sb_logsunit = be32_to_cpu(from->sb_logsunit);
        to->sb_features2 = be32_to_cpu(from->sb_features2);
+        to->sb_bad_features2 = be32_to_cpu(from->sb_bad_features2);
 }
 /*
@@ -781,7 +783,7 @@ xfs_update_alignment(xfs_mount_t *mp, int mfsi_flags, __uint64_t *update_flags)
                 * Update superblock with new values
                 * and log changes
                 */
-                if (XFS_SB_VERSION_HASDALIGN(sbp)) {
+                if (xfs_sb_version_hasdalign(sbp)) {
                        if (sbp->sb_unit != mp->m_dalign) {
                                sbp->sb_unit = mp->m_dalign;
                                *update_flags |= XFS_SB_UNIT;
@@ -792,7 +794,7 @@ xfs_update_alignment(xfs_mount_t *mp, int mfsi_flags, __uint64_t *update_flags)
                        }
                }
        } else if ((mp->m_flags & XFS_MOUNT_NOALIGN) != XFS_MOUNT_NOALIGN &&
-                    XFS_SB_VERSION_HASDALIGN(&mp->m_sb)) {
+                    xfs_sb_version_hasdalign(&mp->m_sb)) {
                        mp->m_dalign = sbp->sb_unit;
                        mp->m_swidth = sbp->sb_width;
        }
@@ -869,7 +871,7 @@ xfs_set_rw_sizes(xfs_mount_t *mp)
 STATIC void
 xfs_set_inoalignment(xfs_mount_t *mp)
 {
-        if (XFS_SB_VERSION_HASALIGN(&mp->m_sb) &&
+        if (xfs_sb_version_hasalign(&mp->m_sb) &&
            mp->m_sb.sb_inoalignmt >=
            XFS_B_TO_FSBT(mp, mp->m_inode_cluster_size))
                mp->m_inoalign_mask = mp->m_sb.sb_inoalignmt - 1;
@@ -970,6 +972,38 @@ xfs_mountfs(
        xfs_mount_common(mp, sbp);
        /*
+         * Check for a mismatched features2 values.  Older kernels
+         * read & wrote into the wrong sb offset for sb_features2
+         * on some platforms due to xfs_sb_t not being 64bit size aligned
+         * when sb_features2 was added, which made older superblock
+         * reading/writing routines swap it as a 64-bit value.
+         *
+         * For backwards compatibility, we make both slots equal.
+         *
+         * If we detect a mismatched field, we OR the set bits into the
+         * existing features2 field in case it has already been modified; we
+         * don't want to lose any features.  We then update the bad location
+         * with the ORed value so that older kernels will see any features2
+         * flags, and mark the two fields as needing updates once the
+         * transaction subsystem is online.
+         */
+        if (xfs_sb_has_mismatched_features2(sbp)) {
+                cmn_err(CE_WARN,
+                        "XFS: correcting sb_features alignment problem");
+                sbp->sb_features2 |= sbp->sb_bad_features2;
+                sbp->sb_bad_features2 = sbp->sb_features2;
+                update_flags |= XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2;
+                /*
+                 * Re-check for ATTR2 in case it was found in bad_features2
+                 * slot.
+                 */
+                if (xfs_sb_version_hasattr2(&mp->m_sb))
+                        mp->m_flags |= XFS_MOUNT_ATTR2;
+        }
+        /*
         * Check if sb_agblocks is aligned at stripe boundary
         * If sb_agblocks is NOT aligned turn off m_dalign since
         * allocator alignment is within an ag, therefore ag has
@@ -1159,11 +1193,10 @@ xfs_mountfs(
        }
        /*
-         * If fs is not mounted readonly, then update the superblock
+         * If fs is not mounted readonly, then update the superblock changes.
-         * unit and width changes.
         */
        if (update_flags && !(mp->m_flags & XFS_MOUNT_RDONLY))
-                xfs_mount_log_sbunit(mp, update_flags);
+                xfs_mount_log_sb(mp, update_flags);
        /*
         * Initialise the XFS quota management subsystem for this mount
@@ -1875,16 +1908,18 @@ xfs_uuid_unmount(
 /*
 * Used to log changes to the superblock unit and width fields which could
- * be altered by the mount options. Only the first superblock is updated.
+ * be altered by the mount options, as well as any potential sb_features2
+ * fixup. Only the first superblock is updated.
 */
 STATIC void
-xfs_mount_log_sbunit(
+xfs_mount_log_sb(
        xfs_mount_t     *mp,
        __int64_t       fields)
 {
        xfs_trans_t     *tp;
-        ASSERT(fields & (XFS_SB_UNIT|XFS_SB_WIDTH|XFS_SB_UUID));
+        ASSERT(fields & (XFS_SB_UNIT | XFS_SB_WIDTH | XFS_SB_UUID |
+                         XFS_SB_FEATURES2 | XFS_SB_BAD_FEATURES2));
        tp = xfs_trans_alloc(mp, XFS_TRANS_SB_UNIT);
        if (xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
diff --git a/fs/xfs/xfs_mount.h b/fs/xfs/xfs_mount.h
index f7c620ec6e69..1d8a4728d847 100644
--- a/fs/xfs/xfs_mount.h
+++ b/fs/xfs/xfs_mount.h
@@ -366,7 +366,7 @@ typedef struct xfs_mount {
 #define XFS_MOUNT_SMALL_INUMS   (1ULL << 15)    /* users wants 32bit inodes */
 #define XFS_MOUNT_NOUUID        (1ULL << 16)    /* ignore uuid during mount */
 #define XFS_MOUNT_BARRIER       (1ULL << 17)
-#define XFS_MOUNT_IDELETE       (1ULL << 18)    /* delete empty inode clusters*/
+#define XFS_MOUNT_IKEEP         (1ULL << 18)    /* keep empty inode clusters*/
 #define XFS_MOUNT_SWALLOC       (1ULL << 19)    /* turn on stripe width
                                                 * allocation */
 #define XFS_MOUNT_RDONLY        (1ULL << 20)    /* read-only fs */
diff --git a/fs/xfs/xfs_rtalloc.c b/fs/xfs/xfs_rtalloc.c
index ca83ddf72af4..47082c01872d 100644
--- a/fs/xfs/xfs_rtalloc.c
+++ b/fs/xfs/xfs_rtalloc.c
@@ -73,6 +73,18 @@ STATIC int xfs_rtmodify_summary(xfs_mount_t *, xfs_trans_t *, int,
 */
 /*
+ * xfs_lowbit32: get low bit set out of 32-bit argument, -1 if none set.
+ */
+STATIC int
+xfs_lowbit32(
+        __uint32_t      v)
+{
+        if (v)
+                return ffs(v) - 1;
+        return -1;
+}
+/*
 * Allocate space to the bitmap or summary file, and zero it, for growfs.
 */
 STATIC int                              /* error */
@@ -432,7 +444,6 @@ xfs_rtallocate_extent_near(
        }
        bbno = XFS_BITTOBLOCK(mp, bno);
        i = 0;
-        ASSERT(minlen != 0);
        log2len = xfs_highbit32(minlen);
        /*
         * Loop over all bitmap blocks (bbno + i is current block).
@@ -601,8 +612,6 @@ xfs_rtallocate_extent_size(
        xfs_suminfo_t   sum;            /* summary information for extents */
        ASSERT(minlen % prod == 0 && maxlen % prod == 0);
-        ASSERT(maxlen != 0);
        /*
         * Loop over all the levels starting with maxlen.
         * At each level, look at all the bitmap blocks, to see if there
@@ -660,9 +669,6 @@ xfs_rtallocate_extent_size(
                *rtblock = NULLRTBLOCK;
                return 0;
        }
-        ASSERT(minlen != 0);
-        ASSERT(maxlen != 0);
        /*
         * Loop over sizes, from maxlen down to minlen.
         * This time, when we do the allocations, allow smaller ones
@@ -1948,7 +1954,6 @@ xfs_growfs_rt(
                                  nsbp->sb_blocksize * nsbp->sb_rextsize);
                nsbp->sb_rextents = nsbp->sb_rblocks;
                do_div(nsbp->sb_rextents, nsbp->sb_rextsize);
-                ASSERT(nsbp->sb_rextents != 0);
                nsbp->sb_rextslog = xfs_highbit32(nsbp->sb_rextents);
                nrsumlevels = nmp->m_rsumlevels = nsbp->sb_rextslog + 1;
                nrsumsize =
diff --git a/fs/xfs/xfs_sb.h b/fs/xfs/xfs_sb.h
index 94660b1a6ccc..d904efe7f871 100644
--- a/fs/xfs/xfs_sb.h
+++ b/fs/xfs/xfs_sb.h
@@ -89,6 +89,7 @@ struct xfs_mount;
 /*
 * Superblock - in core version.  Must match the ondisk version below.
+ * Must be padded to 64 bit alignment.
 */
 typedef struct xfs_sb {
        __uint32_t      sb_magicnum;    /* magic number == XFS_SB_MAGIC */
@@ -145,10 +146,21 @@ typedef struct xfs_sb {
        __uint16_t      sb_logsectsize; /* sector size for the log, bytes */
        __uint32_t      sb_logsunit;    /* stripe unit size for the log */
        __uint32_t      sb_features2;   /* additional feature bits */
+        /*
+         * bad features2 field as a result of failing to pad the sb
+         * structure to 64 bits. Some machines will be using this field
+         * for features2 bits. Easiest just to mark it bad and not use
+         * it for anything else.
+         */
+        __uint32_t      sb_bad_features2;
+        /* must be padded to 64 bit alignment */
 } xfs_sb_t;
 /*
- * Superblock - on disk version.  Must match the in core version below.
+ * Superblock - on disk version.  Must match the in core version above.
+ * Must be padded to 64 bit alignment.
 */
 typedef struct xfs_dsb {
        __be32          sb_magicnum;    /* magic number == XFS_SB_MAGIC */
@@ -205,6 +217,15 @@ typedef struct xfs_dsb {
        __be16          sb_logsectsize; /* sector size for the log, bytes */
        __be32          sb_logsunit;    /* stripe unit size for the log */
        __be32          sb_features2;   /* additional feature bits */
+        /*
+         * bad features2 field as a result of failing to pad the sb
+         * structure to 64 bits. Some machines will be using this field
+         * for features2 bits. Easiest just to mark it bad and not use
+         * it for anything else.
+         */
+        __be32  sb_bad_features2;
+        /* must be padded to 64 bit alignment */
 } xfs_dsb_t;
 /*
@@ -223,7 +244,7 @@ typedef enum {
        XFS_SBS_GQUOTINO, XFS_SBS_QFLAGS, XFS_SBS_FLAGS, XFS_SBS_SHARED_VN,
        XFS_SBS_INOALIGNMT, XFS_SBS_UNIT, XFS_SBS_WIDTH, XFS_SBS_DIRBLKLOG,
        XFS_SBS_LOGSECTLOG, XFS_SBS_LOGSECTSIZE, XFS_SBS_LOGSUNIT,
-        XFS_SBS_FEATURES2,
+        XFS_SBS_FEATURES2, XFS_SBS_BAD_FEATURES2,
        XFS_SBS_FIELDCOUNT
 } xfs_sb_field_t;
@@ -248,13 +269,15 @@ typedef enum {
 #define XFS_SB_IFREE            XFS_SB_MVAL(IFREE)
 #define XFS_SB_FDBLOCKS         XFS_SB_MVAL(FDBLOCKS)
 #define XFS_SB_FEATURES2        XFS_SB_MVAL(FEATURES2)
+#define XFS_SB_BAD_FEATURES2    XFS_SB_MVAL(BAD_FEATURES2)
 #define XFS_SB_NUM_BITS         ((int)XFS_SBS_FIELDCOUNT)
 #define XFS_SB_ALL_BITS         ((1LL << XFS_SB_NUM_BITS) - 1)
 #define XFS_SB_MOD_BITS         \
        (XFS_SB_UUID | XFS_SB_ROOTINO | XFS_SB_RBMINO | XFS_SB_RSUMINO | \
         XFS_SB_VERSIONNUM | XFS_SB_UQUOTINO | XFS_SB_GQUOTINO | \
         XFS_SB_QFLAGS | XFS_SB_SHARED_VN | XFS_SB_UNIT | XFS_SB_WIDTH | \
-         XFS_SB_ICOUNT | XFS_SB_IFREE | XFS_SB_FDBLOCKS | XFS_SB_FEATURES2)
+         XFS_SB_ICOUNT | XFS_SB_IFREE | XFS_SB_FDBLOCKS | XFS_SB_FEATURES2 | \
+         XFS_SB_BAD_FEATURES2)
 /*
@@ -271,7 +294,6 @@ typedef enum {
 #define XFS_SB_VERSION_NUM(sbp) ((sbp)->sb_versionnum & XFS_SB_VERSION_NUMBITS)
-#define XFS_SB_GOOD_VERSION(sbp)        xfs_sb_good_version(sbp)
 #ifdef __KERNEL__
 static inline int xfs_sb_good_version(xfs_sb_t *sbp)
 {
@@ -297,7 +319,15 @@ static inline int xfs_sb_good_version(xfs_sb_t *sbp)
 }
 #endif /* __KERNEL__ */
-#define XFS_SB_VERSION_TONEW(v) xfs_sb_version_tonew(v)
+/*
+ * Detect a mismatched features2 field.  Older kernels read/wrote
+ * this into the wrong slot, so to be safe we keep them in sync.
+ */
+static inline int xfs_sb_has_mismatched_features2(xfs_sb_t *sbp)
+{
+        return (sbp->sb_bad_features2 != sbp->sb_features2);
+}
 static inline unsigned xfs_sb_version_tonew(unsigned v)
 {
        return ((((v) == XFS_SB_VERSION_1) ? \
@@ -308,7 +338,6 @@ static inline unsigned xfs_sb_version_tonew(unsigned v)
                XFS_SB_VERSION_4);
 }
-#define XFS_SB_VERSION_TOOLD(v) xfs_sb_version_toold(v)
 static inline unsigned xfs_sb_version_toold(unsigned v)
 {
        return (((v) & (XFS_SB_VERSION_QUOTABIT | XFS_SB_VERSION_ALIGNBIT)) ? \
@@ -320,7 +349,6 @@ static inline unsigned xfs_sb_version_toold(unsigned v)
                                XFS_SB_VERSION_1)));
 }
-#define XFS_SB_VERSION_HASATTR(sbp)     xfs_sb_version_hasattr(sbp)
 static inline int xfs_sb_version_hasattr(xfs_sb_t *sbp)
 {
        return ((sbp)->sb_versionnum == XFS_SB_VERSION_2) || \
@@ -329,7 +357,6 @@ static inline int xfs_sb_version_hasattr(xfs_sb_t *sbp)
                  ((sbp)->sb_versionnum & XFS_SB_VERSION_ATTRBIT));
 }
-#define XFS_SB_VERSION_ADDATTR(sbp)     xfs_sb_version_addattr(sbp)
 static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
 {
        (sbp)->sb_versionnum = (((sbp)->sb_versionnum == XFS_SB_VERSION_1) ? \
@@ -339,7 +366,6 @@ static inline void xfs_sb_version_addattr(xfs_sb_t *sbp)
                        (XFS_SB_VERSION_4 | XFS_SB_VERSION_ATTRBIT)));
 }
-#define XFS_SB_VERSION_HASNLINK(sbp)    xfs_sb_version_hasnlink(sbp)
 static inline int xfs_sb_version_hasnlink(xfs_sb_t *sbp)
 {
        return ((sbp)->sb_versionnum == XFS_SB_VERSION_3) || \
@@ -347,7 +373,6 @@ static inline int xfs_sb_version_hasnlink(xfs_sb_t *sbp)
                  ((sbp)->sb_versionnum & XFS_SB_VERSION_NLINKBIT));
 }
-#define XFS_SB_VERSION_ADDNLINK(sbp)    xfs_sb_version_addnlink(sbp)
 static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
 {
        (sbp)->sb_versionnum = ((sbp)->sb_versionnum <= XFS_SB_VERSION_2 ? \
@@ -355,115 +380,63 @@ static inline void xfs_sb_version_addnlink(xfs_sb_t *sbp)
                ((sbp)->sb_versionnum | XFS_SB_VERSION_NLINKBIT));
 }
-#define XFS_SB_VERSION_HASQUOTA(sbp)    xfs_sb_version_hasquota(sbp)
 static inline int xfs_sb_version_hasquota(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_QUOTABIT);
 }
-#define XFS_SB_VERSION_ADDQUOTA(sbp)    xfs_sb_version_addquota(sbp)
 static inline void xfs_sb_version_addquota(xfs_sb_t *sbp)
 {
        (sbp)->sb_versionnum = \
                 (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4 ? \
                        ((sbp)->sb_versionnum | XFS_SB_VERSION_QUOTABIT) : \
-                        (XFS_SB_VERSION_TONEW((sbp)->sb_versionnum) | \
+                        (xfs_sb_version_tonew((sbp)->sb_versionnum) | \
                         XFS_SB_VERSION_QUOTABIT));
 }
-#define XFS_SB_VERSION_HASALIGN(sbp)    xfs_sb_version_hasalign(sbp)
 static inline int xfs_sb_version_hasalign(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_ALIGNBIT);
 }
-#define XFS_SB_VERSION_SUBALIGN(sbp)    xfs_sb_version_subalign(sbp)
-static inline void xfs_sb_version_subalign(xfs_sb_t *sbp)
-{
-        (sbp)->sb_versionnum = \
-         XFS_SB_VERSION_TOOLD((sbp)->sb_versionnum & ~XFS_SB_VERSION_ALIGNBIT);
-}
-#define XFS_SB_VERSION_HASDALIGN(sbp)   xfs_sb_version_hasdalign(sbp)
 static inline int xfs_sb_version_hasdalign(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_DALIGNBIT);
 }
-#define XFS_SB_VERSION_ADDDALIGN(sbp)   xfs_sb_version_adddalign(sbp)
-static inline int xfs_sb_version_adddalign(xfs_sb_t *sbp)
-{
-        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_DALIGNBIT);
-}
-#define XFS_SB_VERSION_HASSHARED(sbp)   xfs_sb_version_hasshared(sbp)
 static inline int xfs_sb_version_hasshared(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_SHAREDBIT);
 }
-#define XFS_SB_VERSION_ADDSHARED(sbp)   xfs_sb_version_addshared(sbp)
-static inline int xfs_sb_version_addshared(xfs_sb_t *sbp)
-{
-        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_SHAREDBIT);
-}
-#define XFS_SB_VERSION_SUBSHARED(sbp)   xfs_sb_version_subshared(sbp)
-static inline int xfs_sb_version_subshared(xfs_sb_t *sbp)
-{
-        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_SHAREDBIT);
-}
-#define XFS_SB_VERSION_HASDIRV2(sbp)    xfs_sb_version_hasdirv2(sbp)
 static inline int xfs_sb_version_hasdirv2(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_DIRV2BIT);
 }
-#define XFS_SB_VERSION_HASLOGV2(sbp)   xfs_sb_version_haslogv2(sbp)
 static inline int xfs_sb_version_haslogv2(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_LOGV2BIT);
 }
-#define XFS_SB_VERSION_HASEXTFLGBIT(sbp)        xfs_sb_version_hasextflgbit(sbp)
 static inline int xfs_sb_version_hasextflgbit(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_EXTFLGBIT);
 }
-#define XFS_SB_VERSION_ADDEXTFLGBIT(sbp)        xfs_sb_version_addextflgbit(sbp)
-static inline int xfs_sb_version_addextflgbit(xfs_sb_t *sbp)
-{
-        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum | XFS_SB_VERSION_EXTFLGBIT);
-}
-#define XFS_SB_VERSION_SUBEXTFLGBIT(sbp)        xfs_sb_version_subextflgbit(sbp)
-static inline int xfs_sb_version_subextflgbit(xfs_sb_t *sbp)
-{
-        return (sbp)->sb_versionnum = \
-                ((sbp)->sb_versionnum & ~XFS_SB_VERSION_EXTFLGBIT);
-}
-#define XFS_SB_VERSION_HASSECTOR(sbp)   xfs_sb_version_hassector(sbp)
 static inline int xfs_sb_version_hassector(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
                ((sbp)->sb_versionnum & XFS_SB_VERSION_SECTORBIT);
 }
-#define XFS_SB_VERSION_HASMOREBITS(sbp) xfs_sb_version_hasmorebits(sbp)
 static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
 {
        return (XFS_SB_VERSION_NUM(sbp) == XFS_SB_VERSION_4) && \
@@ -476,24 +449,22 @@ static inline int xfs_sb_version_hasmorebits(xfs_sb_t *sbp)
 * For example, for a bit defined as XFS_SB_VERSION2_FUNBIT, has a macro:
 *
 * SB_VERSION_HASFUNBIT(xfs_sb_t *sbp)
- *      ((XFS_SB_VERSION_HASMOREBITS(sbp) &&
+ *      ((xfs_sb_version_hasmorebits(sbp) &&
 *       ((sbp)->sb_features2 & XFS_SB_VERSION2_FUNBIT)
 */
 static inline int xfs_sb_version_haslazysbcount(xfs_sb_t *sbp)
 {
-        return (XFS_SB_VERSION_HASMOREBITS(sbp) &&      \
+        return (xfs_sb_version_hasmorebits(sbp) &&      \
                ((sbp)->sb_features2 & XFS_SB_VERSION2_LAZYSBCOUNTBIT));
 }
-#define XFS_SB_VERSION_HASATTR2(sbp)    xfs_sb_version_hasattr2(sbp)
 static inline int xfs_sb_version_hasattr2(xfs_sb_t *sbp)
 {
-        return (XFS_SB_VERSION_HASMOREBITS(sbp)) &&     \
+        return (xfs_sb_version_hasmorebits(sbp)) &&     \
                ((sbp)->sb_features2 & XFS_SB_VERSION2_ATTR2BIT);
 }
-#define XFS_SB_VERSION_ADDATTR2(sbp)    xfs_sb_version_addattr2(sbp)
 static inline void xfs_sb_version_addattr2(xfs_sb_t *sbp)
 {
        ((sbp)->sb_versionnum = \
diff --git a/fs/xfs/xfs_trans_ail.c b/fs/xfs/xfs_trans_ail.c
index 4d6330eddc8d..76d470d8a1e6 100644
--- a/fs/xfs/xfs_trans_ail.c
+++ b/fs/xfs/xfs_trans_ail.c
@@ -261,16 +261,19 @@ xfsaild_push(
                xfs_log_force(mp, (xfs_lsn_t)0, XFS_LOG_FORCE);
        }
-        /*
+        if (!count) {
-         * We reached the target so wait a bit longer for I/O to complete and
+                /* We're past our target or empty, so idle */
-         * remove pushed items from the AIL before we start the next scan from
+                tout = 1000;
-         * the start of the AIL.
+        } else if (XFS_LSN_CMP(lsn, target) >= 0) {
-         */
+                /*
-        if ((XFS_LSN_CMP(lsn, target) >= 0)) {
+                 * We reached the target so wait a bit longer for I/O to
+                 * complete and remove pushed items from the AIL before we
+                 * start the next scan from the start of the AIL.
+                 */
                tout += 20;
                last_pushed_lsn = 0;
        } else if ((restarts > XFS_TRANS_PUSH_AIL_RESTARTS) ||
-                   (count && ((stuck * 100) / count > 90))) {
+                   ((stuck * 100) / count > 90)) {
                /*
                 * Either there is a lot of contention on the AIL or we
                 * are stuck due to operations in progress. "Stuck" in this
diff --git a/fs/xfs/xfs_utils.c b/fs/xfs/xfs_utils.c
index 45d740df53b7..18a85e746680 100644
--- a/fs/xfs/xfs_utils.c
+++ b/fs/xfs/xfs_utils.c
@@ -339,10 +339,10 @@ xfs_bump_ino_vers2(
        ip->i_d.di_onlink = 0;
        memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
        mp = tp->t_mountp;
-        if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) {
+        if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
                spin_lock(&mp->m_sb_lock);
-                if (!XFS_SB_VERSION_HASNLINK(&mp->m_sb)) {
+                if (!xfs_sb_version_hasnlink(&mp->m_sb)) {
-                        XFS_SB_VERSION_ADDNLINK(&mp->m_sb);
+                        xfs_sb_version_addnlink(&mp->m_sb);
                        spin_unlock(&mp->m_sb_lock);
                        xfs_mod_sb(tp, XFS_SB_VERSIONNUM);
                } else {
diff --git a/fs/xfs/xfs_vfsops.c b/fs/xfs/xfs_vfsops.c
index 413587f02155..7094caff13cf 100644
--- a/fs/xfs/xfs_vfsops.c
+++ b/fs/xfs/xfs_vfsops.c
@@ -281,8 +281,8 @@ xfs_start_flags(
                mp->m_readio_log = mp->m_writeio_log = ap->iosizelog;
        }
-        if (ap->flags & XFSMNT_IDELETE)
+        if (ap->flags & XFSMNT_IKEEP)
-                mp->m_flags |= XFS_MOUNT_IDELETE;
+                mp->m_flags |= XFS_MOUNT_IKEEP;
        if (ap->flags & XFSMNT_DIRSYNC)
                mp->m_flags |= XFS_MOUNT_DIRSYNC;
        if (ap->flags & XFSMNT_ATTR2)
@@ -330,7 +330,7 @@ xfs_finish_flags(
        int                     ronly = (mp->m_flags & XFS_MOUNT_RDONLY);
        /* Fail a mount where the logbuf is smaller then the log stripe */
-        if (XFS_SB_VERSION_HASLOGV2(&mp->m_sb)) {
+        if (xfs_sb_version_haslogv2(&mp->m_sb)) {
                if ((ap->logbufsize <= 0) &&
                    (mp->m_sb.sb_logsunit > XLOG_BIG_RECORD_BSIZE)) {
                        mp->m_logbsize = mp->m_sb.sb_logsunit;
@@ -349,9 +349,8 @@ xfs_finish_flags(
                }
        }
-        if (XFS_SB_VERSION_HASATTR2(&mp->m_sb)) {
+        if (xfs_sb_version_hasattr2(&mp->m_sb))
                mp->m_flags |= XFS_MOUNT_ATTR2;
-        }
        /*
         * prohibit r/w mounts of read-only filesystems
@@ -366,7 +365,7 @@ xfs_finish_flags(
         * check for shared mount.
         */
        if (ap->flags & XFSMNT_SHARED) {
-                if (!XFS_SB_VERSION_HASSHARED(&mp->m_sb))
+                if (!xfs_sb_version_hasshared(&mp->m_sb))
                        return XFS_ERROR(EINVAL);
                /*
@@ -512,7 +511,7 @@ xfs_mount(
        if (!error && logdev && logdev != ddev) {
                unsigned int    log_sector_size = BBSIZE;
-                if (XFS_SB_VERSION_HASSECTOR(&mp->m_sb))
+                if (xfs_sb_version_hassector(&mp->m_sb))
                        log_sector_size = mp->m_sb.sb_logsectsize;
                error = xfs_setsize_buftarg(mp->m_logdev_targp,
                                            mp->m_sb.sb_blocksize,
diff --git a/fs/xfs/xfs_vnodeops.c b/fs/xfs/xfs_vnodeops.c
index 51305242ff8c..64c5953feca4 100644
--- a/fs/xfs/xfs_vnodeops.c
+++ b/fs/xfs/xfs_vnodeops.c
@@ -4132,7 +4132,7 @@ xfs_free_file_space(
         * actually need to zero the extent edges.  Otherwise xfs_bunmapi
         * will take care of it for us.
         */
-        if (rt && !XFS_SB_VERSION_HASEXTFLGBIT(&mp->m_sb)) {
+        if (rt && !xfs_sb_version_hasextflgbit(&mp->m_sb)) {
                nimap = 1;
                error = xfs_bmapi(NULL, ip, startoffset_fsb,
                        1, 0, NULL, 0, &imap, &nimap, NULL, NULL);