Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/viro/vfs-2.6: (107 commits)
  vfs: use ERR_CAST for err-ptr tossing in lookup_instantiate_filp
  isofs: Remove global fs lock
  jffs2: fix IN_DELETE_SELF on overwriting rename() killing a directory
  fix IN_DELETE_SELF on overwriting rename() on ramfs et.al.
  mm/truncate.c: fix build for CONFIG_BLOCK not enabled
  fs:update the NOTE of the file_operations structure
  Remove dead code in dget_parent()
  AFS: Fix silly characters in a comment
  switch d_add_ci() to d_splice_alias() in "found negative" case as well
  simplify gfs2_lookup()
  jfs_lookup(): don't bother with . or ..
  get rid of useless dget_parent() in btrfs rename() and link()
  get rid of useless dget_parent() in fs/btrfs/ioctl.c
  fs: push i_mutex and filemap_write_and_wait down into ->fsync() handlers
  drivers: fix up various ->llseek() implementations
  fs: handle SEEK_HOLE/SEEK_DATA properly in all fs's that define their own llseek
  Ext4: handle SEEK_HOLE/SEEK_DATA generically
  Btrfs: implement our own ->llseek
  fs: add SEEK_HOLE and SEEK_DATA flags
  reiserfs: make reiserfs default to barrier=flush
  ...

Fix up trivial conflicts in fs/xfs/linux-2.6/xfs_super.c due to the new
shrinker callout for the inode cache, that clashed with the xfs code to
start the periodic workers later.

13 files changed, 259 insertions, 175 deletions

diff --git a/drivers/base/devtmpfs.c b/drivers/base/devtmpfs.c
index 82bbb5967aa9..6d678c99512e 100644
--- a/drivers/base/devtmpfs.c
+++ b/drivers/base/devtmpfs.c
@@ -21,12 +21,11 @@
 #include <linux/fs.h>
 #include <linux/shmem_fs.h>
 #include <linux/ramfs.h>
-#include <linux/cred.h>
 #include <linux/sched.h>
-#include <linux/init_task.h>
 #include <linux/slab.h>
+#include <linux/kthread.h>
 
-static struct vfsmount *dev_mnt;
+static struct task_struct *thread;
 
 #if defined CONFIG_DEVTMPFS_MOUNT
 static int mount_dev = 1;
@@ -34,7 +33,16 @@ static int mount_dev = 1;
 static int mount_dev;
 #endif
 
