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,
return (error);
}
-static struct page **
-pages_vector_from_list(struct list_head *pages, unsigned nr_pages)
-{
- struct page **pl;
- struct page *t;
- unsigned page_idx;
-
- pl = kmalloc(sizeof(*pl) * nr_pages, GFP_NOFS);
- if (!pl)
- return ERR_PTR(-ENOMEM);
-
- page_idx = 0;
- list_for_each_entry_reverse(t, pages, lru) {
- pl[page_idx] = t;
- page_idx++;
- }
-
- return pl;
-}
-
-static int
-zpl_readpages(struct file *file, struct address_space *mapping,
- struct list_head *pages, unsigned nr_pages)
-{
- struct inode *ip;
- struct page **pl;
- struct page *p, *n;
- int error;
-
- ip = mapping->host;
-
- pl = pages_vector_from_list(pages, nr_pages);
- if (IS_ERR(pl))
- return PTR_ERR(pl);
-
- error = -zfs_getpage(ip, pl, nr_pages);
- if (error)
- goto error;
-
- list_for_each_entry_safe_reverse(p, n, pages, lru) {
-
- list_del(&p->lru);
-
- flush_dcache_page(p);
- SetPageUptodate(p);
- unlock_page(p);
- page_cache_release(p);
- }
-
-error:
- kfree(pl);
- return error;
-}
-
/*
* Populate a page with data for the Linux page cache. This function is
* only used to support mmap(2). There will be an identical copy of the
return error;
}
+/*
+ * Populate a set of pages with data for the Linux page cache. This
+ * function will only be called for read ahead and never for demand
+ * paging. For simplicity, the code relies on read_cache_pages() to
+ * correctly lock each page for IO and call zpl_readpage().
+ */
+static int
+zpl_readpages(struct file *filp, struct address_space *mapping,
+ struct list_head *pages, unsigned nr_pages)
+{
+ return (read_cache_pages(mapping, pages,
+ (filler_t *)zpl_readpage, filp));
+}
+
int
zpl_putpage(struct page *pp, struct writeback_control *wbc, void *data)
{
- int error;
+ struct address_space *mapping = data;
+
+ ASSERT(PageLocked(pp));
+ ASSERT(!PageWriteback(pp));
+ ASSERT(!(current->flags & PF_NOFS));
/*
- * Disable the normal reclaim path for zpl_putpage(). This
- * ensures that all memory allocations under this call path
- * will never enter direct reclaim. If this were to happen
- * the VM might try to write out additional pages by calling
- * zpl_putpage() again resulting in a deadlock.
+ * Annotate this call path with a flag that indicates that it is
+ * unsafe to use KM_SLEEP during memory allocations due to the
+ * potential for a deadlock. KM_PUSHPAGE should be used instead.
*/
- current->flags |= PF_MEMALLOC;
- error = -zfs_putpage(pp, wbc, data);
- current->flags &= ~PF_MEMALLOC;
+ current->flags |= PF_NOFS;
+ (void) zfs_putpage(mapping->host, pp, wbc);
+ current->flags &= ~PF_NOFS;
- if (error) {
- SetPageError(pp);
- ClearPageUptodate(pp);
- } else {
- ClearPageError(pp);
- SetPageUptodate(pp);
- flush_dcache_page(pp);
- }
-
- unlock_page(pp);
- return error;
+ return (0);
}
static int
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 */
+
+static long
+zpl_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+ switch (cmd) {
+ case ZFS_IOC_GETFLAGS:
+ case ZFS_IOC_SETFLAGS:
+ return (-EOPNOTSUPP);
+ default:
+ return (-ENOTTY);
+ }
+}
+
+#ifdef CONFIG_COMPAT
+static long
+zpl_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
+{
+ return zpl_ioctl(filp, cmd, arg);
+}
+#endif /* CONFIG_COMPAT */
+
+
const struct address_space_operations zpl_address_space_operations = {
.readpages = zpl_readpages,
.readpage = zpl_readpage,
.llseek = generic_file_llseek,
.read = zpl_read,
.write = zpl_write,
- .readdir = zpl_readdir,
.mmap = zpl_mmap,
.fsync = zpl_fsync,
+#ifdef HAVE_FILE_FALLOCATE
+ .fallocate = zpl_fallocate,
+#endif /* HAVE_FILE_FALLOCATE */
+ .unlocked_ioctl = zpl_ioctl,
+#ifdef CONFIG_COMPAT
+ .compat_ioctl = zpl_compat_ioctl,
+#endif
};
const struct file_operations zpl_dir_file_operations = {
.read = generic_read_dir,
.readdir = zpl_readdir,
.fsync = zpl_fsync,
+ .unlocked_ioctl = zpl_ioctl,
+#ifdef CONFIG_COMPAT
+ .compat_ioctl = zpl_compat_ioctl,
+#endif
};
git://git.camperquake.de / zfs.git / blobdiff