X-Git-Url: https://git.camperquake.de/gitweb.cgi?a=blobdiff_plain;f=module%2Fzfs%2Fzpl_file.c;h=6598c177971d46abbe6e3299f698249e70853582;hb=refs%2Fheads%2Frertzinger%2Ffeature-zpool-get--p;hp=298c0b62df751dcc7ad13c380ef43b2b28a9d70d;hpb=6a95d0b74c2951f0dc82361ea279f64a7349f060;p=zfs.git

diff --git a/module/zfs/zpl_file.c b/module/zfs/zpl_file.c
index 298c0b6..6598c17 100644
--- a/module/zfs/zpl_file.c
+++ b/module/zfs/zpl_file.c
@@ -52,6 +52,9 @@ zpl_release(struct inode *ip, struct file *filp)
 	cred_t *cr = CRED();
 	int error;
 
+	if (ITOZ(ip)->z_atime_dirty)
+		mark_inode_dirty(ip);
+
 	crhold(cr);
 	error = -zfs_close(ip, filp->f_flags, cr);
 	crfree(cr);
@@ -61,52 +64,106 @@ zpl_release(struct inode *ip, struct file *filp)
 }
 
 static int
-zpl_readdir(struct file *filp, void *dirent, filldir_t filldir)
+zpl_iterate(struct file *filp, struct dir_context *ctx)
 {
 	struct dentry *dentry = filp->f_path.dentry;
 	cred_t *cr = CRED();
 	int error;
 
 	crhold(cr);
-	error = -zfs_readdir(dentry->d_inode, dirent, filldir,
-	    &filp->f_pos, cr);
+	error = -zfs_readdir(dentry->d_inode, ctx, cr);
 	crfree(cr);
 	ASSERT3S(error, <=, 0);
 
 	return (error);
 }
 
+#if !defined(HAVE_VFS_ITERATE)
+static int
+zpl_readdir(struct file *filp, void *dirent, filldir_t filldir)
+{
+	struct dir_context ctx = DIR_CONTEXT_INIT(dirent, filldir, filp->f_pos);
+	int error;
+
+	error = zpl_iterate(filp, &ctx);
+	filp->f_pos = ctx.pos;
+
+	return (error);
+}
+#endif /* HAVE_VFS_ITERATE */
+
+#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,
@@ -194,6 +251,28 @@ zpl_write(struct file *filp, const char __user *buf, size_t len, loff_t *ppos)
 	return (wrote);
 }
 
+static loff_t
+zpl_llseek(struct file *filp, loff_t offset, int whence)
+{
+#if defined(SEEK_HOLE) && defined(SEEK_DATA)
+	if (whence == SEEK_DATA || whence == SEEK_HOLE) {
+		struct inode *ip = filp->f_mapping->host;
+		loff_t maxbytes = ip->i_sb->s_maxbytes;
+		loff_t error;
+
+		spl_inode_lock(ip);
+		error = -zfs_holey(ip, whence, &offset);
+		if (error == 0)
+			error = lseek_execute(filp, ip, offset, maxbytes);
+		spl_inode_unlock(ip);
+
+		return (error);
+	}
+#endif /* SEEK_HOLE && SEEK_DATA */
+
+	return generic_file_llseek(filp, offset, whence);
+}
+
 /*
  * It's worth taking a moment to describe how mmap is implemented
  * for zfs because it differs considerably from other Linux filesystems.
@@ -316,21 +395,16 @@ zpl_putpage(struct page *pp, struct writeback_control *wbc, void *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.
 	 */
-	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;
-	}
+	current->flags |= PF_NOFS;
+	(void) zfs_putpage(mapping->host, pp, wbc);
+	current->flags &= ~PF_NOFS;
 
 	return (0);
 }
@@ -353,6 +427,71 @@ 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 */
+
+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,
@@ -363,17 +502,31 @@ const struct address_space_operations zpl_address_space_operations = {
 const struct file_operations zpl_file_operations = {
 	.open		= zpl_open,
 	.release	= zpl_release,
-	.llseek		= generic_file_llseek,
+	.llseek		= zpl_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 = {
 	.llseek		= generic_file_llseek,
 	.read		= generic_read_dir,
+#ifdef HAVE_VFS_ITERATE
+	.iterate	= zpl_iterate,
+#else
 	.readdir	= zpl_readdir,
+#endif
 	.fsync		= zpl_fsync,
+	.unlocked_ioctl = zpl_ioctl,
+#ifdef CONFIG_COMPAT
+	.compat_ioctl   = zpl_compat_ioctl,
+#endif
 };