-static DEFINE_MUTEX(dirlock);
+static DEFINE_SPINLOCK(req_lock);
+
+static struct req {
+        struct req *next;
+        struct completion done;
+        int err;
+        const char *name;
+        mode_t mode;    /* 0 => delete */
+        struct device *dev;
+} *requests;
 
 static int __init mount_param(char *str)
 {
@@ -68,131 +76,152 @@ static inline int is_blockdev(struct device *dev)
 static inline int is_blockdev(struct device *dev) { return 0; }
 #endif
 
+int devtmpfs_create_node(struct device *dev)
+{
+        const char *tmp = NULL;
+        struct req req;
+
+        if (!thread)
+                return 0;
+
+        req.mode = 0;
+        req.name = device_get_devnode(dev, &req.mode, &tmp);
+        if (!req.name)
+                return -ENOMEM;
+
+        if (req.mode == 0)
+                req.mode = 0600;
+        if (is_blockdev(dev))
+                req.mode |= S_IFBLK;
+        else
+                req.mode |= S_IFCHR;
+
+        req.dev = dev;
+
+        init_completion(&req.done);
+
+        spin_lock(&req_lock);
+        req.next = requests;
+        requests = &req;
+        spin_unlock(&req_lock);
+
+        wake_up_process(thread);
+        wait_for_completion(&req.done);
+
+        kfree(tmp);
+
+        return req.err;
+}
+
+int devtmpfs_delete_node(struct device *dev)
+{
+        const char *tmp = NULL;
+        struct req req;
+
+        if (!thread)
+                return 0;
+
+        req.name = device_get_devnode(dev, NULL, &tmp);
+        if (!req.name)
+                return -ENOMEM;
+
+        req.mode = 0;
+        req.dev = dev;
+
+        init_completion(&req.done);
+
+        spin_lock(&req_lock);
+        req.next = requests;
+        requests = &req;
+        spin_unlock(&req_lock);
+
+        wake_up_process(thread);
+        wait_for_completion(&req.done);
+
+        kfree(tmp);
+        return req.err;
+}
+
 static int dev_mkdir(const char *name, mode_t mode)
 {
-        struct nameidata nd;
         struct dentry *dentry;
+        struct path path;
         int err;
 
-        err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
-                              name, LOOKUP_PARENT, &nd);
-        if (err)
-                return err;
-
-        dentry = lookup_create(&nd, 1);
-        if (!IS_ERR(dentry)) {
-                err = vfs_mkdir(nd.path.dentry->d_inode, dentry, mode);
-                if (!err)
-                        /* mark as kernel-created inode */
-                        dentry->d_inode->i_private = &dev_mnt;
-                dput(dentry);
-        } else {
-                err = PTR_ERR(dentry);
-        }
-
-        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
-        path_put(&nd.path);
+        dentry = kern_path_create(AT_FDCWD, name, &path, 1);
+        if (IS_ERR(dentry))
+                return PTR_ERR(dentry);
+
+        err = vfs_mkdir(path.dentry->d_inode, dentry, mode);
+        if (!err)
+                /* mark as kernel-created inode */
+                dentry->d_inode->i_private = &thread;
+        dput(dentry);
+        mutex_unlock(&path.dentry->d_inode->i_mutex);
+        path_put(&path);
         return err;
 }
 
 static int create_path(const char *nodepath)
 {
+        char *path;
+        char *s;
         int err;
 
-        mutex_lock(&dirlock);
-        err = dev_mkdir(nodepath, 0755);
-        if (err == -ENOENT) {
-                char *path;
-                char *s;
-
-                /* parent directories do not exist, create them */
-                path = kstrdup(nodepath, GFP_KERNEL);
-                if (!path) {
-                        err = -ENOMEM;
-                        goto out;
-                }
-                s = path;
-                for (;;) {
-                        s = strchr(s, '/');
-                        if (!s)
-                                break;
-                        s[0] = '\0';
-                        err = dev_mkdir(path, 0755);
-                        if (err && err != -EEXIST)
-                                break;
-                        s[0] = '/';
-                        s++;
-                }
-                kfree(path);
+        /* parent directories do not exist, create them */
+        path = kstrdup(nodepath, GFP_KERNEL);
+        if (!path)
+                return -ENOMEM;
+
+        s = path;
+        for (;;) {
+                s = strchr(s, '/');
+                if (!s)
+                        break;
+                s[0] = '\0';
+                err = dev_mkdir(path, 0755);
+                if (err && err != -EEXIST)
+                        break;
+                s[0] = '/';
+                s++;
         }
-out:
-        mutex_unlock(&dirlock);
+        kfree(path);
         return err;
 }
 
-int devtmpfs_create_node(struct device *dev)
+static int handle_create(const char *nodename, mode_t mode, struct device *dev)
 {
-        const char *tmp = NULL;
-        const char *nodename;
-        const struct cred *curr_cred;
-        mode_t mode = 0;
-        struct nameidata nd;
         struct dentry *dentry;
+        struct path path;
         int err;
 
-        if (!dev_mnt)
-                return 0;
-
-        nodename = device_get_devnode(dev, &mode, &tmp);
-        if (!nodename)
-                return -ENOMEM;
-
-        if (mode == 0)
-                mode = 0600;
-        if (is_blockdev(dev))
-                mode |= S_IFBLK;
-        else
-                mode |= S_IFCHR;
-
-        curr_cred = override_creds(&init_cred);
-
-        err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
-                              nodename, LOOKUP_PARENT, &nd);
-        if (err == -ENOENT) {
+        dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
+        if (dentry == ERR_PTR(-ENOENT)) {
                 create_path(nodename);
-                err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
-                                      nodename, LOOKUP_PARENT, &nd);
+                dentry = kern_path_create(AT_FDCWD, nodename, &path, 0);
         }
-        if (err)
-                goto out;
-
-        dentry = lookup_create(&nd, 0);
-        if (!IS_ERR(dentry)) {
-                err = vfs_mknod(nd.path.dentry->d_inode,
-                                dentry, mode, dev->devt);
-                if (!err) {
-                        struct iattr newattrs;
-
-                        /* fixup possibly umasked mode */
-                        newattrs.ia_mode = mode;
-                        newattrs.ia_valid = ATTR_MODE;
-                        mutex_lock(&dentry->d_inode->i_mutex);
-                        notify_change(dentry, &newattrs);
-                        mutex_unlock(&dentry->d_inode->i_mutex);
-
-                        /* mark as kernel-created inode */
-                        dentry->d_inode->i_private = &dev_mnt;
-                }
-                dput(dentry);
-        } else {
-                err = PTR_ERR(dentry);
+        if (IS_ERR(dentry))
+                return PTR_ERR(dentry);
+
+        err = vfs_mknod(path.dentry->d_inode,
+                        dentry, mode, dev->devt);
+        if (!err) {
+                struct iattr newattrs;
+
+                /* fixup possibly umasked mode */
+                newattrs.ia_mode = mode;
+                newattrs.ia_valid = ATTR_MODE;
+                mutex_lock(&dentry->d_inode->i_mutex);
+                notify_change(dentry, &newattrs);
+                mutex_unlock(&dentry->d_inode->i_mutex);
+
+                /* mark as kernel-created inode */
+                dentry->d_inode->i_private = &thread;
         }
+        dput(dentry);
 
-        mutex_unlock(&nd.path.dentry->d_inode->i_mutex);
-        path_put(&nd.path);
-out:
-        kfree(tmp);
-        revert_creds(curr_cred);
+        mutex_unlock(&path.dentry->d_inode->i_mutex);
+        path_put(&path);
         return err;
 }
 
@@ -202,8 +231,7 @@ static int dev_rmdir(const char *name)
         struct dentry *dentry;
         int err;
 
-        err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
-                              name, LOOKUP_PARENT, &nd);
+        err = kern_path_parent(name, &nd);
         if (err)
                 return err;
 
