lkml.org 
[lkml]   [2012]   [Feb]   [21]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH 56/73] union-mount: In-kernel file copyup routines [ver #2]
Date
When a file on the read-only layer of a union mount is altered, it
must be copied up to the topmost read-write layer. This patch creates
union_copyup() and its supporting routines.

Thanks to Valdis Kletnieks <Valdis.Kletnieks@vt.edu> for a bug fix.

XXX - split up

XXX - If dir xattr copyup fails, delete the newly created dir

XXX - set correct owner after copyup

XXX - reimplement with get_unlinked_inode()

Original-author: Valerie Aurora <vaurora@redhat.com>
Signed-off-by: David Howells <dhowells@redhat.com> (Further development)
---
fs/union.c | 266 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
fs/union.h | 31 +++++++
2 files changed, 296 insertions(+), 1 deletions(-)
diff --git a/fs/union.c b/fs/union.c
index 8efed50..b8ee42d 100644
--- a/fs/union.c
+++ b/fs/union.c
@@ -24,6 +24,8 @@
#include <linux/xattr.h>
#include <linux/file.h>
#include <linux/security.h>
+#include <linux/splice.h>
+#include <linux/xattr.h>

#include "union.h"

@@ -197,9 +199,16 @@ int union_create_topmost_dir(struct path *parent, struct qstr *name,

error = union_copyup_xattr(lower->dentry, topmost->dentry);
if (error)
- dput(topmost->dentry);
+ goto out_rmdir;

fsnotify_mkdir(dir, topmost->dentry);
+
+ mnt_drop_write(parent->mnt);
+
+ return 0;
+out_rmdir:
+ /* XXX rm created dir */
+ dput(topmost->dentry);
out:
mnt_drop_write(parent->mnt);
return error;
@@ -439,3 +448,258 @@ int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
return -ENOENT;
}
EXPORT_SYMBOL(generic_readdir_fallthru);
+
+/**
+ * union_create_file
+ * @nd: namediata for source file
+ * @lower: path of the source file
+ * @new: path of the new file, negative dentry
+ *
+ * Must already have mnt_want_write() on the mnt and the parent's i_mutex.
+ */
+static int union_create_file(struct nameidata *nd, struct path *lower,
+ struct dentry *new)
+{
+ struct path *parent = &nd->path;
+
+ BUG_ON(!mutex_is_locked(&parent->dentry->d_inode->i_mutex));
+
+ return vfs_create(parent->dentry->d_inode, new,
+ lower->dentry->d_inode->i_mode, nd);
+}
+
+/**
+ * union_create_symlink
+ * @nd: namediata for source symlink
+ * @lower: path of the source symlink
+ * @new: path of the new symlink, negative dentry
+ *
+ * Must already have mnt_want_write() on the mnt and the parent's i_mutex.
+ */
+static int union_create_symlink(struct nameidata *nd, struct path *lower,
+ struct dentry *new)
+{
+ struct path *parent = &nd->path;
+ void *cookie;
+ int error;
+
+ BUG_ON(!mutex_is_locked(&parent->dentry->d_inode->i_mutex));
+
+ /* We want the contents of this symlink, not to follow it, so this is
+ * modeled on generic_readlink() rather than do_follow_link().
+ */
+ nd->depth = 0;
+ cookie = lower->dentry->d_inode->i_op->follow_link(lower->dentry, nd);
+ if (IS_ERR(cookie))
+ return PTR_ERR(cookie);
+
+ /* Create a copy of the link on the top layer */
+ error = vfs_symlink(parent->dentry->d_inode, new, nd_get_link(nd));
+ if (lower->dentry->d_inode->i_op->put_link)
+ lower->dentry->d_inode->i_op->put_link(lower->dentry, nd, cookie);
+ return error;
+}
+
+/**
+ * union_copyup_data - Copy up len bytes of old's data to new
+ * @lower: path of source file in lower layer
+ * @new_mnt: vfsmount of target file
+ * @new_dentry: dentry of target file
+ * @len: number of bytes to copy
+ */
+static int union_copyup_data(struct path *lower, struct vfsmount *new_mnt,
+ struct dentry *new_dentry, size_t len)
+{
+ const struct cred *cred = current_cred();
+ struct file *lower_file;
+ struct file *new_file;
+ loff_t offset = 0;
+ long bytes;
+ int error = 0;
+
+ if (len == 0)
+ return 0;
+
+ /* Get reference to balance later fput() */
+ path_get(lower);
+ lower_file = dentry_open(lower->dentry, lower->mnt, O_RDONLY, cred);
+ if (IS_ERR(lower_file))
+ return PTR_ERR(lower_file);
+
+ mntget(new_mnt);
+ dget(new_dentry);
+ new_file = dentry_open(new_dentry, new_mnt, O_WRONLY, cred);
+ if (IS_ERR(new_file)) {
+ error = PTR_ERR(new_file);
+ goto out_fput;
+ }
+
+ bytes = do_splice_direct(lower_file, &offset, new_file, len,
+ SPLICE_F_MOVE);
+ if (bytes < 0)
+ error = bytes;
+
+ fput(new_file);
+out_fput:
+ fput(lower_file);
+ return error;
+}
+
+/**
+ * union_copyup_file - Copy up a regular file, symlink or special file
+ * @nd: nameidata for topmost parent dir
+ * @lower: path of file to be copied up
+ * @dentry: dentry to copy up to
+ * @len: number of bytes of file data to copy up
+ */
+int union_copyup_file(struct nameidata *nd, struct path *lower,
+ struct dentry *dentry, size_t len)
+{
+ struct path *parent = &nd->path;
+ int error;
+
+ BUG_ON(!mutex_is_locked(&parent->dentry->d_inode->i_mutex));
+
+ if (S_ISREG(lower->dentry->d_inode->i_mode)) {
+ error = union_create_file(nd, lower, dentry);
+ if (error)
+ return error;
+ error = union_copyup_data(lower, parent->mnt, dentry, len);
+ } else if (S_ISLNK(lower->dentry->d_inode->i_mode)) {
+ return union_create_symlink(nd, lower, dentry);
+ } else {
+ /* Don't currently support copyup of special files, though in
+ * theory there's no reason we couldn't at least copy up
+ * blockdev, chrdev and FIFO files
+ */
+ return -EXDEV;
+ }
+ if (error)
+ /* Most likely error: ENOSPC */
+ vfs_unlink(parent->dentry->d_inode, dentry);
+
+ return error;
+}
+
+/**
+ * __union_copyup_len - Copy up a file and len bytes of data
+ * @nd: nameidata for topmost parent dir
+ * @path: path of file to be copied up
+ * @len: number of bytes of file data to copy up
+ *
+ * Parent's i_mutex must be held by caller. Newly copied up path is
+ * returned in @path and original is path_put().
+ */
+static int __union_copyup_len(struct nameidata *nd, struct path *path,
+ size_t len)
+{
+ struct dentry *dentry;
+ struct path *parent = &nd->path;
+ int error;
+
+ BUG_ON(!mutex_is_locked(&parent->dentry->d_inode->i_mutex));
+
+ dentry = lookup_one_len(path->dentry->d_name.name, parent->dentry,
+ path->dentry->d_name.len);
+ if (IS_ERR(dentry))
+ return PTR_ERR(dentry);
+
+ if (dentry->d_inode) {
+ /* We raced with someone else and "lost". That's okay, they
+ * did all the work of copying up the file.
+ *
+ * Note that currently data copyup happens under the parent
+ * dir's i_mutex. If we move it outside that, we'll need some
+ * way of waiting for the data copyup to complete here.
+ */
+ error = 0;
+ } else {
+ error = union_copyup_file(nd, path, dentry, len);
+ if (error < 0)
+ goto out_dput;
+ }
+
+ /* Move to the new dentry */
+ path_put(path);
+ path->dentry = dentry;
+ path->mnt = mntget(parent->mnt);
+ return error;
+
+out_dput:
+ /* Don't path_put(path), let caller unwind */
+ dput(dentry);
+ return error;
+}
+
+/**
+ * do_union_copyup_len - Copy up a file given its path (and its parent's)
+ * @nd: nameidata for topmost parent dir
+ * @path: path of file to be copied up
+ * @copy_all: if set, copy all of the file's data and ignore @len
+ * @len: if @copy_all is not set, number of bytes of file data to copy up
+ *
+ * Newly copied up path is returned in @path.
+ */
+static int do_union_copyup_len(struct nameidata *nd, struct path *path,
+ int copy_all, size_t len)
+{
+ struct path *parent = &nd->path;
+ int error;
+
+ if (!IS_DIR_UNIONED(parent->dentry) ||
+ parent->mnt == path->mnt)
+ return 0;
+ if (!S_ISREG(path->dentry->d_inode->i_mode) &&
+ !S_ISLNK(path->dentry->d_inode->i_mode))
+ return 0;
+
+ BUG_ON(!S_ISDIR(parent->dentry->d_inode->i_mode));
+
+ mutex_lock(&parent->dentry->d_inode->i_mutex);
+ error = -ENOENT;
+ if (IS_DEADDIR(parent->dentry->d_inode))
+ goto out_unlock;
+
+ if (copy_all && S_ISREG(path->dentry->d_inode->i_mode)) {
+ error = -EFBIG;
+ len = i_size_read(path->dentry->d_inode);
+ /* Check for overflow of file size */
+ if ((ssize_t)len != len)
+ goto out_unlock;
+ }
+
+ error = __union_copyup_len(nd, path, len);
+
+out_unlock:
+ mutex_unlock(&parent->dentry->d_inode->i_mutex);
+ return error;
+}
+
+/*
+ * Helper function to copy up all of a file
+ */
+int union_copyup(struct nameidata *nd, struct path *path)
+{
+ return do_union_copyup_len(nd, path, 1, 0);
+}
+
+/*
+ * Unlocked helper function to copy up all of a file
+ */
+int __union_copyup(struct nameidata *nd, struct path *path)
+{
+ loff_t len;
+ len = i_size_read(path->dentry->d_inode);
+ if ((ssize_t)len != len)
+ return -EFBIG;
+
+ return __union_copyup_len(nd, path, len);
+}
+
+/*
+ * Helper function to copy up part of a file for truncate and O_TRUNC.
+ */
+int union_copyup_len(struct nameidata *nd, struct path *path, size_t len)
+{
+ return do_union_copyup_len(nd, path, 0, len);
+}
diff --git a/fs/union.h b/fs/union.h
index 46944b9..62d8ef5 100644
--- a/fs/union.h
+++ b/fs/union.h
@@ -19,6 +19,7 @@
#include <linux/mount.h>
#include <linux/dcache.h>
#include <linux/path.h>
+#include <linux/namei.h>
#include <linux/bug.h>

/*
@@ -73,6 +74,11 @@ extern int union_create_topmost_dir(struct path *, struct qstr *, struct path *,
extern int union_copyup_dir(struct path *);
extern int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
int namlen, ino_t *ino, unsigned char *d_type);
+extern int union_copyup(struct nameidata *, struct path *);
+extern int __union_copyup(struct nameidata *, struct path *);
+extern int union_copyup_len(struct nameidata *, struct path *, size_t len);
+extern int union_copyup_file(struct nameidata *nd, struct path *lower,
+ struct dentry *dentry, size_t len);

static inline
struct path *union_find_dir(struct dentry *dentry, unsigned int layer)
@@ -147,4 +153,29 @@ int generic_readdir_fallthru(struct dentry *topmost_dentry, const char *name,
return 0;
}

+static inline int union_copyup(struct nameidata *nd, struct path *path)
+{
+ BUG();
+ return 0;
+}
+
+static inline int __union_copyup(struct nameidata *nd, struct path *path)
+{
+ BUG();
+ return 0;
+}
+
+static inline int union_copyup_len(struct nameidata *nd, struct path *path,
+ size_t len)
+{
+ BUG();
+ return 0;
+}
+
+static inline int union_copyup_file(struct nameidata *nd, struct path *lower,
+ struct dentry *dentry, size_t len)
+{
+ return 0;
+}
+
#endif /* CONFIG_UNION_MOUNT */


\
 
 \ /
  Last update: 2012-02-21 20:59    [from the cache]
©2003-2014 Jasper Spaans. hosted at Digital Ocean