Merge branch 'akpm' (patches from Andrew Morton)

Merge second patch-bomb from Andrew Morton:
 - a few hotfixes
 - drivers/dma updates
 - MAINTAINERS updates
 - Quite a lot of lib/ updates
 - checkpatch updates
 - binfmt updates
 - autofs4
 - drivers/rtc/
 - various small tweaks to less used filesystems
 - ipc/ updates
 - kernel/watchdog.c changes

* emailed patches from Andrew Morton <akpm@linux-foundation.org>: (135 commits)
  mm: softdirty: enable write notifications on VMAs after VM_SOFTDIRTY cleared
  kernel/param: consolidate __{start,stop}___param[] in <linux/moduleparam.h>
  ia64: remove duplicate declarations of __per_cpu_start[] and __per_cpu_end[]
  frv: remove unused declarations of __start___ex_table and __stop___ex_table
  kvm: ensure hard lockup detection is disabled by default
  kernel/watchdog.c: control hard lockup detection default
  staging: rtl8192u: use %*pEn to escape buffer
  staging: rtl8192e: use %*pEn to escape buffer
  staging: wlan-ng: use %*pEhp to print SN
  lib80211: remove unused print_ssid()
  wireless: hostap: proc: print properly escaped SSID
  wireless: ipw2x00: print SSID via %*pE
  wireless: libertas: print esaped string via %*pE
  lib/vsprintf: add %*pE[achnops] format specifier
  lib / string_helpers: introduce string_escape_mem()
  lib / string_helpers: refactoring the test suite
  lib / string_helpers: move documentation to c-file
  include/linux: remove strict_strto* definitions
  arch/x86/mm/numa.c: fix boot failure when all nodes are hotpluggable
  fs: check bh blocknr earlier when searching lru
  ...

32 files changed, 355 insertions, 209 deletions

diff --git a/fs/affs/amigaffs.c b/fs/affs/amigaffs.c
index 406b29836b19..abc853968fed 100644
--- a/fs/affs/amigaffs.c
+++ b/fs/affs/amigaffs.c
@@ -10,8 +10,6 @@
 
 #include "affs.h"
 
-extern struct timezone sys_tz;
-
 static char ErrorBuffer[256];
 
 /*
diff --git a/fs/affs/file.c b/fs/affs/file.c
index a7fe57d2cd9a..1ed590aafecf 100644
--- a/fs/affs/file.c
+++ b/fs/affs/file.c
@@ -584,11 +584,14 @@ affs_extent_file_ofs(struct inode *inode, u32 newsize)
                 bh->b_state &= ~(1UL << BH_New);
                 mark_buffer_dirty_inode(bh, inode);
                 if (prev_bh) {
-                        u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
-                        if (tmp)
-                                affs_warning(sb, "extent_file_ofs", "next block already set for %d (%d)", bidx, tmp);
+                        u32 tmp_next = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
+
+                        if (tmp_next)
+                                affs_warning(sb, "extent_file_ofs",
+                                             "next block already set for %d (%d)",
+                                             bidx, tmp_next);
                         AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
-                        affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp);
+                        affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
                         mark_buffer_dirty_inode(prev_bh, inode);
                         affs_brelse(prev_bh);
                 }
@@ -727,11 +730,14 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
                         AFFS_DATA_HEAD(bh)->next = 0;
                         bh->b_state &= ~(1UL << BH_New);
                         if (prev_bh) {
-                                u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
-                                if (tmp)
-                                        affs_warning(sb, "commit_write_ofs", "next block already set for %d (%d)", bidx, tmp);
+                                u32 tmp_next = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
+
+                                if (tmp_next)
+                                        affs_warning(sb, "commit_write_ofs",
+                                                     "next block already set for %d (%d)",
+                                                     bidx, tmp_next);
                                 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
-                                affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp);
+                                affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
                                 mark_buffer_dirty_inode(prev_bh, inode);
                         }
                 }
@@ -758,11 +764,14 @@ static int affs_write_end_ofs(struct file *file, struct address_space *mapping,
                         AFFS_DATA_HEAD(bh)->next = 0;
                         bh->b_state &= ~(1UL << BH_New);
                         if (prev_bh) {
-                                u32 tmp = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
-                                if (tmp)
-                                        affs_warning(sb, "commit_write_ofs", "next block already set for %d (%d)", bidx, tmp);
+                                u32 tmp_next = be32_to_cpu(AFFS_DATA_HEAD(prev_bh)->next);
+
+                                if (tmp_next)
+                                        affs_warning(sb, "commit_write_ofs",
+                                                     "next block already set for %d (%d)",
+                                                     bidx, tmp_next);
                                 AFFS_DATA_HEAD(prev_bh)->next = cpu_to_be32(bh->b_blocknr);
-                                affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp);
+                                affs_adjust_checksum(prev_bh, bh->b_blocknr - tmp_next);
                                 mark_buffer_dirty_inode(prev_bh, inode);
                         }
                 } else if (be32_to_cpu(AFFS_DATA_HEAD(bh)->size) < tmp)
@@ -842,12 +851,12 @@ affs_truncate(struct inode *inode)
                 struct address_space *mapping = inode->i_mapping;
                 struct page *page;
                 void *fsdata;
-                loff_t size = inode->i_size;
+                loff_t isize = inode->i_size;
                 int res;
 
-                res = mapping->a_ops->write_begin(NULL, mapping, size, 0, 0, &page, &fsdata);
+                res = mapping->a_ops->write_begin(NULL, mapping, isize, 0, 0, &page, &fsdata);
                 if (!res)
-                        res = mapping->a_ops->write_end(NULL, mapping, size, 0, 0, page, fsdata);
+                        res = mapping->a_ops->write_end(NULL, mapping, isize, 0, 0, page, fsdata);
                 else
                         inode->i_size = AFFS_I(inode)->mmu_private;
                 mark_inode_dirty(inode);
diff --git a/fs/affs/inode.c b/fs/affs/inode.c
index bec2d1a0c91c..e217c511459b 100644
--- a/fs/affs/inode.c
+++ b/fs/affs/inode.c
@@ -14,13 +14,11 @@
 #include "affs.h"
 
 extern const struct inode_operations affs_symlink_inode_operations;
-extern struct timezone sys_tz;
 
 struct inode *affs_iget(struct super_block *sb, unsigned long ino)
 {
         struct affs_sb_info     *sbi = AFFS_SB(sb);
         struct buffer_head      *bh;
-        struct affs_head        *head;
         struct affs_tail        *tail;
         struct inode            *inode;
         u32                      block;
@@ -49,7 +47,6 @@ struct inode *affs_iget(struct super_block *sb, unsigned long ino)
                 goto bad_inode;
         }
 
-        head = AFFS_HEAD(bh);
         tail = AFFS_TAIL(sb, bh);
         prot = be32_to_cpu(tail->protect);
 
diff --git a/fs/affs/super.c b/fs/affs/super.c
index 51f1a95bff73..f754ab68a840 100644
--- a/fs/affs/super.c
+++ b/fs/affs/super.c
@@ -20,8 +20,6 @@
 #include <linux/writeback.h>
 #include "affs.h"
 
-extern struct timezone sys_tz;
-
 static int affs_statfs(struct dentry *dentry, struct kstatfs *buf);
 static int affs_remount (struct super_block *sb, int *flags, char *data);
 
@@ -308,7 +306,6 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
         u32                      chksum;
         int                      num_bm;
         int                      i, j;
-        s32                      key;
         kuid_t                   uid;
         kgid_t                   gid;
         int                      reserved;
@@ -367,7 +364,7 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                 i = j = blocksize;
                 size = size / (blocksize / 512);
         }
-        for (blocksize = i, key = 0; blocksize <= j; blocksize <<= 1, size >>= 1) {
+        for (blocksize = i; blocksize <= j; blocksize <<= 1, size >>= 1) {
                 sbi->s_root_block = root_block;
                 if (root_block < 0)
                         sbi->s_root_block = (reserved + size - 1) / 2;
@@ -399,7 +396,6 @@ static int affs_fill_super(struct super_block *sb, void *data, int silent)
                             be32_to_cpu(AFFS_ROOT_TAIL(sb, root_bh)->stype) == ST_ROOT) {
                                 sbi->s_hashsize    = blocksize / 4 - 56;
                                 sbi->s_root_block += num_bm;
-                                key                        = 1;
                                 goto got_root;
                         }
                         affs_brelse(root_bh);
diff --git a/fs/autofs4/autofs_i.h b/fs/autofs4/autofs_i.h
index 9e359fb20c0a..8e98cf954bab 100644
--- a/fs/autofs4/autofs_i.h
+++ b/fs/autofs4/autofs_i.h
@@ -79,6 +79,10 @@ struct autofs_info {
 };
 
 #define AUTOFS_INF_EXPIRING     (1<<0) /* dentry is in the process of expiring */