@@ -211,7 +239,7 @@ static int dev_rmdir(const char *name)
         dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
         if (!IS_ERR(dentry)) {
                 if (dentry->d_inode) {
-                        if (dentry->d_inode->i_private == &dev_mnt)
+                        if (dentry->d_inode->i_private == &thread)
                                 err = vfs_rmdir(nd.path.dentry->d_inode,
                                                 dentry);
                         else
@@ -238,7 +266,6 @@ static int delete_path(const char *nodepath)
         if (!path)
                 return -ENOMEM;
 
-        mutex_lock(&dirlock);
         for (;;) {
                 char *base;
 
@@ -250,7 +277,6 @@ static int delete_path(const char *nodepath)
                 if (err)
                         break;
         }
-        mutex_unlock(&dirlock);
 
         kfree(path);
         return err;
@@ -259,7 +285,7 @@ static int delete_path(const char *nodepath)
 static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *stat)
 {
         /* did we create it */
-        if (inode->i_private != &dev_mnt)
+        if (inode->i_private != &thread)
                 return 0;
 
         /* does the dev_t match */
@@ -277,29 +303,17 @@ static int dev_mynode(struct device *dev, struct inode *inode, struct kstat *sta
         return 1;
 }
 
-int devtmpfs_delete_node(struct device *dev)
+static int handle_remove(const char *nodename, struct device *dev)
 {
-        const char *tmp = NULL;
-        const char *nodename;
-        const struct cred *curr_cred;
         struct nameidata nd;
         struct dentry *dentry;
         struct kstat stat;
         int deleted = 1;
         int err;
 
-        if (!dev_mnt)
-                return 0;
-
-        nodename = device_get_devnode(dev, NULL, &tmp);
-        if (!nodename)
-                return -ENOMEM;
-
-        curr_cred = override_creds(&init_cred);
-        err = vfs_path_lookup(dev_mnt->mnt_root, dev_mnt,
-                              nodename, LOOKUP_PARENT, &nd);
+        err = kern_path_parent(nodename, &nd);
         if (err)
-                goto out;
+                return err;
 
         mutex_lock_nested(&nd.path.dentry->d_inode->i_mutex, I_MUTEX_PARENT);
         dentry = lookup_one_len(nd.last.name, nd.path.dentry, nd.last.len);
@@ -337,9 +351,6 @@ int devtmpfs_delete_node(struct device *dev)
         path_put(&nd.path);
         if (deleted && strchr(nodename, '/'))
                 delete_path(nodename);
-out:
-        kfree(tmp);
-        revert_creds(curr_cred);
         return err;
 }
 
@@ -354,7 +365,7 @@ int devtmpfs_mount(const char *mntdir)
         if (!mount_dev)
                 return 0;
 
-        if (!dev_mnt)
+        if (!thread)
                 return 0;
 
         err = sys_mount("devtmpfs", (char *)mntdir, "devtmpfs", MS_SILENT, NULL);
@@ -365,31 +376,79 @@ int devtmpfs_mount(const char *mntdir)
         return err;
 }
 
+static __initdata DECLARE_COMPLETION(setup_done);
+
+static int handle(const char *name, mode_t mode, struct device *dev)
+{
+        if (mode)
+                return handle_create(name, mode, dev);
+        else
+                return handle_remove(name, dev);
+}
+
+static int devtmpfsd(void *p)
+{
+        char options[] = "mode=0755";
+        int *err = p;
+        *err = sys_unshare(CLONE_NEWNS);
+        if (*err)
+                goto out;
+        *err = sys_mount("devtmpfs", "/", "devtmpfs", MS_SILENT, options);
+        if (*err)
+                goto out;
+        sys_chdir("/.."); /* will traverse into overmounted root */
+        sys_chroot(".");
+        complete(&setup_done);
+        while (1) {
+                spin_lock(&req_lock);
+                while (requests) {
+                        struct req *req = requests;
+                        requests = NULL;
+                        spin_unlock(&req_lock);
+                        while (req) {
+                                req->err = handle(req->name, req->mode, req->dev);
+                                complete(&req->done);
+                                req = req->next;
+                        }
+                        spin_lock(&req_lock);
+                }
+                set_current_state(TASK_INTERRUPTIBLE);
+                spin_unlock(&req_lock);
+                schedule();
+                __set_current_state(TASK_RUNNING);
+        }
+        return 0;
+out:
+        complete(&setup_done);
+        return *err;
+}
+
 /*
  * Create devtmpfs instance, driver-core devices will add their device
  * nodes here.
  */
 int __init devtmpfs_init(void)
 {
-        int err;
-        struct vfsmount *mnt;
-        char options[] = "mode=0755";
-
-        err = register_filesystem(&dev_fs_type);
+        int err = register_filesystem(&dev_fs_type);
         if (err) {
                 printk(KERN_ERR "devtmpfs: unable to register devtmpfs "
                        "type %i\n", err);
                 return err;
         }
 
-        mnt = kern_mount_data(&dev_fs_type, options);
-        if (IS_ERR(mnt)) {
-                err = PTR_ERR(mnt);
+        thread = kthread_run(devtmpfsd, &err, "kdevtmpfs");
+        if (!IS_ERR(thread)) {
+                wait_for_completion(&setup_done);
+        } else {
+                err = PTR_ERR(thread);
+                thread = NULL;
+        }
+
+        if (err) {
                 printk(KERN_ERR "devtmpfs: unable to create devtmpfs %i\n", err);
                 unregister_filesystem(&dev_fs_type);
                 return err;
         }
-        dev_mnt = mnt;
 
         printk(KERN_INFO "devtmpfs: initialized\n");
         return 0;
diff --git a/drivers/block/pktcdvd.c b/drivers/block/pktcdvd.c
index 07a382eaf0a8..e133f094ab08 100644
--- a/drivers/block/pktcdvd.c
+++ b/drivers/block/pktcdvd.c
@@ -1206,7 +1206,7 @@ static int pkt_start_recovery(struct packet_data *pkt)
         if (!sb)
                 return 0;
 
-        if (!sb->s_op || !sb->s_op->relocate_blocks)
+        if (!sb->s_op->relocate_blocks)
                 goto out;
 
         old_block = pkt->sector / (CD_FRAMESIZE >> 9);
diff --git a/drivers/char/generic_nvram.c b/drivers/char/generic_nvram.c
index 0e941b57482e..6c4f4b5a9dd3 100644
--- a/drivers/char/generic_nvram.c
+++ b/drivers/char/generic_nvram.c
@@ -34,12 +34,16 @@ static ssize_t nvram_len;
 static loff_t nvram_llseek(struct file *file, loff_t offset, int origin)
 {
         switch (origin) {
+        case 0:
+                break;
         case 1:
                 offset += file->f_pos;
                 break;
         case 2:
                 offset += nvram_len;
                 break;
+        default:
+                offset = -1;
         }
         if (offset < 0)
                 return -EINVAL;
diff --git a/drivers/char/nvram.c b/drivers/char/nvram.c
index 166f1e7aaa7e..da3cfee782dc 100644
--- a/drivers/char/nvram.c
+++ b/drivers/char/nvram.c
@@ -224,6 +224,8 @@ static loff_t nvram_llseek(struct file *file, loff_t offset, int origin)
         case 2:
                 offset += NVRAM_BYTES;
                 break;
+        default:
+                return -EINVAL;
         }
 
         return (offset >= 0) ? (file->f_pos = offset) : -EINVAL;
diff --git a/drivers/char/ps3flash.c b/drivers/char/ps3flash.c
index 85c004a518ee..d0c57c2e2909 100644
--- a/drivers/char/ps3flash.c
+++ b/drivers/char/ps3flash.c
@@ -101,12 +101,16 @@ static loff_t ps3flash_llseek(struct file *file, loff_t offset, int origin)
 
         mutex_lock(&file->f_mapping->host->i_mutex);
         switch (origin) {
+        case 0:
+                break;
         case 1:
                 offset += file->f_pos;
                 break;
         case 2:
                 offset += dev->regions[dev->region_idx].size*dev->blk_size;
                 break;
+        default:
+                offset = -1;
         }
         if (offset < 0) {
                 res = -EINVAL;
@@ -305,9 +309,14 @@ static int ps3flash_flush(struct file *file, fl_owner_t id)
         return ps3flash_writeback(ps3flash_dev);
 }
 
-static int ps3flash_fsync(struct file *file, int datasync)
+static int ps3flash_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
-        return ps3flash_writeback(ps3flash_dev);
+        struct inode *inode = file->f_path.dentry->d_inode;
+        int err;
+        mutex_lock(&inode->i_mutex);
+        err = ps3flash_writeback(ps3flash_dev);
+        mutex_unlock(&inode->i_mutex);
+        return err;
 }
 
 static irqreturn_t ps3flash_interrupt(int irq, void *data)
diff --git a/drivers/macintosh/nvram.c b/drivers/macintosh/nvram.c
index a271c8218d82..f0e03e7937e3 100644
--- a/drivers/macintosh/nvram.c
+++ b/drivers/macintosh/nvram.c
@@ -21,12 +21,16 @@
 static loff_t nvram_llseek(struct file *file, loff_t offset, int origin)
 {
         switch (origin) {
+        case 0:
+                break;
         case 1:
                 offset += file->f_pos;
                 break;
         case 2:
                 offset += NVRAM_SIZE;
                 break;
+        default:
+                offset = -1;
         }
         if (offset < 0)
                 return -EINVAL;
diff --git a/drivers/md/md.c b/drivers/md/md.c
index 91e31e260b4a..dfc9425db70b 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -6394,16 +6394,11 @@ static void md_seq_stop(struct seq_file *seq, void *v)
                 mddev_put(mddev);
 }
 
-struct mdstat_info {
-        int event;
-};
-
 static int md_seq_show(struct seq_file *seq, void *v)
 {
         mddev_t *mddev = v;
         sector_t sectors;
         mdk_rdev_t *rdev;
-        struct mdstat_info *mi = seq->private;
         struct bitmap *bitmap;
 
         if (v == (void*)1) {
@@ -6415,7 +6410,7 @@ static int md_seq_show(struct seq_file *seq, void *v)
 
                 spin_unlock(&pers_lock);
                 seq_printf(seq, "\n");
-                mi->event = atomic_read(&md_event_count);
+                seq->poll_event = atomic_read(&md_event_count);
                 return 0;
         }
         if (v == (void*)2) {
@@ -6527,26 +6522,21 @@ static const struct seq_operations md_seq_ops = {
 
 static int md_seq_open(struct inode *inode, struct file *file)
 {
+        struct seq_file *seq;
         int error;
-        struct mdstat_info *mi = kmalloc(sizeof(*mi), GFP_KERNEL);
-        if (mi == NULL)
-                return -ENOMEM;
 
         error = seq_open(file, &md_seq_ops);
         if (error)
-                kfree(mi);
-        else {
-                struct seq_file *p = file->private_data;
-                p->private = mi;
-                mi->event = atomic_read(&md_event_count);
-        }
+                return error;
+
+        seq = file->private_data;
+        seq->poll_event = atomic_read(&md_event_count);
         return error;
 }
 
 static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
 {
-        struct seq_file *m = filp->private_data;
-        struct mdstat_info *mi = m->private;
+        struct seq_file *seq = filp->private_data;
         int mask;
 
         poll_wait(filp, &md_event_waiters, wait);
@@ -6554,7 +6544,7 @@ static unsigned int mdstat_poll(struct file *filp, poll_table *wait)
         /* always allow read */
         mask = POLLIN | POLLRDNORM;
 
-        if (mi->event != atomic_read(&md_event_count))
+        if (seq->poll_event != atomic_read(&md_event_count))
                 mask |= POLLERR | POLLPRI;
         return mask;
 }
diff --git a/drivers/mtd/ubi/cdev.c b/drivers/mtd/ubi/cdev.c
index 191f3bb3c41a..3320a50ba4f0 100644
--- a/drivers/mtd/ubi/cdev.c
+++ b/drivers/mtd/ubi/cdev.c
@@ -189,12 +189,16 @@ static loff_t vol_cdev_llseek(struct file *file, loff_t offset, int origin)
         return new_offset;
 }
 
-static int vol_cdev_fsync(struct file *file, int datasync)
+static int vol_cdev_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
         struct ubi_volume_desc *desc = file->private_data;
         struct ubi_device *ubi = desc->vol->ubi;
-
-        return ubi_sync(ubi->ubi_num);
+        struct inode *inode = file->f_path.dentry->d_inode;
+        int err;
+        mutex_lock(&inode->i_mutex);
+        err = ubi_sync(ubi->ubi_num);
+        mutex_unlock(&inode->i_mutex);
+        return err;
 }
 
 
diff --git a/drivers/sh/clk/core.c b/drivers/sh/clk/core.c
index 7e9c39951ecb..d6702e57d428 100644
--- a/drivers/sh/clk/core.c
+++ b/drivers/sh/clk/core.c
@@ -670,7 +670,7 @@ static struct dentry *clk_debugfs_root;
 static int clk_debugfs_register_one(struct clk *c)
 {
         int err;
-        struct dentry *d, *child, *child_tmp;
+        struct dentry *d;
         struct clk *pa = c->parent;
         char s[255];
         char *p = s;
@@ -699,10 +699,7 @@ static int clk_debugfs_register_one(struct clk *c)
         return 0;
 
 err_out:
-        d = c->dentry;
-        list_for_each_entry_safe(child, child_tmp, &d->d_subdirs, d_u.d_child)
-                debugfs_remove(child);
-        debugfs_remove(c->dentry);
+        debugfs_remove_recursive(c->dentry);
         return err;
 }
 
diff --git a/drivers/staging/pohmelfs/dir.c b/drivers/staging/pohmelfs/dir.c
index 9732a9666cc4..7598e77672a5 100644
--- a/drivers/staging/pohmelfs/dir.c
+++ b/drivers/staging/pohmelfs/dir.c
@@ -512,7 +512,7 @@ struct dentry *pohmelfs_lookup(struct inode *dir, struct dentry *dentry, struct
         int err, lock_type = POHMELFS_READ_LOCK, need_lock = 1;
         struct qstr str = dentry->d_name;
 
-        if ((nd->intent.open.flags & O_ACCMODE) > 1)
+        if ((nd->intent.open.flags & O_ACCMODE) != O_RDONLY)
                 lock_type = POHMELFS_WRITE_LOCK;
 
         if (test_bit(NETFS_INODE_OWNED, &parent->state)) {
diff --git a/drivers/staging/pohmelfs/inode.c b/drivers/staging/pohmelfs/inode.c
index c0f0ac7c1cdb..f3c6060c96b8 100644
--- a/drivers/staging/pohmelfs/inode.c
+++ b/drivers/staging/pohmelfs/inode.c
@@ -887,11 +887,16 @@ static struct inode *pohmelfs_alloc_inode(struct super_block *sb)
 /*
  * We want fsync() to work on POHMELFS.
  */
-static int pohmelfs_fsync(struct file *file, int datasync)
+static int pohmelfs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
         struct inode *inode = file->f_mapping->host;
-
-        return sync_inode_metadata(inode, 1);
+        int err = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (!err) {
+                mutex_lock(&inode->i_mutex);
+                err = sync_inode_metadata(inode, 1);
+                mutex_unlock(&inode->i_mutex);
+        }
+        return err;
 }
 
 ssize_t pohmelfs_write(struct file *file, const char __user *buf,
diff --git a/drivers/usb/gadget/printer.c b/drivers/usb/gadget/printer.c
index 271ef94668e7..978e6a101bf2 100644
--- a/drivers/usb/gadget/printer.c
+++ b/drivers/usb/gadget/printer.c
@@ -795,12 +795,14 @@ printer_write(struct file *fd, const char __user *buf, size_t len, loff_t *ptr)
 }
 
 static int
-printer_fsync(struct file *fd, int datasync)
+printer_fsync(struct file *fd, loff_t start, loff_t end, int datasync)
 {
         struct printer_dev      *dev = fd->private_data;
+        struct inode *inode = fd->f_path.dentry->d_inode;
         unsigned long           flags;
         int                     tx_list_empty;
 
+        mutex_lock(&inode->i_mutex);
         spin_lock_irqsave(&dev->lock, flags);
         tx_list_empty = (likely(list_empty(&dev->tx_reqs)));
         spin_unlock_irqrestore(&dev->lock, flags);
@@ -810,6 +812,7 @@ printer_fsync(struct file *fd, int datasync)
                 wait_event_interruptible(dev->tx_flush_wait,
                                 (likely(list_empty(&dev->tx_reqs_active))));
         }
+        mutex_unlock(&inode->i_mutex);
 
         return 0;
 }
diff --git a/drivers/video/fb_defio.c b/drivers/video/fb_defio.c
index 804000183c5e..32814e8800e0 100644
--- a/drivers/video/fb_defio.c
+++ b/drivers/video/fb_defio.c
@@ -66,19 +66,26 @@ static int fb_deferred_io_fault(struct vm_area_struct *vma,
         return 0;
 }
 
-int fb_deferred_io_fsync(struct file *file, int datasync)
+int fb_deferred_io_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 {
         struct fb_info *info = file->private_data;
+        struct inode *inode = file->f_path.dentry->d_inode;
+        int err = filemap_write_and_wait_range(inode->i_mapping, start, end);
+        if (err)
+                return err;
 
         /* Skip if deferred io is compiled-in but disabled on this fbdev */
         if (!info->fbdefio)
                 return 0;
 
+        mutex_lock(&inode->i_mutex);
         /* Kill off the delayed work */
         cancel_delayed_work_sync(&info->deferred_work);
 
         /* Run it immediately */
-        return schedule_delayed_work(&info->deferred_work, 0);
+        err = schedule_delayed_work(&info->deferred_work, 0);
+        mutex_unlock(&inode->i_mutex);
+        return err;
 }
 EXPORT_SYMBOL_GPL(fb_deferred_io_fsync);