sanitize vfs_fsync calling conventions

Now that the last user passing a NULL file pointer is gone we can remove
the redundant dentry argument and associated hacks inside vfs_fsynmc_range.

The next step will be removig the dentry argument from ->fsync, but given
the luck with the last round of method prototype changes I'd rather
defer this until after the main merge window.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Al Viro <viro@zeniv.linux.org.uk>

diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index a90e83c9be96bb0bb66e4415eb86de4308d88dd8..6120922f459f3708685cffa46a51e5517c89b18c 100644 (file)
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -485,7 +485,7 @@ static int do_bio_filebacked(struct loop_device *lo, struct bio *bio)
                                goto out;
                        }
 
-                       ret = vfs_fsync(file, file->f_path.dentry, 0);
+                       ret = vfs_fsync(file, 0);
                        if (unlikely(ret)) {
                                ret = -EIO;
                                goto out;
@@ -495,7 +495,7 @@ static int do_bio_filebacked(struct loop_device *lo, struct bio *bio)
                ret = lo_send(lo, bio, pos);
 
                if (barrier && !ret) {
-                       ret = vfs_fsync(file, file->f_path.dentry, 0);
+                       ret = vfs_fsync(file, 0);
                        if (unlikely(ret))
                                ret = -EIO;
                }

diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index f084249295d97e3fcda1171595b37de58edf3514..53e8bea295e2c64e615c98779fb48e50e5596156 100644 (file)
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -1692,7 +1692,7 @@ int bitmap_create(mddev_t *mddev)
                 * and bypass the page cache, we must sync the file
                 * first.
                 */
-               vfs_fsync(file, file->f_dentry, 1);
+               vfs_fsync(file, 1);
        }
        /* read superblock from bitmap file (this sets mddev->bitmap_info.chunksize) */
        if (!mddev->bitmap_info.external)

diff --git a/drivers/usb/gadget/storage_common.c b/drivers/usb/gadget/storage_common.c
index 868d8ee86756671192a2fd1e93c866ae06121229..04c462ff0ea6af1d6c8e6bf49926c3b1da15d396 100644 (file)
--- a/drivers/usb/gadget/storage_common.c
+++ b/drivers/usb/gadget/storage_common.c
@@ -654,7 +654,7 @@ static int fsg_lun_fsync_sub(struct fsg_lun *curlun)
 
        if (curlun->ro || !filp)
                return 0;
-       return vfs_fsync(filp, filp->f_path.dentry, 1);
+       return vfs_fsync(filp, 1);
 }
 
 static void store_cdrom_address(u8 *dest, int msf, u32 addr)

diff --git a/fs/ceph/file.c b/fs/ceph/file.c
index ed6f19721d6e56d661ac7f11fe2aac04ba18e1a5..7d634938edc9ef9a478c8eb6b7c05b3bb5e99a48 100644 (file)
--- a/fs/ceph/file.c
+++ b/fs/ceph/file.c
@@ -844,8 +844,7 @@ retry_snap:
                if ((ret >= 0 || ret == -EIOCBQUEUED) &&
                    ((file->f_flags & O_SYNC) || IS_SYNC(file->f_mapping->host)
                     || ceph_osdmap_flag(osdc->osdmap, CEPH_OSDMAP_NEARFULL))) {
-                       err = vfs_fsync_range(file, file->f_path.dentry,
-                                             pos, pos + ret - 1, 1);
+                       err = vfs_fsync_range(file, pos, pos + ret - 1, 1);
                        if (err < 0)
                                ret = err;
                }

diff --git a/fs/coda/file.c b/fs/coda/file.c
index 4c813f2cdc52dcaa7074322ffaeb11d34e4c8726..7196077b16886fb4eca989a44d42f4c454cd65a6 100644 (file)
--- a/fs/coda/file.c
+++ b/fs/coda/file.c
@@ -217,7 +217,7 @@ int coda_fsync(struct file *coda_file, struct dentry *coda_dentry, int datasync)
        BUG_ON(!cfi || cfi->cfi_magic != CODA_MAGIC);
        host_file = cfi->cfi_container;
 