+#define AUTOFS_INF_NO_RCU       (1<<1) /* the dentry is being considered
+                                        * for expiry, so RCU_walk is
+                                        * not permitted
+                                        */
 #define AUTOFS_INF_PENDING      (1<<2) /* dentry pending mount */
 
 struct autofs_wait_queue {
@@ -148,7 +152,7 @@ void autofs4_free_ino(struct autofs_info *);
 
 /* Expiration */
 int is_autofs4_dentry(struct dentry *);
-int autofs4_expire_wait(struct dentry *dentry);
+int autofs4_expire_wait(struct dentry *dentry, int rcu_walk);
 int autofs4_expire_run(struct super_block *, struct vfsmount *,
                         struct autofs_sb_info *,
                         struct autofs_packet_expire __user *);
diff --git a/fs/autofs4/dev-ioctl.c b/fs/autofs4/dev-ioctl.c
index 5b570b6efa28..aaf96cb25452 100644
--- a/fs/autofs4/dev-ioctl.c
+++ b/fs/autofs4/dev-ioctl.c
@@ -450,7 +450,7 @@ static int autofs_dev_ioctl_requester(struct file *fp,
         ino = autofs4_dentry_ino(path.dentry);
         if (ino) {
                 err = 0;
-                autofs4_expire_wait(path.dentry);
+                autofs4_expire_wait(path.dentry, 0);
                 spin_lock(&sbi->fs_lock);
                 param->requester.uid = from_kuid_munged(current_user_ns(), ino->uid);
                 param->requester.gid = from_kgid_munged(current_user_ns(), ino->gid);
diff --git a/fs/autofs4/expire.c b/fs/autofs4/expire.c
index 8fa3895cda02..683a5b9ce22a 100644
--- a/fs/autofs4/expire.c
+++ b/fs/autofs4/expire.c
@@ -30,12 +30,6 @@ static inline int autofs4_can_expire(struct dentry *dentry,
                 /* Too young to die */
                 if (!timeout || time_after(ino->last_used + timeout, now))
                         return 0;
-
-                /* update last_used here :-
-                   - obviously makes sense if it is in use now
-                   - less obviously, prevents rapid-fire expire
-                     attempts if expire fails the first time */
-                ino->last_used = now;
         }
         return 1;
 }
@@ -327,10 +321,19 @@ struct dentry *autofs4_expire_direct(struct super_block *sb,
         if (ino->flags & AUTOFS_INF_PENDING)
                 goto out;
         if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
-                ino->flags |= AUTOFS_INF_EXPIRING;
-                init_completion(&ino->expire_complete);
+                ino->flags |= AUTOFS_INF_NO_RCU;
                 spin_unlock(&sbi->fs_lock);
-                return root;
+                synchronize_rcu();
+                spin_lock(&sbi->fs_lock);
+                if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
+                        ino->flags |= AUTOFS_INF_EXPIRING;
+                        smp_mb();
+                        ino->flags &= ~AUTOFS_INF_NO_RCU;
+                        init_completion(&ino->expire_complete);
+                        spin_unlock(&sbi->fs_lock);
+                        return root;
+                }
+                ino->flags &= ~AUTOFS_INF_NO_RCU;
         }
 out:
         spin_unlock(&sbi->fs_lock);
@@ -339,6 +342,89 @@ out:
         return NULL;
 }
 
