lkml.org 
[lkml]   [2008]   [May]   [16]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
Patch in this message
/
From
Subject[PATCH 29/67] aufs copy-up functions, see wbr_policy.c for copy-down
Date
From: Junjiro Okajima <hooanon05@yahoo.co.jp>

initial commit
aufs copy-up functions, see wbr_policy.c for copy-down

Signed-off-by: Junjiro Okajima <hooanon05@yahoo.co.jp>
---
fs/aufs/cpup.c | 1043 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 1043 insertions(+), 0 deletions(-)
diff --git a/fs/aufs/cpup.c b/fs/aufs/cpup.c
new file mode 100644
index 0000000..3227d19
--- /dev/null
+++ b/fs/aufs/cpup.c
@@ -0,0 +1,1043 @@
+/*
+ * Copyright (C) 2005-2008 Junjiro Okajima
+ *
+ * This program, aufs is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/*
+ * copy-up functions, see wbr_policy.c for copy-down
+ *
+ * $Id: cpup.c,v 1.5 2008/05/12 00:29:11 sfjro Exp $
+ */
+
+#include <linux/fs_stack.h>
+#include <linux/uaccess.h>
+#include "aufs.h"
+
+/* violent cpup_attr_*() functions don't care inode lock */
+void au_cpup_attr_timesizes(struct inode *inode)
+{
+ struct inode *h_inode;
+
+ LKTRTrace("i%lu\n", inode->i_ino);
+ //IMustLock(inode);
+ h_inode = au_h_iptr(inode, au_ibstart(inode));
+ AuDebugOn(!h_inode);
+ //IMustLock(!h_inode);
+
+ fsstack_copy_attr_times(inode, h_inode);
+ //todo: this spin_lock conflicts the new unionfs patch in -mm tree
+ //spin_lock(&inode->i_lock);
+ fsstack_copy_inode_size(inode, h_inode);
+ //spin_unlock(&inode->i_lock);
+}
+
+void au_cpup_attr_nlink(struct inode *inode)
+{
+ struct inode *h_inode;
+
+ LKTRTrace("i%lu\n", inode->i_ino);
+ //IMustLock(inode);
+ AuDebugOn(!inode->i_mode);
+
+ h_inode = au_h_iptr(inode, au_ibstart(inode));
+ inode->i_nlink = h_inode->i_nlink;
+
+ /*
+ * fewer nlink makes find(1) noisy, but larger nlink doesn't.
+ * it may includes whplink directory.
+ */
+ if (unlikely(S_ISDIR(h_inode->i_mode))) {
+ aufs_bindex_t bindex, bend;
+ bend = au_ibend(inode);
+ for (bindex = au_ibstart(inode) + 1; bindex <= bend; bindex++) {
+ h_inode = au_h_iptr(inode, bindex);
+ if (h_inode)
+ au_add_nlink(inode, h_inode);
+ }
+ }
+}
+
+void au_cpup_attr_changeable(struct inode *inode)
+{
+ struct inode *h_inode;
+
+ LKTRTrace("i%lu\n", inode->i_ino);
+ //IMustLock(inode);
+ h_inode = au_h_iptr(inode, au_ibstart(inode));
+ AuDebugOn(!h_inode);
+
+ inode->i_mode = h_inode->i_mode;
+ inode->i_uid = h_inode->i_uid;
+ inode->i_gid = h_inode->i_gid;
+ au_cpup_attr_timesizes(inode);
+
+ //??
+ inode->i_flags = h_inode->i_flags;
+}
+
+void au_cpup_igen(struct inode *inode, struct inode *h_inode)
+{
+ inode->i_generation = h_inode->i_generation;
+ au_ii(inode)->ii_hsb1 = h_inode->i_sb;
+}
+
+void au_cpup_attr_all(struct inode *inode)
+{
+ struct inode *h_inode;
+
+ LKTRTrace("i%lu\n", inode->i_ino);
+ //IMustLock(inode);
+ h_inode = au_h_iptr(inode, au_ibstart(inode));
+ AuDebugOn(!h_inode);
+
+ au_cpup_attr_changeable(inode);
+ if (inode->i_nlink > 0)
+ au_cpup_attr_nlink(inode);
+
+ switch (inode->i_mode & S_IFMT) {
+ case S_IFBLK:
+ case S_IFCHR:
+ inode->i_rdev = au_h_rdev(h_inode, /*h_mnt*/NULL,
+ /*h_dentry*/NULL);
+ }
+ inode->i_blkbits = h_inode->i_blkbits;
+ au_cpup_igen(inode, h_inode);
+}
+
+/* ---------------------------------------------------------------------- */
+
+/* Note: dt_dentry and dt_hidden_dentry are not dget/dput-ed */
+
+/* keep the timestamps of the parent dir when cpup */
+void au_dtime_store(struct au_dtime *dt, struct dentry *dentry,
+ struct dentry *h_dentry, struct au_hinode *hdir)
+{
+ struct inode *inode;
+
+ LKTRTrace("%.*s, hdir %d\n", AuDLNPair(dentry), !!hdir);
+ AuDebugOn(!dentry || !h_dentry || !h_dentry->d_inode);
+
+ dt->dt_dentry = dentry;
+ dt->dt_h_dentry = h_dentry;
+ dt->dt_hdir = hdir;
+ inode = h_dentry->d_inode;
+ dt->dt_atime = inode->i_atime;
+ dt->dt_mtime = inode->i_mtime;
+ //smp_mb();
+}
+
+void au_dtime_revert(struct au_dtime *dt)
+{
+ struct iattr attr;
+ int err;
+ struct au_hin_ignore ign;
+ struct vfsub_args vargs;
+
+ LKTRTrace("%.*s\n", AuDLNPair(dt->dt_dentry));
+
+ attr.ia_atime = dt->dt_atime;
+ attr.ia_mtime = dt->dt_mtime;
+ attr.ia_valid = ATTR_FORCE | ATTR_MTIME | ATTR_MTIME_SET
+ | ATTR_ATIME | ATTR_ATIME_SET;
+
+ vfsub_args_init(&vargs, &ign,
+ au_opt_test_dlgt(au_mntflags(dt->dt_dentry->d_sb)), 0);
+ if (unlikely(dt->dt_hdir))
+ vfsub_ign_hinode(&vargs, IN_ATTRIB, dt->dt_hdir);
+ err = vfsub_notify_change(dt->dt_h_dentry, &attr, &vargs);
+ if (unlikely(err))
+ AuWarn("restoring timestamps failed(%d). ignored\n", err);
+}
+
+/* ---------------------------------------------------------------------- */
+
+static noinline_for_stack int
+cpup_iattr(struct dentry *h_dst, struct dentry *h_src, int dlgt)
+{
+ int err, sbits;
+ struct iattr ia;
+ struct inode *h_isrc, *h_idst;
+ struct vfsub_args vargs;
+
+ LKTRTrace("%.*s\n", AuDLNPair(h_dst));
+ h_idst = h_dst->d_inode;
+ //IMustLock(h_idst);
+ h_isrc = h_src->d_inode;
+ //IMustLock(h_isrc);
+
+ ia.ia_valid = ATTR_FORCE | ATTR_MODE | ATTR_UID | ATTR_GID
+ | ATTR_ATIME | ATTR_MTIME
+ | ATTR_ATIME_SET | ATTR_MTIME_SET;
+ ia.ia_mode = h_isrc->i_mode;
+ ia.ia_uid = h_isrc->i_uid;
+ ia.ia_gid = h_isrc->i_gid;
+ ia.ia_atime = h_isrc->i_atime;
+ ia.ia_mtime = h_isrc->i_mtime;
+ sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID));
+
+ vfsub_args_init(&vargs, NULL, dlgt, /*force_unlink*/0);
+ err = vfsub_notify_change(h_dst, &ia, &vargs);
+ //if (LktrCond) err = -1;
+
+ /* is this nfs only? */
+ if (!err && sbits && au_test_nfs(h_dst->d_sb)) {
+ ia.ia_valid = ATTR_FORCE | ATTR_MODE;
+ ia.ia_mode = h_isrc->i_mode;
+ err = vfsub_notify_change(h_dst, &ia, &vargs);
+ }
+
+ if (!err)
+ h_idst->i_flags = h_isrc->i_flags; //??
+
+ AuTraceErr(err);
+ return err;
+}
+
+/*
+ * to support a sparse file which is opened with O_APPEND,
+ * we need to close the file.
+ */
+static noinline_for_stack int
+cpup_regular(struct dentry *dentry, aufs_bindex_t bdst, aufs_bindex_t bsrc,
+ loff_t len)
+{
+ int err, i;
+ struct super_block *sb;
+ struct inode *h_inode;
+ enum { SRC, DST };
+ struct {
+ aufs_bindex_t bindex;
+ unsigned int flags;
+ struct dentry *dentry;
+ struct file *file;
+ void *label, *label_file;
+ } *h, hidden[] = {
+ {
+ .bindex = bsrc,
+ .flags = O_RDONLY | O_NOATIME | O_LARGEFILE,
+ .file = NULL,
+ .label = &&out,
+ .label_file = &&out_src_file
+ },
+ {
+ .bindex = bdst,
+ .flags = O_WRONLY | O_NOATIME | O_LARGEFILE,
+ .file = NULL,
+ .label = &&out_src_file,
+ .label_file = &&out_dst_file
+ }
+ };
+
+ LKTRTrace("dentry %.*s, bdst %d, bsrc %d, len %lld\n",
+ AuDLNPair(dentry), bdst, bsrc, len);
+ AuDebugOn(bsrc <= bdst);
+ AuDebugOn(!len);
+ sb = dentry->d_sb;
+ AuDebugOn(au_test_ro(sb, bdst, dentry->d_inode));
+ /* bsrc branch can be ro/rw. */
+
+ h = hidden;
+ for (i = 0; i < 2; i++, h++) {
+ h->dentry = au_h_dptr(dentry, h->bindex);
+ AuDebugOn(!h->dentry);
+ h_inode = h->dentry->d_inode;
+ AuDebugOn(!h_inode || !S_ISREG(h_inode->i_mode));
+ h->file = au_h_open(dentry, h->bindex, h->flags, /*file*/NULL);
+ //if (LktrCond)
+ //{fput(h->file);au_sbr_put(sb, h->bindex);h->file=ERR_PTR(-1);}
+ err = PTR_ERR(h->file);
+ if (IS_ERR(h->file))
+ goto *h->label;
+ err = -EINVAL;
+ if (unlikely(!h->file->f_op))
+ goto *h->label_file;
+ }
+
+ /* stop updating while we copyup */
+ IMustLock(hidden[SRC].dentry->d_inode);
+ err = au_copy_file(hidden[DST].file, hidden[SRC].file, len, sb);
+
+ out_dst_file:
+ fput(hidden[DST].file);
+ au_sbr_put(sb, hidden[DST].bindex);
+ out_src_file:
+ fput(hidden[SRC].file);
+ au_sbr_put(sb, hidden[SRC].bindex);
+ out:
+ AuTraceErr(err);
+ return err;
+}
+
+static noinline_for_stack int
+au_do_cpup_regular(struct dentry *dentry, aufs_bindex_t bdst,
+ aufs_bindex_t bsrc, loff_t len, struct inode *h_inode,
+ struct inode *h_dir, struct dentry *h_dst, int dlgt)
+{
+ int err, rerr;
+ loff_t l;
+ struct vfsub_args vargs;
+
+ AuTraceEnter();
+
+ err = 0;
+ l = i_size_read(h_inode);
+ if (len == -1 || l < len)
+ len = l;
+ if (len)
+ err = cpup_regular(dentry, bdst, bsrc, len);
+ //if (LktrCond) err = -1;
+ if (!err)
+ goto out; /* success */
+
+ vfsub_args_init(&vargs, NULL, dlgt, 0);
+ rerr = vfsub_unlink(h_dir, h_dst, &vargs);
+ if (rerr) {
+ AuIOErr("failed unlinking cpup-ed %.*s(%d, %d)\n",
+ AuDLNPair(h_dst), err, rerr);
+ err = -EIO;
+ }
+
+ out:
+ AuTraceErr(err);
+ return err;
+}
+
+static noinline_for_stack int
+au_do_cpup_symlink(struct dentry *h_dst, struct dentry *h_src,
+ struct inode *h_dir, umode_t mode, int dlgt)
+{
+ int err, symlen;
+ char *sym;
+ mm_segment_t old_fs;
+
+ AuTraceEnter();
+
+ err = -ENOMEM;
+ sym = __getname();
+ //if (LktrCond) {__putname(sym); sym = NULL;}
+ if (unlikely(!sym))
+ goto out;
+
+ old_fs = get_fs();
+ set_fs(KERNEL_DS);
+ symlen = h_src->d_inode->i_op->readlink(h_src, (char __user *)sym,
+ PATH_MAX);
+ err = symlen;
+ //if (LktrCond) err = symlen = -1;
+ set_fs(old_fs);
+
+ if (symlen > 0) {
+ sym[symlen] = 0;
+ err = vfsub_symlink(h_dir, h_dst, sym, mode, dlgt);
+ //if (LktrCond)
+ //{vfs_unlink(h_dir, h_dst); err = -1;}
+ }
+ __putname(sym);
+
+ out:
+ AuTraceErr(err);
+ return err;
+}
+
+/* return with hidden dst inode is locked */
+static noinline_for_stack int
+cpup_entry(struct dentry *dentry, aufs_bindex_t bdst, aufs_bindex_t bsrc,
+ loff_t len, unsigned int flags, int dlgt)
+{
+ int err, isdir, hinotify;
+ struct dentry *h_src, *h_dst, *h_parent, *parent;
+ struct inode *h_inode, *h_dir;
+ struct au_dtime dt;
+ umode_t mode;
+ struct super_block *sb;
+ struct au_hinode *hgdir;
+ const int do_dt = au_ftest_cpup(flags, DTIME);
+ unsigned int mnt_flags;
+
+ LKTRTrace("%.*s, i%lu, bdst %d, bsrc %d, len %Ld, dtime %u\n",
+ AuDLNPair(dentry), dentry->d_inode->i_ino, bdst, bsrc, len,
+ do_dt);
+ sb = dentry->d_sb;
+ AuDebugOn(bdst >= bsrc || au_test_ro(sb, bdst, NULL));
+ /* bsrc branch can be ro/rw. */
+
+ h_src = au_h_dptr(dentry, bsrc);
+ AuDebugOn(!h_src);
+ h_inode = h_src->d_inode;
+ AuDebugOn(!h_inode);
+
+ /* stop referencing while we are creating */
+ parent = dget_parent(dentry);
+ h_dst = au_h_dptr(dentry, bdst);
+ AuDebugOn(h_dst && h_dst->d_inode);
+ h_parent = h_dst->d_parent; /* dir inode is locked */
+ h_dir = h_parent->d_inode;
+ IMustLock(h_dir);
+
+ mnt_flags = au_mntflags(sb);
+ hinotify = !!au_opt_test(mnt_flags, UDBA_INOTIFY);
+ if (do_dt) {
+ hgdir = NULL;
+ if (unlikely(hinotify && !IS_ROOT(parent))) {
+ struct dentry *gparent;
+ gparent = dget_parent(parent);
+ hgdir = au_hi(gparent->d_inode, bdst);
+ dput(gparent);
+ }
+ au_dtime_store(&dt, parent, h_parent, hgdir);
+ }
+
+ isdir = 0;
+ mode = h_inode->i_mode;
+ switch (mode & S_IFMT) {
+ case S_IFREG:
+ /* stop updating while we are referencing */
+ IMustLock(h_inode);
+ err = au_h_create(h_dir, h_dst, mode | S_IWUSR, dlgt, NULL,
+ au_nfsmnt(sb, bdst));
+ //if (LktrCond) {vfs_unlink(h_dir, h_dst); err = -1;}
+ if (!err)
+ err = au_do_cpup_regular(dentry, bdst, bsrc, len,
+ h_inode, h_dir, h_dst, dlgt);
+ break;
+ case S_IFDIR:
+ isdir = 1;
+ err = vfsub_mkdir(h_dir, h_dst, mode, dlgt);
+ //if (LktrCond) {vfs_rmdir(h_dir, h_dst); err = -1;}
+ if (!err) {
+ /* setattr case: dir is not locked */
+ if (0 && au_ibstart(parent->d_inode) == bdst)
+ au_cpup_attr_nlink(parent->d_inode);
+ au_cpup_attr_nlink(dentry->d_inode);
+ }
+ break;
+ case S_IFLNK:
+ err = au_do_cpup_symlink(h_dst, h_src, h_dir, mode, dlgt);
+ break;
+ case S_IFCHR:
+ case S_IFBLK:
+ AuDebugOn(!capable(CAP_MKNOD));
+ /*FALLTHROUGH*/
+ case S_IFIFO:
+ case S_IFSOCK:
+ err = vfsub_mknod(h_dir, h_dst, mode,
+ au_h_rdev(h_inode, /*h_mnt*/NULL, h_src),
+ dlgt);
+ //if (LktrCond) {vfs_unlink(h_dir, h_dst); err = -1;}
+ break;
+ default:
+ AuIOErr("Unknown inode type 0%o\n", mode);
+ err = -EIO;
+ }
+
+ //todo: should it be always?
+ if (unlikely(hinotify
+ && !isdir
+ && au_opt_test(mnt_flags, XINO)
+ && h_inode->i_nlink == 1
+ && bdst < bsrc))
+ au_xino_write0(sb, bsrc, h_inode->i_ino, /*ino*/0);
+ /* ignore this error */
+
+ if (do_dt)
+ au_dtime_revert(&dt);
+ dput(parent);
+ AuTraceErr(err);
+ return err;
+}
+
+/*
+ * copyup the @dentry from @bsrc to @bdst.
+ * the caller must set the both of hidden dentries.
+ * @len is for truncating when it is -1 copyup the entire file.
+ */
+int au_cpup_single(struct dentry *dentry, aufs_bindex_t bdst,
+ aufs_bindex_t bsrc, loff_t len, unsigned int flags)
+{
+ int err, rerr, isdir, dlgt, plink;
+ struct dentry *h_src, *h_dst, *parent, *h_parent;
+ struct inode *dst_inode, *h_dir, *inode;
+ struct super_block *sb;
+ aufs_bindex_t old_ibstart;
+ struct au_dtime dt;
+ struct vfsub_args vargs;
+ struct au_hinode *hgdir;
+ unsigned int mnt_flags;
+
+ LKTRTrace("%.*s, i%lu, bdst %d, bsrc %d, len %Ld, flags 0x%x\n",
+ AuDLNPair(dentry), dentry->d_inode->i_ino, bdst, bsrc, len,
+ flags);
+ sb = dentry->d_sb;
+ AuDebugOn(bsrc <= bdst);
+ h_dst = au_h_dptr(dentry, bdst);
+ AuDebugOn(!h_dst || h_dst->d_inode);
+ h_parent = h_dst->d_parent; /* dir inode is locked */
+ h_dir = h_parent->d_inode;
+ IMustLock(h_dir);
+ h_src = au_h_dptr(dentry, bsrc);
+ AuDebugOn(!h_src || !h_src->d_inode);
+ inode = dentry->d_inode;
+ IiMustWriteLock(inode);
+ parent = dget_parent(dentry);
+
+ mnt_flags = au_mntflags(sb);
+ dlgt = !!au_opt_test_dlgt(mnt_flags);
+ plink = !!au_opt_test(mnt_flags, PLINK);
+ dst_inode = au_h_iptr(inode, bdst);
+ if (unlikely(dst_inode)) {
+ if (unlikely(!plink)) {
+ err = -EIO;
+ AuIOErr("i%lu exists on a upper branch "
+ "but plink is disabled\n", inode->i_ino);
+ goto out;
+ }
+
+ if (dst_inode->i_nlink) {
+ h_src = au_plink_lkup(sb, bdst, inode);
+ err = PTR_ERR(h_src);
+ if (IS_ERR(h_src))
+ goto out;
+ AuDebugOn(!h_src->d_inode);
+ err = vfsub_link(h_src, h_dir, h_dst, dlgt);
+ dput(h_src);
+ goto out;
+ } else
+ //todo: cpup_wh_file
+ /* udba work */
+ au_update_brange(inode, 1);
+ }
+
+ old_ibstart = au_ibstart(inode);
+ err = cpup_entry(dentry, bdst, bsrc, len, flags, dlgt);
+ if (unlikely(err))
+ goto out;
+ dst_inode = h_dst->d_inode;
+ mutex_lock_nested(&dst_inode->i_mutex, AuLsc_I_CHILD2);
+
+ //todo: test dlgt
+ err = cpup_iattr(h_dst, h_src, dlgt);
+ //if (LktrCond) err = -1;
+#if 0 // xattr
+ if (0 && !err)
+ err = cpup_xattrs(h_src, h_dst);
+#endif
+ isdir = S_ISDIR(dst_inode->i_mode);
+ if (!err) {
+ if (bdst < old_ibstart)
+ au_set_ibstart(inode, bdst);
+ au_set_h_iptr(inode, bdst, igrab(dst_inode),
+ au_hi_flags(inode, isdir));
+ mutex_unlock(&dst_inode->i_mutex);
+ if (!isdir
+ && h_src->d_inode->i_nlink > 1
+ && plink)
+ au_plink_append(sb, inode, h_dst, bdst);
+ goto out; /* success */
+ }
+
+ /* revert */
+ mutex_unlock(&dst_inode->i_mutex);
+ hgdir = NULL;
+ if (unlikely(au_opt_test(mnt_flags, UDBA_INOTIFY)
+ && !IS_ROOT(parent))) {
+ struct dentry *gparent;
+ gparent = dget_parent(parent);
+ hgdir = au_hi(gparent->d_inode, bdst);
+ dput(gparent);
+ }
+ au_dtime_store(&dt, parent, h_parent, hgdir);
+ vfsub_args_init(&vargs, NULL, dlgt, 0);
+ if (!isdir)
+ rerr = vfsub_unlink(h_dir, h_dst, &vargs);
+ else
+ rerr = vfsub_rmdir(h_dir, h_dst, &vargs);
+ //rerr = -1;
+ au_dtime_revert(&dt);
+ if (rerr) {
+ AuIOErr("failed removing broken entry(%d, %d)\n", err, rerr);
+ err = -EIO;
+ }
+
+ out:
+ dput(parent);
+ AuTraceErr(err);
+ return err;
+}
+
+struct au_cpup_single_args {
+ int *errp;
+ struct dentry *dentry;
+ aufs_bindex_t bdst, bsrc;
+ loff_t len;
+ unsigned int flags;
+};
+
+static void au_call_cpup_single(void *args)
+{
+ struct au_cpup_single_args *a = args;
+ *a->errp = au_cpup_single(a->dentry, a->bdst, a->bsrc, a->len,
+ a->flags);
+}
+
+int au_sio_cpup_single(struct dentry *dentry, aufs_bindex_t bdst,
+ aufs_bindex_t bsrc, loff_t len, unsigned int flags)
+{
+ int err, wkq_err;
+ struct dentry *h_dentry;
+ umode_t mode;
+
+ LKTRTrace("%.*s, i%lu, bdst %d, bsrc %d, len %Ld, flags 0x%x\n",
+ AuDLNPair(dentry), dentry->d_inode->i_ino, bdst, bsrc, len,
+ flags);
+
+ h_dentry = au_h_dptr(dentry, bsrc);
+ mode = h_dentry->d_inode->i_mode & S_IFMT;
+ if ((mode != S_IFCHR && mode != S_IFBLK)
+ || capable(CAP_MKNOD))
+ err = au_cpup_single(dentry, bdst, bsrc, len, flags);
+ else {
+ struct au_cpup_single_args args = {
+ .errp = &err,
+ .dentry = dentry,
+ .bdst = bdst,
+ .bsrc = bsrc,
+ .len = len,
+ .flags = flags
+ };
+ wkq_err = au_wkq_wait(au_call_cpup_single, &args, /*dlgt*/0);
+ if (unlikely(wkq_err))
+ err = wkq_err;
+ }
+
+ AuTraceErr(err);
+ return err;
+}
+
+/*
+ * copyup the @dentry from the first active hidden branch to @bdst,
+ * using au_cpup_single().
+ */
+int au_cpup_simple(struct dentry *dentry, aufs_bindex_t bdst, loff_t len,
+ unsigned int flags)
+{
+ int err;
+ struct inode *inode;
+ aufs_bindex_t bsrc, bend;
+
+ LKTRTrace("%.*s, bdst %d, len %Ld, flags 0x%x\n",
+ AuDLNPair(dentry), bdst, len, flags);
+ inode = dentry->d_inode;
+ AuDebugOn(!S_ISDIR(inode->i_mode) && au_dbstart(dentry) < bdst);
+
+ bend = au_dbend(dentry);
+ for (bsrc = bdst + 1; bsrc <= bend; bsrc++)
+ if (au_h_dptr(dentry, bsrc))
+ break;
+ AuDebugOn(!au_h_dptr(dentry, bsrc));
+
+ err = au_lkup_neg(dentry, bdst);
+ //err = -1;
+ if (!err) {
+ err = au_cpup_single(dentry, bdst, bsrc, len, flags);
+ if (!err)
+ return 0; /* success */
+
+ /* revert */
+ au_set_h_dptr(dentry, bdst, NULL);
+ au_set_dbstart(dentry, bsrc);
+ }
+
+ AuTraceErr(err);
+ return err;
+}
+
+struct au_cpup_simple_args {
+ int *errp;
+ struct dentry *dentry;
+ aufs_bindex_t bdst;
+ loff_t len;
+ unsigned int flags;
+};
+
+static void au_call_cpup_simple(void *args)
+{
+ struct au_cpup_simple_args *a = args;
+ *a->errp = au_cpup_simple(a->dentry, a->bdst, a->len, a->flags);
+}
+
+int au_sio_cpup_simple(struct dentry *dentry, aufs_bindex_t bdst, loff_t len,
+ unsigned int flags)
+{
+ int err, do_sio, dlgt, wkq_err;
+ struct dentry *parent;
+ struct inode *h_dir, *dir;
+
+ LKTRTrace("%.*s, b%d, len %Ld, flags 0x%x\n",
+ AuDLNPair(dentry), bdst, len, flags);
+
+ parent = dget_parent(dentry);
+ dir = parent->d_inode;
+ h_dir = au_h_iptr(dir, bdst);
+ dlgt = !!au_opt_test_dlgt(au_mntflags(dir->i_sb));
+ do_sio = au_test_h_perm_sio(h_dir, MAY_EXEC | MAY_WRITE, dlgt);
+ if (!do_sio) {
+ /*
+ * testing CAP_MKNOD is for generic fs,
+ * but CAP_FSETID is for xfs only, currently.
+ */
+ umode_t mode = dentry->d_inode->i_mode;
+ do_sio = (((mode & (S_IFCHR | S_IFBLK))
+ && !capable(CAP_MKNOD))
+ || ((mode & (S_ISUID | S_ISGID))
+ && !capable(CAP_FSETID)));
+ }
+ if (!do_sio)
+ err = au_cpup_simple(dentry, bdst, len, flags);
+ else {
+ struct au_cpup_simple_args args = {
+ .errp = &err,
+ .dentry = dentry,
+ .bdst = bdst,
+ .len = len,
+ .flags = flags
+ };
+ wkq_err = au_wkq_wait(au_call_cpup_simple, &args, /*dlgt*/0);
+ if (unlikely(wkq_err))
+ err = wkq_err;
+ }
+
+ dput(parent);
+ AuTraceErr(err);
+ return err;
+}
+
+/* ---------------------------------------------------------------------- */
+
+static noinline_for_stack int
+au_do_cpup_wh(struct dentry *dentry, aufs_bindex_t bdst,
+ struct dentry *wh_dentry, struct file *file, loff_t len)
+{
+ int err;
+ struct au_dinfo *dinfo;
+ aufs_bindex_t bstart;
+ struct dentry *h_d_bdst, *h_d_bstart;
+
+ AuTraceEnter();
+
+ dinfo = au_di(dentry);
+ bstart = dinfo->di_bstart;
+ h_d_bdst = dinfo->di_hdentry[0 + bdst].hd_dentry;
+ dinfo->di_bstart = bdst;
+ dinfo->di_hdentry[0 + bdst].hd_dentry = wh_dentry;
+ h_d_bstart = dinfo->di_hdentry[0 + bstart].hd_dentry;
+ if (file)
+ dinfo->di_hdentry[0 + bstart].hd_dentry
+ = au_h_fptr(file, au_fbstart(file))->f_dentry;
+ err = au_cpup_single(dentry, bdst, bstart, len, !AuCpup_DTIME);
+ //if (LktrCond) err = -1;
+ if (!err && file) {
+ err = au_reopen_nondir(file);
+ //err = -1;
+ dinfo->di_hdentry[0 + bstart].hd_dentry = h_d_bstart;
+ }
+ dinfo->di_hdentry[0 + bdst].hd_dentry = h_d_bdst;
+ dinfo->di_bstart = bstart;
+
+ AuTraceErr(err);
+ return err;
+}
+
+/*
+ * copyup the deleted file for writing.
+ */
+int au_cpup_wh(struct dentry *dentry, aufs_bindex_t bdst, loff_t len,
+ struct file *file)
+{
+ int err, dlgt;
+ struct dentry *parent, *h_parent, *wh_dentry;
+ struct super_block *sb;
+ unsigned int mnt_flags;
+ struct au_dtime dt;
+ struct vfsub_args vargs;
+ struct au_hinode *hgdir;
+ struct au_ndx ndx = {
+ .nd = NULL,
+ .flags = 0,
+ //.br = NULL
+ };
+
+ LKTRTrace("%.*s, bdst %d, len %Lu\n", AuDLNPair(dentry), bdst, len);
+ AuDebugOn(S_ISDIR(dentry->d_inode->i_mode)
+ || (file && !(file->f_mode & FMODE_WRITE)));
+ DiMustWriteLock(dentry);
+
+ parent = dget_parent(dentry);
+ IiMustAnyLock(parent->d_inode);
+ h_parent = au_h_dptr(parent, bdst);
+ AuDebugOn(!h_parent);
+
+ sb = parent->d_sb;
+ mnt_flags = au_mntflags(sb);
+ dlgt = 0;
+ ndx.nfsmnt = au_nfsmnt(sb, bdst);
+ if (unlikely(au_opt_test_dlgt(mnt_flags))) {
+ dlgt = 1;
+ au_fset_ndx(ndx.flags, DLGT);
+ }
+ wh_dentry = au_whtmp_lkup(h_parent, &dentry->d_name, &ndx);
+ //if (LktrCond) {dput(wh_dentry); wh_dentry = ERR_PTR(-1);}
+ err = PTR_ERR(wh_dentry);
+ if (IS_ERR(wh_dentry))
+ goto out;
+
+ hgdir = NULL;
+ if (unlikely(au_opt_test(mnt_flags, UDBA_INOTIFY)
+ && !IS_ROOT(parent))) {
+ struct dentry *gparent;
+ gparent = dget_parent(parent);
+ hgdir = au_hi(gparent->d_inode, bdst);
+ dput(gparent);
+ }
+ au_dtime_store(&dt, parent, h_parent, hgdir);
+ err = au_do_cpup_wh(dentry, bdst, wh_dentry, file, len);
+ if (unlikely(err))
+ goto out_wh;
+
+ AuDebugOn(!d_unhashed(dentry));
+ /* dget first to force sillyrename on nfs */
+ dget(wh_dentry);
+ vfsub_args_init(&vargs, NULL, dlgt, 0);
+ err = vfsub_unlink(h_parent->d_inode, wh_dentry, &vargs);
+ //if (LktrCond) err = -1;
+ if (unlikely(err)) {
+ AuIOErr("failed remove copied-up tmp file %.*s(%d)\n",
+ AuDLNPair(wh_dentry), err);
+ err = -EIO;
+ }
+ au_dtime_revert(&dt);
+ au_set_hi_wh(dentry->d_inode, bdst, wh_dentry);
+
+ out_wh:
+ dput(wh_dentry);
+ out:
+ dput(parent);
+ AuTraceErr(err);
+ //au_debug_off();
+ return err;
+}
+
+struct au_cpup_wh_args {
+ int *errp;
+ struct dentry *dentry;
+ aufs_bindex_t bdst;
+ loff_t len;
+ struct file *file;
+};
+
+static void au_call_cpup_wh(void *args)
+{
+ struct au_cpup_wh_args *a = args;
+ *a->errp = au_cpup_wh(a->dentry, a->bdst, a->len, a->file);
+}
+
+int au_sio_cpup_wh(struct dentry *dentry, aufs_bindex_t bdst, loff_t len,
+ struct file *file)
+{
+ int err, wkq_err;
+ struct dentry *parent;
+ struct inode *dir, *h_dir;
+
+ AuTraceEnter();
+ parent = dget_parent(dentry);
+ dir = parent->d_inode;
+ IiMustAnyLock(dir);
+ h_dir = au_h_iptr(dir, bdst);
+
+ if (!au_test_h_perm_sio
+ (h_dir, MAY_EXEC | MAY_WRITE,
+ au_opt_test_dlgt(au_mntflags(dentry->d_sb))))
+ err = au_cpup_wh(dentry, bdst, len, file);
+ else {
+ struct au_cpup_wh_args args = {
+ .errp = &err,
+ .dentry = dentry,
+ .bdst = bdst,
+ .len = len,
+ .file = file
+ };
+ wkq_err = au_wkq_wait(au_call_cpup_wh, &args, /*dlgt*/0);
+ if (unlikely(wkq_err))
+ err = wkq_err;
+ }
+ dput(parent);
+
+ AuTraceErr(err);
+ return err;
+}
+
+/* ---------------------------------------------------------------------- */
+
+/*
+ * generic routine for both of copy-up and copy-down.
+ * Although I've tried building a path by dcsub, I gave up this approach.
+ * Since the ancestor directory may be moved/renamed during copy.
+ */
+/* cf. revalidate function in file.c */
+int au_cp_dirs(struct dentry *dentry, aufs_bindex_t bdst, struct dentry *locked,
+ int (*cp)(struct dentry *dentry, aufs_bindex_t bdst,
+ struct dentry *h_parent, void *arg),
+ void *arg)
+{
+ int err, hinotify;
+ struct super_block *sb;
+ struct dentry *d, *parent, *h_parent, *gparent, *real_parent;
+
+ LKTRTrace("%.*s, b%d, parent i%lu, locked %p\n",
+ AuDLNPair(dentry), bdst, parent_ino(dentry), locked);
+ sb = dentry->d_sb;
+ AuDebugOn(au_test_ro(sb, bdst, NULL));
+ err = 0;
+ parent = dget_parent(dentry);
+ IiMustWriteLock(parent->d_inode);
+ if (unlikely(IS_ROOT(parent)))
+ goto out;
+ if (locked) {
+ DiMustAnyLock(locked);
+ IiMustAnyLock(locked->d_inode);
+ }
+
+ /* slow loop, keep it simple and stupid */
+ real_parent = parent;
+ hinotify = !!au_opt_test(au_mntflags(sb), UDBA_INOTIFY);
+ while (1) {
+ dput(parent);
+ parent = dget_parent(dentry);
+ h_parent = au_h_dptr(parent, bdst);
+ if (h_parent)
+ goto out; /* success */
+
+ /* find top dir which is needed to cpup */
+ do {
+ d = parent;
+ dput(parent);
+ parent = dget_parent(d);
+ if (parent != locked) {
+ di_read_lock_parent3(parent, !AuLock_IR);
+ h_parent = au_h_dptr(parent, bdst);
+ di_read_unlock(parent, !AuLock_IR);
+ } else
+ h_parent = au_h_dptr(parent, bdst);
+ } while (!h_parent);
+
+ if (d != real_parent)
+ di_write_lock_child3(d);
+
+ /* somebody else might create while we were sleeping */
+ if (!au_h_dptr(d, bdst) || !au_h_dptr(d, bdst)->d_inode) {
+ struct inode *h_dir = h_parent->d_inode,
+ *dir = parent->d_inode;
+
+ if (au_h_dptr(d, bdst))
+ au_update_dbstart(d);
+ //AuDebugOn(au_dbstart(d) <= bdst);
+ if (parent != locked)
+ di_read_lock_parent3(parent, AuLock_IR);
+ gparent = NULL;
+ if (unlikely(hinotify && !IS_ROOT(parent))) {
+ gparent = dget_parent(parent);
+ if (gparent != locked)
+ ii_read_lock_parent4(gparent->d_inode);
+ else {
+ dput(gparent);
+ gparent = NULL;
+ }
+ }
+ au_hdir_lock(h_dir, dir, bdst);
+ err = cp(d, bdst, h_parent, arg);
+ //if (LktrCond) err = -1;
+ au_hdir_unlock(h_dir, dir, bdst);
+ if (unlikely(gparent)) {
+ ii_read_unlock(gparent->d_inode);
+ dput(gparent);
+ }
+ if (parent != locked)
+ di_read_unlock(parent, AuLock_IR);
+ }
+
+ if (d != real_parent)
+ di_write_unlock(d);
+ if (unlikely(err))
+ break;
+ }
+
+ out:
+ dput(parent);
+ AuTraceErr(err);
+ return err;
+}
+
+static int au_cpup_dir(struct dentry *dentry, aufs_bindex_t bdst,
+ struct dentry *h_parent, void *arg)
+{
+ int err;
+
+ err = au_sio_cpup_simple(dentry, bdst, -1, AuCpup_DTIME);
+
+ AuTraceErr(err);
+ return err;
+}
+
+int au_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst,
+ struct dentry *locked)
+{
+ int err;
+
+ err = au_cp_dirs(dentry, bdst, locked, au_cpup_dir, NULL);
+
+ AuTraceErr(err);
+ return err;
+}
+
+int au_test_and_cpup_dirs(struct dentry *dentry, aufs_bindex_t bdst,
+ struct dentry *locked)
+{
+ int err;
+ struct dentry *parent;
+ struct inode *dir;
+
+ parent = dget_parent(dentry);
+ dir = parent->d_inode;
+ LKTRTrace("%.*s, b%d, parent i%lu, locked %p\n",
+ AuDLNPair(dentry), bdst, dir->i_ino, locked);
+ DiMustReadLock(parent);
+ IiMustReadLock(dir);
+
+ err = 0;
+ if (au_h_iptr(dir, bdst))
+ goto out;
+
+ di_read_unlock(parent, AuLock_IR);
+ di_write_lock_parent2(parent);
+ /* someone else might change our inode while we were sleeping */
+ if (unlikely(!au_h_iptr(dir, bdst)))
+ err = au_cpup_dirs(dentry, bdst, locked);
+ di_downgrade_lock(parent, AuLock_IR);
+
+ out:
+ dput(parent);
+ AuTraceErr(err);
+ return err;
+}
--
1.4.4.4


\
 
 \ /
  Last update: 2008-05-16 16:57    [from the cache]
©2003-2011 Jasper Spaans