-       err = vfs_fsync(host_file, host_file->f_path.dentry, datasync);
+       err = vfs_fsync(host_file, datasync);
        if ( !err && !datasync ) {
                lock_kernel();
                err = venus_fsync(coda_inode->i_sb, coda_i2f(coda_inode));

diff --git a/fs/ecryptfs/file.c b/fs/ecryptfs/file.c
index e7440a6f5ebf0cffb9e9bee7a770b80553e72b15..3bdddbcc785f367f0ff63ed1b2899ad104cfce67 100644 (file)
--- a/fs/ecryptfs/file.c
+++ b/fs/ecryptfs/file.c
@@ -276,9 +276,7 @@ static int ecryptfs_release(struct inode *inode, struct file *file)
 static int
 ecryptfs_fsync(struct file *file, struct dentry *dentry, int datasync)
 {
-       return vfs_fsync(ecryptfs_file_to_lower(file),
-                        ecryptfs_dentry_to_lower(dentry),
-                        datasync);
+       return vfs_fsync(ecryptfs_file_to_lower(file), datasync);
 }
 
 static int ecryptfs_fasync(int fd, struct file *file, int flag)

diff --git a/fs/nfsd/nfs4recover.c b/fs/nfsd/nfs4recover.c
index dada03f2c13bc0836575a3e6610e642d5890b8ff..7e26caab2a262befd2c74af594d076e0ebb40121 100644 (file)
--- a/fs/nfsd/nfs4recover.c
+++ b/fs/nfsd/nfs4recover.c
@@ -158,7 +158,7 @@ out_unlock:
        mutex_unlock(&dir->d_inode->i_mutex);
        if (status == 0) {
                clp->cl_firststate = 1;
-               vfs_fsync(rec_file, rec_file->f_path.dentry, 0);
+               vfs_fsync(rec_file, 0);
        }
        nfs4_reset_creds(original_cred);
        dprintk("NFSD: nfsd4_create_clid_dir returns %d\n", status);
@@ -288,7 +288,7 @@ nfsd4_remove_clid_dir(struct nfs4_client *clp)
        status = nfsd4_unlink_clid_dir(clp->cl_recdir, HEXDIR_LEN-1);
        nfs4_reset_creds(original_cred);
        if (status == 0)
-               vfs_fsync(rec_file, rec_file->f_path.dentry, 0);
+               vfs_fsync(rec_file, 0);
        mnt_drop_write(rec_file->f_path.mnt);
 out:
        if (status)
@@ -325,7 +325,7 @@ nfsd4_recdir_purge_old(void) {
                goto out;
        status = nfsd4_list_rec_dir(rec_file->f_path.dentry, purge_old);
        if (status == 0)
-               vfs_fsync(rec_file, rec_file->f_path.dentry, 0);
+               vfs_fsync(rec_file, 0);
        mnt_drop_write(rec_file->f_path.mnt);
 out:
        if (status)

diff --git a/fs/nfsd/vfs.c b/fs/nfsd/vfs.c
index 23c06f77f4cab11b9ccc775698bd6c9cd1111e80..ebbf3b6b24577128c3182072d34933770d56e644 100644 (file)
--- a/fs/nfsd/vfs.c
+++ b/fs/nfsd/vfs.c
@@ -999,7 +999,7 @@ static int wait_for_concurrent_writes(struct file *file)
 
        if (inode->i_state & I_DIRTY) {
                dprintk("nfsd: write sync %d\n", task_pid_nr(current));
-               err = vfs_fsync(file, file->f_path.dentry, 0);
+               err = vfs_fsync(file, 0);
        }
        last_ino = inode->i_ino;
        last_dev = inode->i_sb->s_dev;
@@ -1175,8 +1175,7 @@ nfsd_commit(struct svc_rqst *rqstp, struct svc_fh *fhp,
        if (err)
                goto out;
        if (EX_ISSYNC(fhp->fh_export)) {
-               int err2 = vfs_fsync_range(file, file->f_path.dentry,
-                               offset, end, 0);
+               int err2 = vfs_fsync_range(file, offset, end, 0);
 
                if (err2 != -EINVAL)
                        err = nfserrno(err2);

diff --git a/fs/sync.c b/fs/sync.c
index d5369203f8e46bda1cb18336517091862eb98bce..5a537ccd2e85a7df9375909410fdc03da302e743 100644 (file)
--- a/fs/sync.c
+++ b/fs/sync.c
@@ -158,7 +158,6 @@ EXPORT_SYMBOL(file_fsync);
 /**
  * vfs_fsync_range - helper to sync a range of data & metadata to disk
  * @file:              file to sync
- * @dentry:            dentry of @file
  * @start:             offset in bytes of the beginning of data range to sync
  * @end:               offset in bytes of the end of data range (inclusive)
  * @datasync:          perform only datasync
@@ -166,32 +165,13 @@ EXPORT_SYMBOL(file_fsync);
  * Write back data in range @start..@end and metadata for @file to disk.  If
  * @datasync is set only metadata needed to access modified file data is
  * written.
- *
- * In case this function is called from nfsd @file may be %NULL and
- * only @dentry is set.  This can only happen when the filesystem
- * implements the export_operations API.
  */
-int vfs_fsync_range(struct file *file, struct dentry *dentry, loff_t start,
-                   loff_t end, int datasync)
+int vfs_fsync_range(struct file *file, loff_t start, loff_t end, int datasync)
 {
-       const struct file_operations *fop;
-       struct address_space *mapping;
+       struct address_space *mapping = file->f_mapping;
        int err, ret;
 
-       /*
-        * Get mapping and operations from the file in case we have
-        * as file, or get the default values for them in case we
-        * don't have a struct file available.  Damn nfsd..
-        */
-       if (file) {
-               mapping = file->f_mapping;
-               fop = file->f_op;
-       } else {
-               mapping = dentry->d_inode->i_mapping;
-               fop = dentry->d_inode->i_fop;
-       }
-
-       if (!fop || !fop->fsync) {
+       if (!file->f_op || !file->f_op->fsync) {
                ret = -EINVAL;
                goto out;
        }
@@ -203,7 +183,7 @@ int vfs_fsync_range(struct file *file, struct dentry *dentry, loff_t start,
         * livelocks in fsync_buffers_list().
         */
        mutex_lock(&mapping->host->i_mutex);
-       err = fop->fsync(file, dentry, datasync);
+       err = file->f_op->fsync(file, file->f_path.dentry, datasync);
        if (!ret)
                ret = err;
        mutex_unlock(&mapping->host->i_mutex);
@@ -216,19 +196,14 @@ EXPORT_SYMBOL(vfs_fsync_range);
 /**
  * vfs_fsync - perform a fsync or fdatasync on a file
  * @file:              file to sync
- * @dentry:            dentry of @file
  * @datasync:          only perform a fdatasync operation
  *
  * Write back data and metadata for @file to disk.  If @datasync is
  * set only metadata needed to access modified file data is written.
- *
- * In case this function is called from nfsd @file may be %NULL and
- * only @dentry is set.  This can only happen when the filesystem
- * implements the export_operations API.
  */
-int vfs_fsync(struct file *file, struct dentry *dentry, int datasync)
+int vfs_fsync(struct file *file, int datasync)
 {
-       return vfs_fsync_range(file, dentry, 0, LLONG_MAX, datasync);
+       return vfs_fsync_range(file, 0, LLONG_MAX, datasync);
 }
 EXPORT_SYMBOL(vfs_fsync);
 
@@ -239,7 +214,7 @@ static int do_fsync(unsigned int fd, int datasync)
 
        file = fget(fd);
        if (file) {
-               ret = vfs_fsync(file, file->f_path.dentry, datasync);
+               ret = vfs_fsync(file, datasync);
                fput(file);
        }
        return ret;
@@ -267,8 +242,7 @@ int generic_write_sync(struct file *file, loff_t pos, loff_t count)
 {
        if (!(file->f_flags & O_DSYNC) && !IS_SYNC(file->f_mapping->host))
                return 0;
-       return vfs_fsync_range(file, file->f_path.dentry, pos,
-                              pos + count - 1,
+       return vfs_fsync_range(file, pos, pos + count - 1,
                               (file->f_flags & __O_SYNC) ? 0 : 1);
 }
 EXPORT_SYMBOL(generic_write_sync);

diff --git a/include/linux/fs.h b/include/linux/fs.h
index 6660db898c412adfaac260ddab78aa5ed4ef398f..f3e108314c9396bcee96c5f08c6ef6a94dca274f 100644 (file)
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -2084,9 +2084,9 @@ extern int __filemap_fdatawrite_range(struct address_space *mapping,
 extern int filemap_fdatawrite_range(struct address_space *mapping,
                                loff_t start, loff_t end);
 
-extern int vfs_fsync_range(struct file *file, struct dentry *dentry,
-                          loff_t start, loff_t end, int datasync);
-extern int vfs_fsync(struct file *file, struct dentry *dentry, int datasync);
+extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
+                          int datasync);
+extern int vfs_fsync(struct file *file, int datasync);
 extern int generic_write_sync(struct file *file, loff_t pos, loff_t count);
 extern void sync_supers(void);
 extern void emergency_sync(void);

diff --git a/mm/msync.c b/mm/msync.c
index 4083209b7f02e068b94ac50c16d0739a539bc47b..632df4527c0122062d9332a0d483835274ed62f6 100644 (file)
--- a/mm/msync.c
+++ b/mm/msync.c
@@ -82,7 +82,7 @@ SYSCALL_DEFINE3(msync, unsigned long, start, size_t, len, int, flags)
                                (vma->vm_flags & VM_SHARED)) {
                        get_file(file);
                        up_read(&mm->mmap_sem);
-                       error = vfs_fsync(file, file->f_path.dentry, 0);
+                       error = vfs_fsync(file, 0);
                        fput(file);
                        if (error || start >= end)
                                goto out;