+/* Check if 'dentry' should expire, or return a nearby
+ * dentry that is suitable.
+ * If returned dentry is different from arg dentry,
+ * then a dget() reference was taken, else not.
+ */
+static struct dentry *should_expire(struct dentry *dentry,
+                                    struct vfsmount *mnt,
+                                    unsigned long timeout,
+                                    int how)
+{
+        int do_now = how & AUTOFS_EXP_IMMEDIATE;
+        int exp_leaves = how & AUTOFS_EXP_LEAVES;
+        struct autofs_info *ino = autofs4_dentry_ino(dentry);
+        unsigned int ino_count;
+
+        /* No point expiring a pending mount */
+        if (ino->flags & AUTOFS_INF_PENDING)
+                return NULL;
+
+        /*
+         * Case 1: (i) indirect mount or top level pseudo direct mount
+         *         (autofs-4.1).
+         *         (ii) indirect mount with offset mount, check the "/"
+         *         offset (autofs-5.0+).
+         */
+        if (d_mountpoint(dentry)) {
+                DPRINTK("checking mountpoint %p %.*s",
+                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
+
+                /* Can we umount this guy */
+                if (autofs4_mount_busy(mnt, dentry))
+                        return NULL;
+
+                /* Can we expire this guy */
+                if (autofs4_can_expire(dentry, timeout, do_now))
+                        return dentry;
+                return NULL;
+        }
+
+        if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) {
+                DPRINTK("checking symlink %p %.*s",
+                        dentry, (int)dentry->d_name.len, dentry->d_name.name);
+                /*
+                 * A symlink can't be "busy" in the usual sense so
+                 * just check last used for expire timeout.
+                 */
+                if (autofs4_can_expire(dentry, timeout, do_now))
+                        return dentry;
+                return NULL;
+        }
+
+        if (simple_empty(dentry))
+                return NULL;
+
+        /* Case 2: tree mount, expire iff entire tree is not busy */
+        if (!exp_leaves) {
+                /* Path walk currently on this dentry? */
+                ino_count = atomic_read(&ino->count) + 1;
+                if (d_count(dentry) > ino_count)
+                        return NULL;
+
+                if (!autofs4_tree_busy(mnt, dentry, timeout, do_now))
+                        return dentry;
+        /*
+         * Case 3: pseudo direct mount, expire individual leaves
+         *         (autofs-4.1).
+         */
+        } else {
+                /* Path walk currently on this dentry? */
+                struct dentry *expired;
+                ino_count = atomic_read(&ino->count) + 1;
+                if (d_count(dentry) > ino_count)
+                        return NULL;
+
+                expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
+                if (expired) {
+                        if (expired == dentry)
+                                dput(dentry);
+                        return expired;
+                }
+        }
+        return NULL;
+}
 /*
  * Find an eligible tree to time-out
  * A tree is eligible if :-
@@ -353,11 +439,8 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
         unsigned long timeout;
         struct dentry *root = sb->s_root;
         struct dentry *dentry;
-        struct dentry *expired = NULL;
-        int do_now = how & AUTOFS_EXP_IMMEDIATE;
-        int exp_leaves = how & AUTOFS_EXP_LEAVES;
+        struct dentry *expired;
         struct autofs_info *ino;
-        unsigned int ino_count;
 
         if (!root)
                 return NULL;
@@ -369,77 +452,28 @@ struct dentry *autofs4_expire_indirect(struct super_block *sb,
         while ((dentry = get_next_positive_subdir(dentry, root))) {
                 spin_lock(&sbi->fs_lock);
                 ino = autofs4_dentry_ino(dentry);
-                /* No point expiring a pending mount */
-                if (ino->flags & AUTOFS_INF_PENDING)
-                        goto next;
-
-                /*
-                 * Case 1: (i) indirect mount or top level pseudo direct mount
-                 *         (autofs-4.1).
-                 *         (ii) indirect mount with offset mount, check the "/"
-                 *         offset (autofs-5.0+).
-                 */
-                if (d_mountpoint(dentry)) {
-                        DPRINTK("checking mountpoint %p %.*s",
-                                dentry, (int)dentry->d_name.len, dentry->d_name.name);
-
-                        /* Can we umount this guy */
-                        if (autofs4_mount_busy(mnt, dentry))
-                                goto next;
-
-                        /* Can we expire this guy */
-                        if (autofs4_can_expire(dentry, timeout, do_now)) {
-                                expired = dentry;
-                                goto found;
-                        }
-                        goto next;
+                if (ino->flags & AUTOFS_INF_NO_RCU)
+                        expired = NULL;
+                else
+                        expired = should_expire(dentry, mnt, timeout, how);
+                if (!expired) {
+                        spin_unlock(&sbi->fs_lock);
+                        continue;
                 }
-
-                if (dentry->d_inode && S_ISLNK(dentry->d_inode->i_mode)) {
-                        DPRINTK("checking symlink %p %.*s",
-                                dentry, (int)dentry->d_name.len, dentry->d_name.name);
-                        /*
-                         * A symlink can't be "busy" in the usual sense so
-                         * just check last used for expire timeout.
-                         */
-                        if (autofs4_can_expire(dentry, timeout, do_now)) {
-                                expired = dentry;
-                                goto found;
-                        }
-                        goto next;
-                }
-
-                if (simple_empty(dentry))
-                        goto next;
-
-                /* Case 2: tree mount, expire iff entire tree is not busy */
-                if (!exp_leaves) {
-                        /* Path walk currently on this dentry? */
-                        ino_count = atomic_read(&ino->count) + 1;
-                        if (d_count(dentry) > ino_count)
-                                goto next;
-
-                        if (!autofs4_tree_busy(mnt, dentry, timeout, do_now)) {
-                                expired = dentry;
-                                goto found;
-                        }
-                /*
-                 * Case 3: pseudo direct mount, expire individual leaves
-                 *         (autofs-4.1).
-                 */
-                } else {
-                        /* Path walk currently on this dentry? */
-                        ino_count = atomic_read(&ino->count) + 1;
-                        if (d_count(dentry) > ino_count)
-                                goto next;
-
-                        expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
-                        if (expired) {
+                ino = autofs4_dentry_ino(expired);
+                ino->flags |= AUTOFS_INF_NO_RCU;
+                spin_unlock(&sbi->fs_lock);
+                synchronize_rcu();
+                spin_lock(&sbi->fs_lock);
+                if (should_expire(expired, mnt, timeout, how)) {
+                        if (expired != dentry)
                                 dput(dentry);
-                                goto found;
-                        }
+                        goto found;
                 }
-next:
+
+                ino->flags &= ~AUTOFS_INF_NO_RCU;
+                if (expired != dentry)
+                        dput(expired);
                 spin_unlock(&sbi->fs_lock);
         }
         return NULL;
@@ -447,8 +481,9 @@ next:
 found:
         DPRINTK("returning %p %.*s",
                 expired, (int)expired->d_name.len, expired->d_name.name);
-        ino = autofs4_dentry_ino(expired);
         ino->flags |= AUTOFS_INF_EXPIRING;
+        smp_mb();
+        ino->flags &= ~AUTOFS_INF_NO_RCU;
         init_completion(&ino->expire_complete);
         spin_unlock(&sbi->fs_lock);
         spin_lock(&sbi->lookup_lock);
@@ -461,13 +496,18 @@ found:
         return expired;
 }
 
-int autofs4_expire_wait(struct dentry *dentry)
+int autofs4_expire_wait(struct dentry *dentry, int rcu_walk)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
         int status;
 
         /* Block on any pending expire */
+        if (!(ino->flags & (AUTOFS_INF_EXPIRING | AUTOFS_INF_NO_RCU)))
+                return 0;
+        if (rcu_walk)
+                return -ECHILD;
+
         spin_lock(&sbi->fs_lock);
         if (ino->flags & AUTOFS_INF_EXPIRING) {
                 spin_unlock(&sbi->fs_lock);
@@ -519,6 +559,8 @@ int autofs4_expire_run(struct super_block *sb,
 
         spin_lock(&sbi->fs_lock);
         ino = autofs4_dentry_ino(dentry);
+        /* avoid rapid-fire expire attempts if expiry fails */
+        ino->last_used = now;
         ino->flags &= ~AUTOFS_INF_EXPIRING;
         complete_all(&ino->expire_complete);
         spin_unlock(&sbi->fs_lock);
@@ -545,6 +587,8 @@ int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
                 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
 
                 spin_lock(&sbi->fs_lock);
+                /* avoid rapid-fire expire attempts if expiry fails */
+                ino->last_used = now;
                 ino->flags &= ~AUTOFS_INF_EXPIRING;
                 complete_all(&ino->expire_complete);
                 spin_unlock(&sbi->fs_lock);
diff --git a/fs/autofs4/root.c b/fs/autofs4/root.c
index cdb25ebccc4c..d76d083f2f06 100644
--- a/fs/autofs4/root.c
+++ b/fs/autofs4/root.c
@@ -210,7 +210,8 @@ next:
         return NULL;
 }
 
-static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
+static struct dentry *autofs4_lookup_expiring(struct dentry *dentry,
+                                              bool rcu_walk)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
         struct dentry *parent = dentry->d_parent;
@@ -229,6 +230,11 @@ static struct dentry *autofs4_lookup_expiring(struct dentry *dentry)
                 struct dentry *expiring;
                 struct qstr *qstr;
 
+                if (rcu_walk) {
+                        spin_unlock(&sbi->lookup_lock);
+                        return ERR_PTR(-ECHILD);
+                }
+
                 ino = list_entry(p, struct autofs_info, expiring);
                 expiring = ino->dentry;
 
@@ -264,13 +270,15 @@ next:
         return NULL;
 }
 
