Merge remote-tracking branch 'ovl/for-viro' into for-linus

Overlayfs-related series from Miklos and Amir

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 3043771..f52b88b 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -501,9 +501,9 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
        cmd->iocb.ki_flags = IOCB_DIRECT;
 
        if (rw == WRITE)
-               ret = file->f_op->write_iter(&cmd->iocb, &iter);
+               ret = call_write_iter(file, &cmd->iocb, &iter);
        else
-               ret = file->f_op->read_iter(&cmd->iocb, &iter);
+               ret = call_read_iter(file, &cmd->iocb, &iter);
 
        if (ret != -EIOCBQUEUED)
                cmd->iocb.ki_complete(&cmd->iocb, ret, 0);

diff --git a/drivers/gpu/drm/i915/i915_gem_dmabuf.c b/drivers/gpu/drm/i915/i915_gem_dmabuf.c
index d037adc..29bb801 100644 (file)
--- a/drivers/gpu/drm/i915/i915_gem_dmabuf.c
+++ b/drivers/gpu/drm/i915/i915_gem_dmabuf.c
@@ -141,7 +141,7 @@ static int i915_gem_dmabuf_mmap(struct dma_buf *dma_buf, struct vm_area_struct *
        if (!obj->base.filp)
                return -ENODEV;
 
-       ret = obj->base.filp->f_op->mmap(obj->base.filp, vma);
+       ret = call_mmap(obj->base.filp, vma);
        if (ret)
                return ret;
 

diff --git a/drivers/gpu/drm/vgem/vgem_drv.c b/drivers/gpu/drm/vgem/vgem_drv.c
index 477e07f..9f7e222 100644 (file)
--- a/drivers/gpu/drm/vgem/vgem_drv.c
+++ b/drivers/gpu/drm/vgem/vgem_drv.c
@@ -287,7 +287,7 @@ static int vgem_prime_mmap(struct drm_gem_object *obj,
        if (!obj->filp)
                return -ENODEV;
 
-       ret = obj->filp->f_op->mmap(obj->filp, vma);
+       ret = call_mmap(obj->filp, vma);
        if (ret)
                return ret;
 

diff --git a/fs/aio.c b/fs/aio.c
index 873b4ca..63e97f3 100644 (file)
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1495,7 +1495,7 @@ static ssize_t aio_read(struct kiocb *req, struct iocb *iocb, bool vectored,
                return ret;
        ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter));
        if (!ret)
-               ret = aio_ret(req, file->f_op->read_iter(req, &iter));
+               ret = aio_ret(req, call_read_iter(file, req, &iter));
        kfree(iovec);
        return ret;
 }
