Support the fallocate() file operation.

[zfs.git] / module / zfs / zpl_file.c

diff --git a/module/zfs/zpl_file.c b/module/zfs/zpl_file.c
index af46afd..5ac41c9 100644 (file)
--- a/module/zfs/zpl_file.c
+++ b/module/zfs/zpl_file.c
@@ -76,37 +76,78 @@ zpl_readdir(struct file *filp, void *dirent, filldir_t filldir)
        return (error);
 }
 
+#if defined(HAVE_FSYNC_WITH_DENTRY)
 /*
- * 2.6.35 API change,
- * As of 2.6.35 the dentry argument to the .fsync() vfs hook was deemed
+ * Linux 2.6.x - 2.6.34 API,
+ * Through 2.6.34 the nfsd kernel server would pass a NULL 'file struct *'
+ * to the fops->fsync() hook.  For this reason, we must be careful not to
+ * use filp unconditionally.
+ */
+static int
+zpl_fsync(struct file *filp, struct dentry *dentry, int datasync)
+{
+       cred_t *cr = CRED();
+       int error;
+
+       crhold(cr);
+       error = -zfs_fsync(dentry->d_inode, datasync, cr);
+       crfree(cr);
+       ASSERT3S(error, <=, 0);
+
+       return (error);
+}
+
+#elif defined(HAVE_FSYNC_WITHOUT_DENTRY)
+/*
+ * Linux 2.6.35 - 3.0 API,
+ * As of 2.6.35 the dentry argument to the fops->fsync() hook was deemed
  * redundant.  The dentry is still accessible via filp->f_path.dentry,
  * and we are guaranteed that filp will never be NULL.
- *
- * 2.6.34 API change,
- * Prior to 2.6.34 the nfsd kernel server would pass a NULL file struct *
- * to the .fsync() hook.  For this reason, we must be careful not to use
- * filp unconditionally in the 3 argument case.
  */
-#ifdef HAVE_2ARGS_FSYNC
 static int
 zpl_fsync(struct file *filp, int datasync)
 {
-       struct dentry *dentry = filp->f_path.dentry;
-#else
+       struct inode *inode = filp->f_mapping->host;
+       cred_t *cr = CRED();
+       int error;
+
+       crhold(cr);
+       error = -zfs_fsync(inode, datasync, cr);
+       crfree(cr);
+       ASSERT3S(error, <=, 0);
+
+       return (error);
+}
+
+#elif defined(HAVE_FSYNC_RANGE)
+/*
+ * Linux 3.1 - 3.x API,
+ * As of 3.1 the responsibility to call filemap_write_and_wait_range() has
+ * been pushed down in to the .fsync() vfs hook.  Additionally, the i_mutex
+ * lock is no longer held by the caller, for zfs we don't require the lock
+ * to be held so we don't acquire it.
+ */
 static int
-zpl_fsync(struct file *filp, struct dentry *dentry, int datasync)
+zpl_fsync(struct file *filp, loff_t start, loff_t end, int datasync)
 {
-#endif /* HAVE_2ARGS_FSYNC */
+       struct inode *inode = filp->f_mapping->host;
        cred_t *cr = CRED();
        int error;
 
+       error = filemap_write_and_wait_range(inode->i_mapping, start, end);
+       if (error)
+               return (error);
+
        crhold(cr);
-       error = -zfs_fsync(dentry->d_inode, datasync, cr);
+       error = -zfs_fsync(inode, datasync, cr);
        crfree(cr);
        ASSERT3S(error, <=, 0);
 
        return (error);
 }
+#else
+#error "Unsupported fops->fsync() implementation"
+#endif
 
 ssize_t
 zpl_read_common(struct inode *ip, const char *buf, size_t len, loff_t pos,
@@ -324,9 +365,13 @@ zpl_putpage(struct page *pp, struct writeback_control *wbc, void *data)
         * the VM might try to write out additional pages by calling
         * zpl_putpage() again resulting in a deadlock.
         */
-       current->flags |= PF_MEMALLOC;
-       (void) zfs_putpage(mapping->host, pp, wbc);
-       current->flags &= ~PF_MEMALLOC;
+       if (current->flags & PF_MEMALLOC) {
+               (void) zfs_putpage(mapping->host, pp, wbc);
+       } else {
+               current->flags |= PF_MEMALLOC;
+               (void) zfs_putpage(mapping->host, pp, wbc);
+               current->flags &= ~PF_MEMALLOC;
+       }
 
        return (0);
 }
@@ -349,6 +394,50 @@ zpl_writepage(struct page *pp, struct writeback_control *wbc)
        return zpl_putpage(pp, wbc, pp->mapping);
 }
 
+/*
+ * The only flag combination which matches the behavior of zfs_space()
+ * is FALLOC_FL_PUNCH_HOLE.  This flag was introduced in the 2.6.38 kernel.
+ */
+long
+zpl_fallocate_common(struct inode *ip, int mode, loff_t offset, loff_t len)
+{
+       cred_t *cr = CRED();
+       int error = -EOPNOTSUPP;
+
+       if (mode & FALLOC_FL_KEEP_SIZE)
+               return (-EOPNOTSUPP);
+
+       crhold(cr);
+
+#ifdef FALLOC_FL_PUNCH_HOLE
+       if (mode & FALLOC_FL_PUNCH_HOLE) {
+               flock64_t bf;
+
+               bf.l_type = F_WRLCK;
+               bf.l_whence = 0;
+               bf.l_start = offset;
+               bf.l_len = len;
+               bf.l_pid = 0;
+
+               error = -zfs_space(ip, F_FREESP, &bf, FWRITE, offset, cr);
+       }
+#endif /* FALLOC_FL_PUNCH_HOLE */
+
+       crfree(cr);
+
+       ASSERT3S(error, <=, 0);
+       return (error);
+}
+
+#ifdef HAVE_FILE_FALLOCATE
+static long
+zpl_fallocate(struct file *filp, int mode, loff_t offset, loff_t len)
+{
+       return zpl_fallocate_common(filp->f_path.dentry->d_inode,
+           mode, offset, len);
+}
+#endif /* HAVE_FILE_FALLOCATE */
+
 const struct address_space_operations zpl_address_space_operations = {
        .readpages      = zpl_readpages,
        .readpage       = zpl_readpage,
@@ -365,6 +454,9 @@ const struct file_operations zpl_file_operations = {
        .readdir        = zpl_readdir,
        .mmap           = zpl_mmap,
        .fsync          = zpl_fsync,
+#ifdef HAVE_FILE_FALLOCATE
+       .fallocate      = zpl_fallocate,
+#endif /* HAVE_FILE_FALLOCATE */
 };
 
 const struct file_operations zpl_dir_file_operations = {