-static int autofs4_mount_wait(struct dentry *dentry)
+static int autofs4_mount_wait(struct dentry *dentry, bool rcu_walk)
 {
         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
         struct autofs_info *ino = autofs4_dentry_ino(dentry);
         int status = 0;
 
         if (ino->flags & AUTOFS_INF_PENDING) {
+                if (rcu_walk)
+                        return -ECHILD;
                 DPRINTK("waiting for mount name=%.*s",
                         dentry->d_name.len, dentry->d_name.name);
                 status = autofs4_wait(sbi, dentry, NFY_MOUNT);
@@ -280,20 +288,22 @@ static int autofs4_mount_wait(struct dentry *dentry)
         return status;
 }
 
-static int do_expire_wait(struct dentry *dentry)
+static int do_expire_wait(struct dentry *dentry, bool rcu_walk)
 {
         struct dentry *expiring;
 
-        expiring = autofs4_lookup_expiring(dentry);
+        expiring = autofs4_lookup_expiring(dentry, rcu_walk);
+        if (IS_ERR(expiring))
+                return PTR_ERR(expiring);
         if (!expiring)
-                return autofs4_expire_wait(dentry);
+                return autofs4_expire_wait(dentry, rcu_walk);
         else {
                 /*
                  * If we are racing with expire the request might not
                  * be quite complete, but the directory has been removed
                  * so it must have been successful, just wait for it.
                  */
-                autofs4_expire_wait(expiring);
+                autofs4_expire_wait(expiring, 0);
                 autofs4_del_expiring(expiring);
                 dput(expiring);
         }
@@ -345,7 +355,7 @@ static struct vfsmount *autofs4_d_automount(struct path *path)
          * and the directory was removed, so just go ahead and try
          * the mount.
          */
-        status = do_expire_wait(dentry);
+        status = do_expire_wait(dentry, 0);
         if (status && status != -EAGAIN)
                 return NULL;
 
@@ -353,7 +363,7 @@ static struct vfsmount *autofs4_d_automount(struct path *path)
         spin_lock(&sbi->fs_lock);
         if (ino->flags & AUTOFS_INF_PENDING) {
                 spin_unlock(&sbi->fs_lock);
-                status = autofs4_mount_wait(dentry);
+                status = autofs4_mount_wait(dentry, 0);
                 if (status)
                         return ERR_PTR(status);
                 goto done;
@@ -394,7 +404,7 @@ static struct vfsmount *autofs4_d_automount(struct path *path)
                 }
                 ino->flags |= AUTOFS_INF_PENDING;
                 spin_unlock(&sbi->fs_lock);
-                status = autofs4_mount_wait(dentry);
+                status = autofs4_mount_wait(dentry, 0);
                 spin_lock(&sbi->fs_lock);
                 ino->flags &= ~AUTOFS_INF_PENDING;
                 if (status) {
@@ -423,28 +433,46 @@ static int autofs4_d_manage(struct dentry *dentry, bool rcu_walk)
 
         /* The daemon never waits. */
         if (autofs4_oz_mode(sbi)) {
-                if (rcu_walk)
-                        return 0;
                 if (!d_mountpoint(dentry))
                         return -EISDIR;
                 return 0;
         }
 
-        /* We need to sleep, so we need pathwalk to be in ref-mode */
-        if (rcu_walk)
-                return -ECHILD;
-
         /* Wait for pending expires */
-        do_expire_wait(dentry);
+        if (do_expire_wait(dentry, rcu_walk) == -ECHILD)
+                return -ECHILD;
 
         /*
          * This dentry may be under construction so wait on mount
          * completion.
          */
-        status = autofs4_mount_wait(dentry);
+        status = autofs4_mount_wait(dentry, rcu_walk);
         if (status)
                 return status;
 
+        if (rcu_walk) {
+                /* We don't need fs_lock in rcu_walk mode,
+                 * just testing 'AUTOFS_INFO_NO_RCU' is enough.
+                 * simple_empty() takes a spinlock, so leave it
+                 * to last.
+                 * We only return -EISDIR when certain this isn't
+                 * a mount-trap.
+                 */
+                struct inode *inode;
+                if (ino->flags & (AUTOFS_INF_EXPIRING | AUTOFS_INF_NO_RCU))
+                        return 0;
+                if (d_mountpoint(dentry))
+                        return 0;
+                inode = ACCESS_ONCE(dentry->d_inode);
+                if (inode && S_ISLNK(inode->i_mode))
+                        return -EISDIR;
+                if (list_empty(&dentry->d_subdirs))
+                        return 0;
+                if (!simple_empty(dentry))
+                        return -EISDIR;
+                return 0;
+        }
+
         spin_lock(&sbi->fs_lock);
         /*
          * If the dentry has been selected for expire while we slept
diff --git a/fs/befs/btree.c b/fs/befs/btree.c
index 9c7faa8a9288..0826e91dacda 100644
--- a/fs/befs/btree.c
+++ b/fs/befs/btree.c
@@ -78,11 +78,11 @@
 /*
  * In memory structure of each btree node
  */
-typedef struct {
+struct befs_btree_node {
         befs_host_btree_nodehead head;  /* head of node converted to cpu byteorder */
         struct buffer_head *bh;
         befs_btree_nodehead *od_node;   /* on disk node */
-} befs_btree_node;
+};
 
 /* local constants */
 static const befs_off_t befs_bt_inval = 0xffffffffffffffffULL;
@@ -90,27 +90,30 @@ static const befs_off_t befs_bt_inval = 0xffffffffffffffffULL;
 /* local functions */
 static int befs_btree_seekleaf(struct super_block *sb, befs_data_stream * ds,
                                befs_btree_super * bt_super,
-                               befs_btree_node * this_node,
+                               struct befs_btree_node *this_node,
                                befs_off_t * node_off);
 
 static int befs_bt_read_super(struct super_block *sb, befs_data_stream * ds,
                               befs_btree_super * sup);
 
 static int befs_bt_read_node(struct super_block *sb, befs_data_stream * ds,
-                             befs_btree_node * node, befs_off_t node_off);
+                             struct befs_btree_node *node,
+                             befs_off_t node_off);
 
-static int befs_leafnode(befs_btree_node * node);
+static int befs_leafnode(struct befs_btree_node *node);
 
-static fs16 *befs_bt_keylen_index(befs_btree_node * node);
+static fs16 *befs_bt_keylen_index(struct befs_btree_node *node);
 
-static fs64 *befs_bt_valarray(befs_btree_node * node);
+static fs64 *befs_bt_valarray(struct befs_btree_node *node);
 
-static char *befs_bt_keydata(befs_btree_node * node);
+static char *befs_bt_keydata(struct befs_btree_node *node);
 
-static int befs_find_key(struct super_block *sb, befs_btree_node * node,
+static int befs_find_key(struct super_block *sb,
+                         struct befs_btree_node *node,
                          const char *findkey, befs_off_t * value);
 
-static char *befs_bt_get_key(struct super_block *sb, befs_btree_node * node,
+static char *befs_bt_get_key(struct super_block *sb,
+                             struct befs_btree_node *node,
                              int index, u16 * keylen);
 
 static int befs_compare_strings(const void *key1, int keylen1,
@@ -191,7 +194,7 @@ befs_bt_read_super(struct super_block *sb, befs_data_stream * ds,
 
 static int
 befs_bt_read_node(struct super_block *sb, befs_data_stream * ds,
-                  befs_btree_node * node, befs_off_t node_off)
+                  struct befs_btree_node *node, befs_off_t node_off)
 {
         uint off = 0;
 
@@ -247,7 +250,7 @@ int
 befs_btree_find(struct super_block *sb, befs_data_stream * ds,
                 const char *key, befs_off_t * value)
 {
-        befs_btree_node *this_node = NULL;
+        struct befs_btree_node *this_node = NULL;
         befs_btree_super bt_super;
         befs_off_t node_off;
         int res;
@@ -260,11 +263,11 @@ befs_btree_find(struct super_block *sb, befs_data_stream * ds,
                 goto error;
         }
 
-        this_node = kmalloc(sizeof (befs_btree_node),
+        this_node = kmalloc(sizeof(struct befs_btree_node),
                                                 GFP_NOFS);
         if (!this_node) {
                 befs_error(sb, "befs_btree_find() failed to allocate %zu "
-                           "bytes of memory", sizeof (befs_btree_node));
+                           "bytes of memory", sizeof(struct befs_btree_node));
                 goto error;
         }
 
@@ -333,7 +336,7 @@ befs_btree_find(struct super_block *sb, befs_data_stream * ds,
  * Use binary search instead of a linear.
  */
 static int
-befs_find_key(struct super_block *sb, befs_btree_node * node,
+befs_find_key(struct super_block *sb, struct befs_btree_node *node,
               const char *findkey, befs_off_t * value)
 {
         int first, last, mid;
@@ -417,7 +420,7 @@ befs_btree_read(struct super_block *sb, befs_data_stream * ds,
                 loff_t key_no, size_t bufsize, char *keybuf, size_t * keysize,
                 befs_off_t * value)
 {
-        befs_btree_node *this_node;
+        struct befs_btree_node *this_node;
         befs_btree_super bt_super;
         befs_off_t node_off = 0;
         int cur_key;
@@ -436,9 +439,10 @@ befs_btree_read(struct super_block *sb, befs_data_stream * ds,
                 goto error;
         }
 
-        if ((this_node = kmalloc(sizeof (befs_btree_node), GFP_NOFS)) == NULL) {
+        this_node = kmalloc(sizeof(struct befs_btree_node), GFP_NOFS);
+        if (this_node == NULL) {
                 befs_error(sb, "befs_btree_read() failed to allocate %zu "
-                           "bytes of memory", sizeof (befs_btree_node));
+                           "bytes of memory", sizeof(struct befs_btree_node));
                 goto error;
         }
 
@@ -545,7 +549,8 @@ befs_btree_read(struct super_block *sb, befs_data_stream * ds,
  */
 static int
 befs_btree_seekleaf(struct super_block *sb, befs_data_stream * ds,
-                    befs_btree_super * bt_super, befs_btree_node * this_node,
+                    befs_btree_super *bt_super,
+                    struct befs_btree_node *this_node,
                     befs_off_t * node_off)
 {
 
@@ -600,7 +605,7 @@ befs_btree_seekleaf(struct super_block *sb, befs_data_stream * ds,
  * Return 1 if leaf, 0 if interior
  */
 static int
-befs_leafnode(befs_btree_node * node)
+befs_leafnode(struct befs_btree_node *node)
 {
         /* all interior nodes (and only interior nodes) have an overflow node */
         if (node->head.overflow == befs_bt_inval)
@@ -623,7 +628,7 @@ befs_leafnode(befs_btree_node * node)
  * Except that rounding up to 8 works, and rounding up to 4 doesn't.
  */
 static fs16 *
-befs_bt_keylen_index(befs_btree_node * node)
+befs_bt_keylen_index(struct befs_btree_node *node)
 {
         const int keylen_align = 8;
         unsigned long int off =
@@ -644,7 +649,7 @@ befs_bt_keylen_index(befs_btree_node * node)
  * of the node pointed to by the node header
  */
 static fs64 *
-befs_bt_valarray(befs_btree_node * node)
+befs_bt_valarray(struct befs_btree_node *node)
 {
         void *keylen_index_start = (void *) befs_bt_keylen_index(node);
         size_t keylen_index_size = node->head.all_key_count * sizeof (fs16);
@@ -660,7 +665,7 @@ befs_bt_valarray(befs_btree_node * node)
  * of the node pointed to by the node header 
  */
 static char *
-befs_bt_keydata(befs_btree_node * node)
+befs_bt_keydata(struct befs_btree_node *node)
 {
         return (char *) ((void *) node->od_node + sizeof (befs_btree_nodehead));
 }
@@ -676,7 +681,7 @@ befs_bt_keydata(befs_btree_node * node)
  * Returns NULL on failure (bad input) and sets *@keylen = 0
  */
 static char *
-befs_bt_get_key(struct super_block *sb, befs_btree_node * node,
+befs_bt_get_key(struct super_block *sb, struct befs_btree_node *node,
                 int index, u16 * keylen)
 {
         int prev_key_end;
diff --git a/fs/binfmt_misc.c b/fs/binfmt_misc.c
index b60500300dd7..fd8beb9657a2 100644
--- a/fs/binfmt_misc.c
+++ b/fs/binfmt_misc.c
@@ -62,7 +62,22 @@ static struct file_system_type bm_fs_type;
 static struct vfsmount *bm_mnt;
 static int entry_count;
 
-/* 
+/*
+ * Max length of the register string.  Determined by:
+ *  - 7 delimiters
+ *  - name:   ~50 bytes
+ *  - type:   1 byte
+ *  - offset: 3 bytes (has to be smaller than BINPRM_BUF_SIZE)
+ *  - magic:  128 bytes (512 in escaped form)
+ *  - mask:   128 bytes (512 in escaped form)
+ *  - interp: ~50 bytes
+ *  - flags:  5 bytes
+ * Round that up a bit, and then back off to hold the internal data
+ * (like struct Node).
+ */
+#define MAX_REGISTER_LENGTH 1920
+
+/*
  * Check if we support the binfmt
  * if we do, return the node, else NULL
  * locking is done in load_misc_binary
@@ -279,7 +294,7 @@ static Node *create_entry(const char __user *buffer, size_t count)
 
         /* some sanity checks */
         err = -EINVAL;
-        if ((count < 11) || (count > 256))
+        if ((count < 11) || (count > MAX_REGISTER_LENGTH))
                 goto out;
 
         err = -ENOMEM;
@@ -396,12 +411,12 @@ static int parse_command(const char __user *buffer, size_t count)
 {
         char s[4];
 
-        if (!count)
-                return 0;
         if (count > 3)
                 return -EINVAL;
         if (copy_from_user(s, buffer, count))
                 return -EFAULT;
+        if (!count)
+                return 0;
         if (s[count-1] == '\n')
                 count--;
         if (count == 1 && s[0] == '0')
diff --git a/fs/buffer.c b/fs/buffer.c
index d1f704806264..9614adc7e754 100644
--- a/fs/buffer.c
+++ b/fs/buffer.c
@@ -1331,8 +1331,8 @@ lookup_bh_lru(struct block_device *bdev, sector_t block, unsigned size)
         for (i = 0; i < BH_LRU_SIZE; i++) {
                 struct buffer_head *bh = __this_cpu_read(bh_lrus.bhs[i]);
 
-                if (bh && bh->b_bdev == bdev &&
-                                bh->b_blocknr == block && bh->b_size == size) {
+                if (bh && bh->b_blocknr == block && bh->b_bdev == bdev &&
+                    bh->b_size == size) {
                         if (i) {
                                 while (i) {
                                         __this_cpu_write(bh_lrus.bhs[i],
diff --git a/fs/cifs/cifs_dfs_ref.c b/fs/cifs/cifs_dfs_ref.c
index 58df174deb10..b8602f199815 100644
--- a/fs/cifs/cifs_dfs_ref.c
+++ b/fs/cifs/cifs_dfs_ref.c
@@ -195,15 +195,15 @@ char *cifs_compose_mount_options(const char *sb_mountdata,
                 else
                         noff = tkn_e - (sb_mountdata + off) + 1;
 
-                if (strnicmp(sb_mountdata + off, "unc=", 4) == 0) {
+                if (strncasecmp(sb_mountdata + off, "unc=", 4) == 0) {
                         off += noff;
                         continue;
                 }
-                if (strnicmp(sb_mountdata + off, "ip=", 3) == 0) {
+                if (strncasecmp(sb_mountdata + off, "ip=", 3) == 0) {
                         off += noff;
                         continue;
                 }
-                if (strnicmp(sb_mountdata + off, "prefixpath=", 11) == 0) {
+                if (strncasecmp(sb_mountdata + off, "prefixpath=", 11) == 0) {
                         off += noff;
                         continue;
                 }
diff --git a/fs/cifs/connect.c b/fs/cifs/connect.c
index 36ca2045009b..239e1fb33000 100644
--- a/fs/cifs/connect.c
+++ b/fs/cifs/connect.c
@@ -1718,7 +1718,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                                 goto cifs_parse_mount_err;
                         }
 
-                         if (strnicmp(string, "default", 7) != 0) {
+                         if (strncasecmp(string, "default", 7) != 0) {
                                 vol->iocharset = kstrdup(string,
                                                          GFP_KERNEL);
                                 if (!vol->iocharset) {
@@ -1790,7 +1790,7 @@ cifs_parse_mount_options(const char *mountdata, const char *devname,
                         if (string == NULL)
                                 goto out_nomem;
 
-                        if (strnicmp(string, "1", 1) == 0) {
+                        if (strncasecmp(string, "1", 1) == 0) {
                                 /* This is the default */
                                 break;
                         }
diff --git a/fs/coredump.c b/fs/coredump.c
index a93f7e6ea4cf..b5c86ffd5033 100644
--- a/fs/coredump.c
+++ b/fs/coredump.c
@@ -199,6 +199,14 @@ static int format_corename(struct core_name *cn, struct coredump_params *cprm)
                                 err = cn_printf(cn, "%d",
                                               task_tgid_nr(current));
                                 break;
+                        case 'i':
+                                err = cn_printf(cn, "%d",
+                                              task_pid_vnr(current));
+                                break;
+                        case 'I':
+                                err = cn_printf(cn, "%d",
+                                              task_pid_nr(current));
+                                break;
                         /* uid */
                         case 'u':
                                 err = cn_printf(cn, "%d", cred->uid);
diff --git a/fs/fat/misc.c b/fs/fat/misc.c
index 628e22a5a543..d8da2d2e30ae 100644
--- a/fs/fat/misc.c
+++ b/fs/fat/misc.c
@@ -164,8 +164,6 @@ int fat_chain_add(struct inode *inode, int new_dclus, int nr_cluster)
         return 0;
 }
 
-extern struct timezone sys_tz;
-
 /*
  * The epoch of FAT timestamp is 1980.
  *     :  bits :     value
diff --git a/fs/hfs/hfs_fs.h b/fs/hfs/hfs_fs.h
index 0524cda47a6e..95d255219b1e 100644
--- a/fs/hfs/hfs_fs.h
+++ b/fs/hfs/hfs_fs.h
@@ -242,8 +242,6 @@ extern int hfs_mac2asc(struct super_block *, char *, const struct hfs_name *);
 /* super.c */
 extern void hfs_mark_mdb_dirty(struct super_block *sb);
 
-extern struct timezone sys_tz;
-
 /*
  * There are two time systems.  Both are based on seconds since
  * a particular time/date.
diff --git a/fs/isofs/inode.c b/fs/isofs/inode.c
index 5ddaf8625d3b..881b3bd0143f 100644
--- a/fs/isofs/inode.c
+++ b/fs/isofs/inode.c
@@ -247,7 +247,7 @@ static int isofs_dentry_cmp_common(
         }
         if (alen == blen) {
                 if (ci) {
-                        if (strnicmp(name->name, str, alen) == 0)
+                        if (strncasecmp(name->name, str, alen) == 0)
                                 return 0;
                 } else {
                         if (strncmp(name->name, str, alen) == 0)
diff --git a/fs/ncpfs/dir.c b/fs/ncpfs/dir.c
index 314e7add99b8..7cb751dfbeef 100644
--- a/fs/ncpfs/dir.c
+++ b/fs/ncpfs/dir.c
@@ -1178,9 +1178,6 @@ static int day_n[] =
 {0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 0, 0, 0, 0};
 /* Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec */
 
-
-extern struct timezone sys_tz;
-
 static int utc2local(int time)
 {
         return time - sys_tz.tz_minuteswest * 60;
diff --git a/fs/nilfs2/file.c b/fs/nilfs2/file.c
index 24978153c0c4..e9e3325f29f3 100644
--- a/fs/nilfs2/file.c
+++ b/fs/nilfs2/file.c
@@ -56,11 +56,9 @@ int nilfs_sync_file(struct file *file, loff_t start, loff_t end, int datasync)
         mutex_unlock(&inode->i_mutex);
 
         nilfs = inode->i_sb->s_fs_info;
-        if (!err && nilfs_test_opt(nilfs, BARRIER)) {
-                err = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
-                if (err != -EIO)
-                        err = 0;
-        }
+        if (!err)
+                err = nilfs_flush_device(nilfs);
+
         return err;
 }
 
diff --git a/fs/nilfs2/inode.c b/fs/nilfs2/inode.c
index d071e7f23de2..e1fa69b341b9 100644
--- a/fs/nilfs2/inode.c
+++ b/fs/nilfs2/inode.c
@@ -126,7 +126,7 @@ int nilfs_get_block(struct inode *inode, sector_t blkoff,
                         nilfs_transaction_abort(inode->i_sb);
                         goto out;
                 }
-                nilfs_mark_inode_dirty(inode);
+                nilfs_mark_inode_dirty_sync(inode);
                 nilfs_transaction_commit(inode->i_sb); /* never fails */
                 /* Error handling should be detailed */
                 set_buffer_new(bh_result);
@@ -672,7 +672,7 @@ void nilfs_write_inode_common(struct inode *inode,
            for substitutions of appended fields */
 }
 
-void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh)
+void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh, int flags)
 {
         ino_t ino = inode->i_ino;
         struct nilfs_inode_info *ii = NILFS_I(inode);
@@ -683,7 +683,8 @@ void nilfs_update_inode(struct inode *inode, struct buffer_head *ibh)
 
         if (test_and_clear_bit(NILFS_I_NEW, &ii->i_state))
                 memset(raw_inode, 0, NILFS_MDT(ifile)->mi_entry_size);
-        set_bit(NILFS_I_INODE_DIRTY, &ii->i_state);
+        if (flags & I_DIRTY_DATASYNC)
+                set_bit(NILFS_I_INODE_SYNC, &ii->i_state);
 
         nilfs_write_inode_common(inode, raw_inode, 0);
                 /* XXX: call with has_bmap = 0 is a workaround to avoid
@@ -939,7 +940,7 @@ int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty)
         return 0;
 }
 
-int nilfs_mark_inode_dirty(struct inode *inode)
+int __nilfs_mark_inode_dirty(struct inode *inode, int flags)
 {
         struct buffer_head *ibh;
         int err;
@@ -950,7 +951,7 @@ int nilfs_mark_inode_dirty(struct inode *inode)
                               "failed to reget inode block.\n");
                 return err;
         }
-        nilfs_update_inode(inode, ibh);
+        nilfs_update_inode(inode, ibh, flags);
         mark_buffer_dirty(ibh);
         nilfs_mdt_mark_dirty(NILFS_I(inode)->i_root->ifile);
         brelse(ibh);
@@ -983,7 +984,7 @@ void nilfs_dirty_inode(struct inode *inode, int flags)
                 return;
         }
         nilfs_transaction_begin(inode->i_sb, &ti, 0);
-        nilfs_mark_inode_dirty(inode);
+        __nilfs_mark_inode_dirty(inode, flags);
         nilfs_transaction_commit(inode->i_sb); /* never fails */
 }
 
diff --git a/fs/nilfs2/ioctl.c b/fs/nilfs2/ioctl.c
index 422fb54b7377..9a20e513d7eb 100644
--- a/fs/nilfs2/ioctl.c
+++ b/fs/nilfs2/ioctl.c
@@ -1022,11 +1022,9 @@ static int nilfs_ioctl_sync(struct inode *inode, struct file *filp,
                 return ret;
 
         nilfs = inode->i_sb->s_fs_info;
-        if (nilfs_test_opt(nilfs, BARRIER)) {
-                ret = blkdev_issue_flush(inode->i_sb->s_bdev, GFP_KERNEL, NULL);
-                if (ret == -EIO)
-                        return ret;
-        }
+        ret = nilfs_flush_device(nilfs);
+        if (ret < 0)
+                return ret;
 
         if (argp != NULL) {
                 down_read(&nilfs->ns_segctor_sem);
diff --git a/fs/nilfs2/nilfs.h b/fs/nilfs2/nilfs.h
index 0696161bf59d..91093cd74f0d 100644
--- a/fs/nilfs2/nilfs.h
+++ b/fs/nilfs2/nilfs.h
@@ -104,7 +104,7 @@ enum {
                                            constructor */
         NILFS_I_COLLECTED,              /* All dirty blocks are collected */
         NILFS_I_UPDATED,                /* The file has been written back */
-        NILFS_I_INODE_DIRTY,            /* write_inode is requested */
+        NILFS_I_INODE_SYNC,             /* dsync is not allowed for inode */
         NILFS_I_BMAP,                   /* has bmap and btnode_cache */
         NILFS_I_GCINODE,                /* inode for GC, on memory only */
 };
@@ -273,7 +273,7 @@ struct inode *nilfs_iget(struct super_block *sb, struct nilfs_root *root,
                          unsigned long ino);
 extern struct inode *nilfs_iget_for_gc(struct super_block *sb,
                                        unsigned long ino, __u64 cno);
-extern void nilfs_update_inode(struct inode *, struct buffer_head *);
+extern void nilfs_update_inode(struct inode *, struct buffer_head *, int);
 extern void nilfs_truncate(struct inode *);
 extern void nilfs_evict_inode(struct inode *);
 extern int nilfs_setattr(struct dentry *, struct iattr *);
@@ -282,10 +282,18 @@ int nilfs_permission(struct inode *inode, int mask);
 int nilfs_load_inode_block(struct inode *inode, struct buffer_head **pbh);
 extern int nilfs_inode_dirty(struct inode *);
 int nilfs_set_file_dirty(struct inode *inode, unsigned nr_dirty);
-extern int nilfs_mark_inode_dirty(struct inode *);
+extern int __nilfs_mark_inode_dirty(struct inode *, int);
 extern void nilfs_dirty_inode(struct inode *, int flags);
 int nilfs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                  __u64 start, __u64 len);
+static inline int nilfs_mark_inode_dirty(struct inode *inode)
+{
+        return __nilfs_mark_inode_dirty(inode, I_DIRTY);
+}
+static inline int nilfs_mark_inode_dirty_sync(struct inode *inode)
+{
+        return __nilfs_mark_inode_dirty(inode, I_DIRTY_SYNC);
+}
 
 /* super.c */
 extern struct inode *nilfs_alloc_inode(struct super_block *);
diff --git a/fs/nilfs2/segment.c b/fs/nilfs2/segment.c
index a1a191634abc..7ef18fc656c2 100644
--- a/fs/nilfs2/segment.c
+++ b/fs/nilfs2/segment.c
@@ -930,7 +930,7 @@ static void nilfs_drop_collected_inodes(struct list_head *head)
                 if (!test_and_clear_bit(NILFS_I_COLLECTED, &ii->i_state))
                         continue;
 
-                clear_bit(NILFS_I_INODE_DIRTY, &ii->i_state);
+                clear_bit(NILFS_I_INODE_SYNC, &ii->i_state);
                 set_bit(NILFS_I_UPDATED, &ii->i_state);
         }
 }
@@ -1833,6 +1833,7 @@ static void nilfs_segctor_complete_write(struct nilfs_sc_info *sci)
         nilfs_set_next_segment(nilfs, segbuf);
 
         if (update_sr) {
+                nilfs->ns_flushed_device = 0;
                 nilfs_set_last_segment(nilfs, segbuf->sb_pseg_start,
                                        segbuf->sb_sum.seg_seq, nilfs->ns_cno++);
 
@@ -2194,7 +2195,7 @@ int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode,
         nilfs_transaction_lock(sb, &ti, 0);
 
         ii = NILFS_I(inode);
-        if (test_bit(NILFS_I_INODE_DIRTY, &ii->i_state) ||
+        if (test_bit(NILFS_I_INODE_SYNC, &ii->i_state) ||
             nilfs_test_opt(nilfs, STRICT_ORDER) ||
             test_bit(NILFS_SC_UNCLOSED, &sci->sc_flags) ||
             nilfs_discontinued(nilfs)) {
@@ -2216,6 +2217,8 @@ int nilfs_construct_dsync_segment(struct super_block *sb, struct inode *inode,
         sci->sc_dsync_end = end;
 
         err = nilfs_segctor_do_construct(sci, SC_LSEG_DSYNC);
+        if (!err)
+                nilfs->ns_flushed_device = 0;
 
         nilfs_transaction_unlock(sb);
         return err;
diff --git a/fs/nilfs2/super.c b/fs/nilfs2/super.c
index 228f5bdf0772..2e5b3ec85b8f 100644
--- a/fs/nilfs2/super.c
+++ b/fs/nilfs2/super.c
@@ -310,6 +310,9 @@ int nilfs_commit_super(struct super_block *sb, int flag)
                                             nilfs->ns_sbsize));
         }
         clear_nilfs_sb_dirty(nilfs);
+        nilfs->ns_flushed_device = 1;
+        /* make sure store to ns_flushed_device cannot be reordered */
+        smp_wmb();
         return nilfs_sync_super(sb, flag);
 }
 
@@ -514,6 +517,9 @@ static int nilfs_sync_fs(struct super_block *sb, int wait)
         }
         up_write(&nilfs->ns_sem);
 
+        if (!err)
+                err = nilfs_flush_device(nilfs);
+
         return err;
 }
 
diff --git a/fs/nilfs2/the_nilfs.h b/fs/nilfs2/the_nilfs.h
index d01ead1bea9a..23778d385836 100644
--- a/fs/nilfs2/the_nilfs.h
+++ b/fs/nilfs2/the_nilfs.h
@@ -46,6 +46,7 @@ enum {
 /**
  * struct the_nilfs - struct to supervise multiple nilfs mount points
  * @ns_flags: flags
+ * @ns_flushed_device: flag indicating if all volatile data was flushed
  * @ns_bdev: block device
  * @ns_sem: semaphore for shared states
  * @ns_snapshot_mount_mutex: mutex to protect snapshot mounts
@@ -103,6 +104,7 @@ enum {
  */
 struct the_nilfs {
         unsigned long           ns_flags;
+        int                     ns_flushed_device;
 
         struct block_device    *ns_bdev;
         struct rw_semaphore     ns_sem;
@@ -371,4 +373,24 @@ static inline int nilfs_segment_is_active(struct the_nilfs *nilfs, __u64 n)
         return n == nilfs->ns_segnum || n == nilfs->ns_nextnum;
 }
 
+static inline int nilfs_flush_device(struct the_nilfs *nilfs)
+{
+        int err;
+
+        if (!nilfs_test_opt(nilfs, BARRIER) || nilfs->ns_flushed_device)
+                return 0;
+
+        nilfs->ns_flushed_device = 1;
+        /*
+         * the store to ns_flushed_device must not be reordered after
+         * blkdev_issue_flush().
+         */
+        smp_wmb();
+
+        err = blkdev_issue_flush(nilfs->ns_bdev, GFP_KERNEL, NULL);
+        if (err != -EIO)
+                err = 0;
+        return err;
+}
+
 #endif /* _THE_NILFS_H */
diff --git a/fs/ocfs2/cluster/heartbeat.c b/fs/ocfs2/cluster/heartbeat.c
index d13385448168..eb9d48746ab4 100644
--- a/fs/ocfs2/cluster/heartbeat.c
+++ b/fs/ocfs2/cluster/heartbeat.c
@@ -2244,7 +2244,7 @@ ssize_t o2hb_heartbeat_group_mode_store(struct o2hb_heartbeat_group *group,
                 return -EINVAL;
 
         for (i = 0; i < O2HB_HEARTBEAT_NUM_MODES; ++i) {
-                if (strnicmp(page, o2hb_heartbeat_mode_desc[i], len))
+                if (strncasecmp(page, o2hb_heartbeat_mode_desc[i], len))
                         continue;
 
                 ret = o2hb_global_heartbeat_mode_set(i);
diff --git a/fs/ocfs2/cluster/masklog.c b/fs/ocfs2/cluster/masklog.c
index 07ac24fd9252..af7598bff1b5 100644
--- a/fs/ocfs2/cluster/masklog.c
+++ b/fs/ocfs2/cluster/masklog.c
@@ -49,13 +49,13 @@ static ssize_t mlog_mask_show(u64 mask, char *buf)
 
 static ssize_t mlog_mask_store(u64 mask, const char *buf, size_t count)
 {
-        if (!strnicmp(buf, "allow", 5)) {
+        if (!strncasecmp(buf, "allow", 5)) {
                 __mlog_set_u64(mask, mlog_and_bits);
                 __mlog_clear_u64(mask, mlog_not_bits);
-        } else if (!strnicmp(buf, "deny", 4)) {
+        } else if (!strncasecmp(buf, "deny", 4)) {
                 __mlog_set_u64(mask, mlog_not_bits);
                 __mlog_clear_u64(mask, mlog_and_bits);
-        } else if (!strnicmp(buf, "off", 3)) {
+        } else if (!strncasecmp(buf, "off", 3)) {
                 __mlog_clear_u64(mask, mlog_not_bits);
                 __mlog_clear_u64(mask, mlog_and_bits);
         } else
diff --git a/fs/omfs/inode.c b/fs/omfs/inode.c
index ba8819702c56..138321b0c6c2 100644
--- a/fs/omfs/inode.c
+++ b/fs/omfs/inode.c
@@ -306,9 +306,7 @@ static const struct super_operations omfs_sops = {
  */
 static int omfs_get_imap(struct super_block *sb)
 {
-        int bitmap_size;
-        int array_size;
-        int count;
+        unsigned int bitmap_size, count, array_size;
         struct omfs_sb_info *sbi = OMFS_SB(sb);
         struct buffer_head *bh;
         unsigned long **ptr;
@@ -473,6 +471,12 @@ static int omfs_fill_super(struct super_block *sb, void *data, int silent)
         sbi->s_sys_blocksize = be32_to_cpu(omfs_sb->s_sys_blocksize);
         mutex_init(&sbi->s_bitmap_lock);
 
+        if (sbi->s_num_blocks > OMFS_MAX_BLOCKS) {
+                printk(KERN_ERR "omfs: sysblock number (%llx) is out of range\n",
+                       (unsigned long long)sbi->s_num_blocks);
+                goto out_brelse_bh;
+        }
+
         if (sbi->s_sys_blocksize > PAGE_SIZE) {
                 printk(KERN_ERR "omfs: sysblock size (%d) is out of range\n",
                         sbi->s_sys_blocksize);
diff --git a/fs/omfs/omfs_fs.h b/fs/omfs/omfs_fs.h
index ee5e4327de92..83a98330ed66 100644
--- a/fs/omfs/omfs_fs.h
+++ b/fs/omfs/omfs_fs.h
@@ -18,6 +18,7 @@
 #define OMFS_XOR_COUNT 19
 #define OMFS_MAX_BLOCK_SIZE 8192
 #define OMFS_MAX_CLUSTER_SIZE 8
+#define OMFS_MAX_BLOCKS (1ul << 31)
 
 struct omfs_super_block {
         char s_fill1[256];
diff --git a/fs/proc/task_mmu.c b/fs/proc/task_mmu.c
index b7a7dc963a35..4e0388cffe3d 100644
--- a/fs/proc/task_mmu.c
+++ b/fs/proc/task_mmu.c
@@ -827,8 +827,21 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                         .private = &cp,
                 };
                 down_read(&mm->mmap_sem);
-                if (type == CLEAR_REFS_SOFT_DIRTY)
+                if (type == CLEAR_REFS_SOFT_DIRTY) {
+                        for (vma = mm->mmap; vma; vma = vma->vm_next) {
+                                if (!(vma->vm_flags & VM_SOFTDIRTY))
+                                        continue;
+                                up_read(&mm->mmap_sem);
+                                down_write(&mm->mmap_sem);
+                                for (vma = mm->mmap; vma; vma = vma->vm_next) {
+                                        vma->vm_flags &= ~VM_SOFTDIRTY;
+                                        vma_set_page_prot(vma);
+                                }
+                                downgrade_write(&mm->mmap_sem);
+                                break;
+                        }
                         mmu_notifier_invalidate_range_start(mm, 0, -1);
+                }
                 for (vma = mm->mmap; vma; vma = vma->vm_next) {
                         cp.vma = vma;
                         if (is_vm_hugetlb_page(vma))
@@ -848,10 +861,6 @@ static ssize_t clear_refs_write(struct file *file, const char __user *buf,
                                 continue;
                         if (type == CLEAR_REFS_MAPPED && !vma->vm_file)
                                 continue;
-                        if (type == CLEAR_REFS_SOFT_DIRTY) {
-                                if (vma->vm_flags & VM_SOFTDIRTY)
-                                        vma->vm_flags &= ~VM_SOFTDIRTY;
-                        }
                         walk_page_range(vma->vm_start, vma->vm_end,
                                         &clear_refs_walk);
                 }
diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index a88b1b3e7db3..d571e173a990 100644
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -699,11 +699,13 @@ static int add_to_chunk(struct buffer_chunk *chunk, struct buffer_head *bh,
         chunk->bh[chunk->nr++] = bh;
         if (chunk->nr >= CHUNK_SIZE) {
                 ret = 1;
-                if (lock)
+                if (lock) {
                         spin_unlock(lock);
-                fn(chunk);
-                if (lock)
+                        fn(chunk);
                         spin_lock(lock);
+                } else {
+                        fn(chunk);
+                }
         }
         return ret;
 }
diff --git a/fs/ufs/balloc.c b/fs/ufs/balloc.c
index 7bc20809c99e..2c1036080d52 100644
--- a/fs/ufs/balloc.c
+++ b/fs/ufs/balloc.c
@@ -784,7 +784,6 @@ static u64 ufs_bitmap_search(struct super_block *sb,
                 0x0, 0x2, 0x6, 0xe, 0x1e, 0x3e, 0x7e, 0xfe, 0x1fe
         };
         struct ufs_sb_private_info *uspi = UFS_SB(sb)->s_uspi;
-        struct ufs_cylinder_group *ucg;
         unsigned start, length, loc;
         unsigned pos, want, blockmap, mask, end;
         u64 result;
@@ -792,8 +791,6 @@ static u64 ufs_bitmap_search(struct super_block *sb,
         UFSD("ENTER, cg %u, goal %llu, count %u\n", ucpi->c_cgx,
              (unsigned long long)goal, count);
 
-        ucg = ubh_get_ucg(UCPI_UBH(ucpi));
-
         if (goal)
                 start = ufs_dtogd(uspi, goal) >> 3;
         else