@@ -1520,7 +1520,7 @@ static ssize_t aio_write(struct kiocb *req, struct iocb *iocb, bool vectored,
        if (!ret) {
                req->ki_flags |= IOCB_WRITE;
                file_start_write(file);
-               ret = aio_ret(req, file->f_op->write_iter(req, &iter));
+               ret = aio_ret(req, call_write_iter(file, req, &iter));
                /*
                 * We release freeze protection in aio_complete().  Fool lockdep
                 * by telling it the lock got released so that it doesn't

diff --git a/fs/coda/file.c b/fs/coda/file.c
index 6e0154e..9d956cd 100644 (file)
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -96,7 +96,7 @@ coda_file_mmap(struct file *coda_file, struct vm_area_struct *vma)
        cfi->cfi_mapcount++;
        spin_unlock(&cii->c_lock);
 
-       return host_file->f_op->mmap(host_file, vma);
+       return call_mmap(host_file, vma);
 }
 
 int coda_open(struct inode *coda_inode, struct file *coda_file)

diff --git a/fs/namei.c b/fs/namei.c
index 07e292b..d41fab7 100644 (file)
--- a/fs/namei.c
+++ b/fs/namei.c
@@ -3363,13 +3363,50 @@ out:
        return error;
 }
 
+struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode, int open_flag)
+{
+       static const struct qstr name = QSTR_INIT("/", 1);
+       struct dentry *child = NULL;
+       struct inode *dir = dentry->d_inode;
+       struct inode *inode;
+       int error;
+
+       /* we want directory to be writable */
+       error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
+       if (error)
+               goto out_err;
+       error = -EOPNOTSUPP;
+       if (!dir->i_op->tmpfile)
+               goto out_err;
+       error = -ENOMEM;
+       child = d_alloc(dentry, &name);
+       if (unlikely(!child))
+               goto out_err;
+       error = dir->i_op->tmpfile(dir, child, mode);
+       if (error)
+               goto out_err;
+       error = -ENOENT;
+       inode = child->d_inode;
+       if (unlikely(!inode))
+               goto out_err;
+       if (!(open_flag & O_EXCL)) {
+               spin_lock(&inode->i_lock);
+               inode->i_state |= I_LINKABLE;
+               spin_unlock(&inode->i_lock);
+       }
+       return child;
+
+out_err:
+       dput(child);
+       return ERR_PTR(error);
+}
+EXPORT_SYMBOL(vfs_tmpfile);
+
 static int do_tmpfile(struct nameidata *nd, unsigned flags,
                const struct open_flags *op,
                struct file *file, int *opened)
 {
-       static const struct qstr name = QSTR_INIT("/", 1);
        struct dentry *child;
-       struct inode *dir;
        struct path path;
        int error = path_lookupat(nd, flags | LOOKUP_DIRECTORY, &path);
        if (unlikely(error))
@@ -3377,25 +3414,12 @@ static int do_tmpfile(struct nameidata *nd, unsigned flags,
        error = mnt_want_write(path.mnt);
        if (unlikely(error))
                goto out;
-       dir = path.dentry->d_inode;
-       /* we want directory to be writable */
-       error = inode_permission(dir, MAY_WRITE | MAY_EXEC);
-       if (error)
-               goto out2;
-       if (!dir->i_op->tmpfile) {
-               error = -EOPNOTSUPP;
-               goto out2;
-       }
-       child = d_alloc(path.dentry, &name);
-       if (unlikely(!child)) {
-               error = -ENOMEM;
+       child = vfs_tmpfile(path.dentry, op->mode, op->open_flag);
+       error = PTR_ERR(child);
+       if (unlikely(IS_ERR(child)))
                goto out2;
-       }
        dput(path.dentry);
        path.dentry = child;
-       error = dir->i_op->tmpfile(dir, child, op->mode);
-       if (error)
-               goto out2;
        audit_inode(nd->name, child, 0);
        /* Don't check for other permissions, the inode was just created */
        error = may_open(&path, 0, op->open_flag);
@@ -3406,14 +3430,8 @@ static int do_tmpfile(struct nameidata *nd, unsigned flags,
        if (error)
                goto out2;
        error = open_check_o_direct(file);
-       if (error) {
+       if (error)
                fput(file);
-       } else if (!(op->open_flag & O_EXCL)) {
-               struct inode *inode = file_inode(file);
-               spin_lock(&inode->i_lock);
-               inode->i_state |= I_LINKABLE;
-               spin_unlock(&inode->i_lock);
-       }
 out2:
        mnt_drop_write(path.mnt);
 out:

diff --git a/fs/open.c b/fs/open.c
index 9921f70..949cef2 100644 (file)
--- a/fs/open.c
+++ b/fs/open.c
@@ -301,12 +301,10 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
        if (S_ISFIFO(inode->i_mode))
                return -ESPIPE;
 
-       /*
-        * Let individual file system decide if it supports preallocation
-        * for directories or not.
-        */
-       if (!S_ISREG(inode->i_mode) && !S_ISDIR(inode->i_mode) &&
-           !S_ISBLK(inode->i_mode))
+       if (S_ISDIR(inode->i_mode))
+               return -EISDIR;
+
+       if (!S_ISREG(inode->i_mode) && !S_ISBLK(inode->i_mode))
                return -ENODEV;
 
        /* Check for wrap through zero too */
@@ -316,7 +314,7 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
        if (!file->f_op->fallocate)
                return -EOPNOTSUPP;
 
-       sb_start_write(inode->i_sb);
+       file_start_write(file);
        ret = file->f_op->fallocate(file, mode, offset, len);
 
        /*
@@ -329,7 +327,7 @@ int vfs_fallocate(struct file *file, int mode, loff_t offset, loff_t len)
        if (ret == 0)
                fsnotify_modify(file);
 
-       sb_end_write(inode->i_sb);
+       file_end_write(file);
        return ret;
 }
 EXPORT_SYMBOL_GPL(vfs_fallocate);

diff --git a/fs/read_write.c b/fs/read_write.c
index 5816d4c..f2ed9fd 100644 (file)
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -23,9 +23,6 @@
 #include <linux/uaccess.h>
 #include <asm/unistd.h>
 
-typedef ssize_t (*io_fn_t)(struct file *, char __user *, size_t, loff_t *);
-typedef ssize_t (*iter_fn_t)(struct kiocb *, struct iov_iter *);
-
 const struct file_operations generic_ro_fops = {
        .llseek         = generic_file_llseek,
        .read_iter      = generic_file_read_iter,
@@ -370,7 +367,7 @@ ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos)
        kiocb.ki_pos = *ppos;
 
        iter->type |= READ;
-       ret = file->f_op->read_iter(&kiocb, iter);
+       ret = call_read_iter(file, &kiocb, iter);
        BUG_ON(ret == -EIOCBQUEUED);
        if (ret > 0)
                *ppos = kiocb.ki_pos;
@@ -390,7 +387,7 @@ ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos)
        kiocb.ki_pos = *ppos;
 
        iter->type |= WRITE;
-       ret = file->f_op->write_iter(&kiocb, iter);
+       ret = call_write_iter(file, &kiocb, iter);
        BUG_ON(ret == -EIOCBQUEUED);
        if (ret > 0)
                *ppos = kiocb.ki_pos;
@@ -439,7 +436,7 @@ static ssize_t new_sync_read(struct file *filp, char __user *buf, size_t len, lo
        kiocb.ki_pos = *ppos;
        iov_iter_init(&iter, READ, &iov, 1, len);
 
-       ret = filp->f_op->read_iter(&kiocb, &iter);
+       ret = call_read_iter(filp, &kiocb, &iter);
        BUG_ON(ret == -EIOCBQUEUED);
        *ppos = kiocb.ki_pos;
        return ret;
@@ -496,7 +493,7 @@ static ssize_t new_sync_write(struct file *filp, const char __user *buf, size_t
        kiocb.ki_pos = *ppos;
        iov_iter_init(&iter, WRITE, &iov, 1, len);
 
-       ret = filp->f_op->write_iter(&kiocb, &iter);
+       ret = call_write_iter(filp, &kiocb, &iter);
        BUG_ON(ret == -EIOCBQUEUED);
        if (ret > 0)
                *ppos = kiocb.ki_pos;
@@ -675,7 +672,7 @@ unsigned long iov_shorten(struct iovec *iov, unsigned long nr_segs, size_t to)
 EXPORT_SYMBOL(iov_shorten);
 
 static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
-               loff_t *ppos, iter_fn_t fn, int flags)
+               loff_t *ppos, int type, int flags)
 {
        struct kiocb kiocb;
        ssize_t ret;
@@ -692,7 +689,10 @@ static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
                kiocb.ki_flags |= (IOCB_DSYNC | IOCB_SYNC);
        kiocb.ki_pos = *ppos;
 
-       ret = fn(&kiocb, iter);
+       if (type == READ)
+               ret = call_read_iter(filp, &kiocb, iter);
+       else
+               ret = call_write_iter(filp, &kiocb, iter);
        BUG_ON(ret == -EIOCBQUEUED);
        *ppos = kiocb.ki_pos;
        return ret;
@@ -700,7 +700,7 @@ static ssize_t do_iter_readv_writev(struct file *filp, struct iov_iter *iter,
 
 /* Do it by hand, with file-ops */
 static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
-               loff_t *ppos, io_fn_t fn, int flags)
+               loff_t *ppos, int type, int flags)
 {
        ssize_t ret = 0;
 
@@ -711,7 +711,13 @@ static ssize_t do_loop_readv_writev(struct file *filp, struct iov_iter *iter,
                struct iovec iovec = iov_iter_iovec(iter);
                ssize_t nr;
 
-               nr = fn(filp, iovec.iov_base, iovec.iov_len, ppos);
+               if (type == READ) {
+                       nr = filp->f_op->read(filp, iovec.iov_base,
+                                             iovec.iov_len, ppos);
+               } else {
+                       nr = filp->f_op->write(filp, iovec.iov_base,
+                                              iovec.iov_len, ppos);
+               }
 
                if (nr < 0) {
                        if (!ret)
@@ -834,50 +840,32 @@ out:
        return ret;
 }
 
-static ssize_t do_readv_writev(int type, struct file *file,
-                              const struct iovec __user * uvector,
-                              unsigned long nr_segs, loff_t *pos,
-                              int flags)
+static ssize_t __do_readv_writev(int type, struct file *file,
+                                struct iov_iter *iter, loff_t *pos, int flags)
 {
        size_t tot_len;
-       struct iovec iovstack[UIO_FASTIOV];
-       struct iovec *iov = iovstack;
-       struct iov_iter iter;
-       ssize_t ret;
-       io_fn_t fn;
-       iter_fn_t iter_fn;
-
-       ret = import_iovec(type, uvector, nr_segs,
-                          ARRAY_SIZE(iovstack), &iov, &iter);
-       if (ret < 0)
-               return ret;
+       ssize_t ret = 0;
 
-       tot_len = iov_iter_count(&iter);
+       tot_len = iov_iter_count(iter);
        if (!tot_len)
                goto out;
        ret = rw_verify_area(type, file, pos, tot_len);
        if (ret < 0)
                goto out;
 
-       if (type == READ) {
-               fn = file->f_op->read;
-               iter_fn = file->f_op->read_iter;
-       } else {
-               fn = (io_fn_t)file->f_op->write;
-               iter_fn = file->f_op->write_iter;
+       if (type != READ)
                file_start_write(file);
-       }
 
-       if (iter_fn)
-               ret = do_iter_readv_writev(file, &iter, pos, iter_fn, flags);
+       if ((type == READ && file->f_op->read_iter) ||
+           (type == WRITE && file->f_op->write_iter))
+               ret = do_iter_readv_writev(file, iter, pos, type, flags);
        else
-               ret = do_loop_readv_writev(file, &iter, pos, fn, flags);
+               ret = do_loop_readv_writev(file, iter, pos, type, flags);
 
        if (type != READ)
                file_end_write(file);
 
 out:
-       kfree(iov);
        if ((ret + (type == READ)) > 0) {
                if (type == READ)
                        fsnotify_access(file);
@@ -887,6 +875,27 @@ out:
        return ret;
 }
 
+static ssize_t do_readv_writev(int type, struct file *file,
+                              const struct iovec __user *uvector,
+                              unsigned long nr_segs, loff_t *pos,
+                              int flags)
+{
+       struct iovec iovstack[UIO_FASTIOV];
+       struct iovec *iov = iovstack;
+       struct iov_iter iter;
+       ssize_t ret;
+
+       ret = import_iovec(type, uvector, nr_segs,
+                          ARRAY_SIZE(iovstack), &iov, &iter);
+       if (ret < 0)
+               return ret;
+
+       ret = __do_readv_writev(type, file, &iter, pos, flags);
+       kfree(iov);
+
+       return ret;
+}
+
 ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
                  unsigned long vlen, loff_t *pos, int flags)
 {
@@ -1064,51 +1073,19 @@ static ssize_t compat_do_readv_writev(int type, struct file *file,
                               unsigned long nr_segs, loff_t *pos,
                               int flags)
 {
-       compat_ssize_t tot_len;
        struct iovec iovstack[UIO_FASTIOV];
        struct iovec *iov = iovstack;
        struct iov_iter iter;
        ssize_t ret;
-       io_fn_t fn;
-       iter_fn_t iter_fn;
 
        ret = compat_import_iovec(type, uvector, nr_segs,
                                  UIO_FASTIOV, &iov, &iter);
        if (ret < 0)
                return ret;
 
-       tot_len = iov_iter_count(&iter);
-       if (!tot_len)
-               goto out;
-       ret = rw_verify_area(type, file, pos, tot_len);
-       if (ret < 0)
-               goto out;
-
-       if (type == READ) {
-               fn = file->f_op->read;
-               iter_fn = file->f_op->read_iter;
-       } else {
-               fn = (io_fn_t)file->f_op->write;
-               iter_fn = file->f_op->write_iter;
-               file_start_write(file);
-       }
-
-       if (iter_fn)
-               ret = do_iter_readv_writev(file, &iter, pos, iter_fn, flags);
-       else
-               ret = do_loop_readv_writev(file, &iter, pos, fn, flags);
-
-       if (type != READ)
-               file_end_write(file);
-
-out:
+       ret = __do_readv_writev(type, file, &iter, pos, flags);
        kfree(iov);
-       if ((ret + (type == READ)) > 0) {
-               if (type == READ)
-                       fsnotify_access(file);
-               else
-                       fsnotify_modify(file);
-       }
+
        return ret;
 }
 
@@ -1518,6 +1495,11 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
        if (flags != 0)
                return -EINVAL;
 
+       if (S_ISDIR(inode_in->i_mode) || S_ISDIR(inode_out->i_mode))
+               return -EISDIR;
+       if (!S_ISREG(inode_in->i_mode) || !S_ISREG(inode_out->i_mode))
+               return -EINVAL;
+
        ret = rw_verify_area(READ, file_in, &pos_in, len);
        if (unlikely(ret))
                return ret;
@@ -1538,7 +1520,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
        if (len == 0)
                return 0;
 
-       sb_start_write(inode_out->i_sb);
+       file_start_write(file_out);
 
        /*
         * Try cloning first, this is supported by more file systems, and
@@ -1574,7 +1556,7 @@ done:
        inc_syscr(current);
        inc_syscw(current);
 
-       sb_end_write(inode_out->i_sb);
+       file_end_write(file_out);
 
        return ret;
 }

diff --git a/fs/splice.c b/fs/splice.c
index 4ef78aa..eaafa3d 100644 (file)
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -307,7 +307,7 @@ ssize_t generic_file_splice_read(struct file *in, loff_t *ppos,
        idx = to.idx;
        init_sync_kiocb(&kiocb, in);
        kiocb.ki_pos = *ppos;
-       ret = in->f_op->read_iter(&kiocb, &to);
+       ret = call_read_iter(in, &kiocb, &to);
        if (ret > 0) {
                *ppos = kiocb.ki_pos;
                file_accessed(in);

diff --git a/fs/sync.c b/fs/sync.c
index 2a54c1f..11ba023 100644 (file)
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -192,7 +192,7 @@ int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync)
                spin_unlock(&inode->i_lock);
                mark_inode_dirty_sync(inode);
        }
-       return file->f_op->fsync(file, start, end, datasync);
+       return call_fsync(file, start, end, datasync);
 }
 EXPORT_SYMBOL(vfs_fsync_range);
 

diff --git a/include/linux/fs.h b/include/linux/fs.h
index c930cbc..f45809c 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -1562,6 +1562,9 @@ extern int vfs_unlink(struct inode *, struct dentry *, struct inode **);
 extern int vfs_rename(struct inode *, struct dentry *, struct inode *, struct dentry *, struct inode **, unsigned int);
 extern int vfs_whiteout(struct inode *, struct dentry *);
 
+extern struct dentry *vfs_tmpfile(struct dentry *dentry, umode_t mode,
+                                 int open_flag);
+
 /*
  * VFS file helper functions.
  */
@@ -1713,6 +1716,29 @@ struct inode_operations {
        int (*set_acl)(struct inode *, struct posix_acl *, int);
 } ____cacheline_aligned;
 
+static inline ssize_t call_read_iter(struct file *file, struct kiocb *kio,
+                                    struct iov_iter *iter)
+{
+       return file->f_op->read_iter(kio, iter);
+}
+
+static inline ssize_t call_write_iter(struct file *file, struct kiocb *kio,
+                                     struct iov_iter *iter)
+{
+       return file->f_op->write_iter(kio, iter);
+}
+
+static inline int call_mmap(struct file *file, struct vm_area_struct *vma)
+{
+       return file->f_op->mmap(file, vma);
+}
+
+static inline int call_fsync(struct file *file, loff_t start, loff_t end,
+                            int datasync)
+{
+       return file->f_op->fsync(file, start, end, datasync);
+}
+
 ssize_t rw_copy_check_uvector(int type, const struct iovec __user * uvector,
                              unsigned long nr_segs, unsigned long fast_segs,
                              struct iovec *fast_pointer,
@@ -1739,19 +1765,6 @@ extern int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
 extern int vfs_dedupe_file_range(struct file *file,
                                 struct file_dedupe_range *same);
 
-static inline int do_clone_file_range(struct file *file_in, loff_t pos_in,
-                                     struct file *file_out, loff_t pos_out,
-                                     u64 len)
-{
-       int ret;
-
-       sb_start_write(file_inode(file_out)->i_sb);
-       ret = vfs_clone_file_range(file_in, pos_in, file_out, pos_out, len);
-       sb_end_write(file_inode(file_out)->i_sb);
-
-       return ret;
-}
-
 struct super_operations {
        struct inode *(*alloc_inode)(struct super_block *sb);
        void (*destroy_inode)(struct inode *);
@@ -2563,6 +2576,19 @@ static inline void file_end_write(struct file *file)
        __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
 }
 
+static inline int do_clone_file_range(struct file *file_in, loff_t pos_in,
+                                     struct file *file_out, loff_t pos_out,
+                                     u64 len)
+{
+       int ret;
+
+       file_start_write(file_out);
+       ret = vfs_clone_file_range(file_in, pos_in, file_out, pos_out, len);
+       file_end_write(file_out);
+
+       return ret;
+}
+
 /*
  * get_write_access() gets write permission for a file.
  * put_write_access() releases this write permission.

diff --git a/ipc/shm.c b/ipc/shm.c
index 81203e8..258aff2 100644 (file)
--- a/ipc/shm.c
+++ b/ipc/shm.c
@@ -423,7 +423,7 @@ static int shm_mmap(struct file *file, struct vm_area_struct *vma)
        if (ret)
                return ret;
 
-       ret = sfd->file->f_op->mmap(sfd->file, vma);
+       ret = call_mmap(sfd->file, vma);
        if (ret) {
                shm_close(vma);
                return ret;
@@ -452,7 +452,7 @@ static int shm_fsync(struct file *file, loff_t start, loff_t end, int datasync)
 
        if (!sfd->file->f_op->fsync)
                return -EINVAL;
-       return sfd->file->f_op->fsync(sfd->file, start, end, datasync);
+       return call_fsync(sfd->file, start, end, datasync);
 }
 
 static long shm_fallocate(struct file *file, int mode, loff_t offset,

diff --git a/mm/mmap.c b/mm/mmap.c
index b729084..2ffca21 100644 (file)
--- a/mm/mmap.c
+++ b/mm/mmap.c
@@ -1668,7 +1668,7 @@ unsigned long mmap_region(struct file *file, unsigned long addr,
                 * new file must not have been exposed to user-space, yet.
                 */
                vma->vm_file = get_file(file);
-               error = file->f_op->mmap(file, vma);
+               error = call_mmap(file, vma);
                if (error)
                        goto unmap_and_free_vma;
 

diff --git a/mm/nommu.c b/mm/nommu.c
index bc964c2..782e83a 100644 (file)
--- a/mm/nommu.c
+++ b/mm/nommu.c
@@ -1084,7 +1084,7 @@ static int do_mmap_shared_file(struct vm_area_struct *vma)
 {
        int ret;
 
-       ret = vma->vm_file->f_op->mmap(vma->vm_file, vma);
+       ret = call_mmap(vma->vm_file, vma);
        if (ret == 0) {
                vma->vm_region->vm_top = vma->vm_region->vm_end;
                return 0;
@@ -1115,7 +1115,7 @@ static int do_mmap_private(struct vm_area_struct *vma,
         * - VM_MAYSHARE will be set if it may attempt to share
         */
        if (capabilities & NOMMU_MAP_DIRECT) {
-               ret = vma->vm_file->f_op->mmap(vma->vm_file, vma);
+               ret = call_mmap(vma->vm_file, vma);
                if (ret == 0) {
                        /* shouldn't return success if we're not sharing */
                        BUG_ON(!(vma->vm_flags & VM_MAYSHARE));