From f20cc753998dfb4e273a7f12c7e05fd5bab7eaef Mon Sep 17 00:00:00 2001
From: Waldemar Brodkorb <wbx@openadk.org>
Date: Sun, 2 Aug 2015 21:18:16 +0200
Subject: remove non-lts kernel

---
 target/linux/patches/4.0.6/aufs4.patch             | 33447 -------------------
 target/linux/patches/4.0.6/cleankernel.patch       |    11 -
 target/linux/patches/4.0.6/cris-header.patch       |    12 -
 .../patches/4.0.6/initramfs-nosizelimit.patch      |    57 -
 target/linux/patches/4.0.6/startup.patch           |    37 -
 5 files changed, 33564 deletions(-)
 delete mode 100644 target/linux/patches/4.0.6/aufs4.patch
 delete mode 100644 target/linux/patches/4.0.6/cleankernel.patch
 delete mode 100644 target/linux/patches/4.0.6/cris-header.patch
 delete mode 100644 target/linux/patches/4.0.6/initramfs-nosizelimit.patch
 delete mode 100644 target/linux/patches/4.0.6/startup.patch

(limited to 'target/linux')

diff --git a/target/linux/patches/4.0.6/aufs4.patch b/target/linux/patches/4.0.6/aufs4.patch
deleted file mode 100644
index db38c850a..000000000
--- a/target/linux/patches/4.0.6/aufs4.patch
+++ /dev/null
@@ -1,33447 +0,0 @@
-diff -Nur linux-4.0.5.orig/drivers/block/loop.c linux-4.0.5/drivers/block/loop.c
---- linux-4.0.5.orig/drivers/block/loop.c	2015-06-06 10:21:22.000000000 -0500
-+++ linux-4.0.5/drivers/block/loop.c	2015-06-21 14:08:17.146432521 -0500
-@@ -592,6 +592,24 @@
- 	return i && S_ISBLK(i->i_mode) && MAJOR(i->i_rdev) == LOOP_MAJOR;
- }
- 
-+/*
-+ * for AUFS
-+ * no get/put for file.
-+ */
-+struct file *loop_backing_file(struct super_block *sb)
-+{
-+	struct file *ret;
-+	struct loop_device *l;
-+
-+	ret = NULL;
-+	if (MAJOR(sb->s_dev) == LOOP_MAJOR) {
-+		l = sb->s_bdev->bd_disk->private_data;
-+		ret = l->lo_backing_file;
-+	}
-+	return ret;
-+}
-+EXPORT_SYMBOL(loop_backing_file);
-+
- /* loop sysfs attributes */
- 
- static ssize_t loop_attr_show(struct device *dev, char *page,
-diff -Nur linux-4.0.5.orig/fs/aufs/aufs.h linux-4.0.5/fs/aufs/aufs.h
---- linux-4.0.5.orig/fs/aufs/aufs.h	1969-12-31 18:00:00.000000000 -0600
-+++ linux-4.0.5/fs/aufs/aufs.h	2015-06-21 14:07:48.682432781 -0500
-@@ -0,0 +1,59 @@
-+/*
-+ * Copyright (C) 2005-2015 Junjiro R. 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, see <http://www.gnu.org/licenses/>.
-+ */
-+
-+/*
-+ * all header files
-+ */
-+
-+#ifndef __AUFS_H__
-+#define __AUFS_H__
-+
-+#ifdef __KERNEL__
-+
-+#define AuStub(type, name, body, ...) \
-+	static inline type name(__VA_ARGS__) { body; }
-+
-+#define AuStubVoid(name, ...) \
-+	AuStub(void, name, , __VA_ARGS__)
-+#define AuStubInt0(name, ...) \
-+	AuStub(int, name, return 0, __VA_ARGS__)
-+
-+#include "debug.h"
-+
-+#include "branch.h"
-+#include "cpup.h"
-+#include "dcsub.h"
-+#include "dbgaufs.h"
-+#include "dentry.h"
-+#include "dir.h"
-+#include "dynop.h"
-+#include "file.h"
-+#include "fstype.h"
-+#include "inode.h"
-+#include "loop.h"
-+#include "module.h"
-+#include "opts.h"
-+#include "rwsem.h"
-+#include "spl.h"
-+#include "super.h"
-+#include "sysaufs.h"
-+#include "vfsub.h"
-+#include "whout.h"
-+#include "wkq.h"
-+
-+#endif /* __KERNEL__ */
-+#endif /* __AUFS_H__ */
-diff -Nur linux-4.0.5.orig/fs/aufs/branch.c linux-4.0.5/fs/aufs/branch.c
---- linux-4.0.5.orig/fs/aufs/branch.c	1969-12-31 18:00:00.000000000 -0600
-+++ linux-4.0.5/fs/aufs/branch.c	2015-06-21 14:07:48.682432781 -0500
-@@ -0,0 +1,1406 @@
-+/*
-+ * Copyright (C) 2005-2015 Junjiro R. 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, see <http://www.gnu.org/licenses/>.
-+ */
-+
-+/*
-+ * branch management
-+ */
-+
-+#include <linux/compat.h>
-+#include <linux/statfs.h>
-+#include "aufs.h"
-+
-+/*
-+ * free a single branch
-+ */
-+static void au_br_do_free(struct au_branch *br)
-+{
-+	int i;
-+	struct au_wbr *wbr;
-+	struct au_dykey **key;
-+
-+	au_hnotify_fin_br(br);
-+
-+	if (br->br_xino.xi_file)
-+		fput(br->br_xino.xi_file);
-+	mutex_destroy(&br->br_xino.xi_nondir_mtx);
-+
-+	AuDebugOn(atomic_read(&br->br_count));
-+
-+	wbr = br->br_wbr;
-+	if (wbr) {
-+		for (i = 0; i < AuBrWh_Last; i++)
-+			dput(wbr->wbr_wh[i]);
-+		AuDebugOn(atomic_read(&wbr->wbr_wh_running));
-+		AuRwDestroy(&wbr->wbr_wh_rwsem);
-+	}
-+
-+	if (br->br_fhsm) {
-+		au_br_fhsm_fin(br->br_fhsm);
-+		kfree(br->br_fhsm);
-+	}
-+
-+	key = br->br_dykey;
-+	for (i = 0; i < AuBrDynOp; i++, key++)
-+		if (*key)
-+			au_dy_put(*key);
-+		else
-+			break;
-+
-+	/* recursive lock, s_umount of branch's */
-+	lockdep_off();
-+	path_put(&br->br_path);
-+	lockdep_on();
-+	kfree(wbr);
-+	kfree(br);
-+}
-+
-+/*
-+ * frees all branches
-+ */
-+void au_br_free(struct au_sbinfo *sbinfo)
-+{
-+	aufs_bindex_t bmax;
-+	struct au_branch **br;
-+
-+	AuRwMustWriteLock(&sbinfo->si_rwsem);
-+
-+	bmax = sbinfo->si_bend + 1;
-+	br = sbinfo->si_branch;
-+	while (bmax--)
-+		au_br_do_free(*br++);
-+}
-+
-+/*
-+ * find the index of a branch which is specified by @br_id.
-+ */
-+int au_br_index(struct super_block *sb, aufs_bindex_t br_id)
-+{
-+	aufs_bindex_t bindex, bend;
-+
-+	bend = au_sbend(sb);
-+	for (bindex = 0; bindex <= bend; bindex++)
-+		if (au_sbr_id(sb, bindex) == br_id)
-+			return bindex;
-+	return -1;
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/*
-+ * add a branch
-+ */
-+
-+static int test_overlap(struct super_block *sb, struct dentry *h_adding,
-+			struct dentry *h_root)
-+{
-+	if (unlikely(h_adding == h_root
-+		     || au_test_loopback_overlap(sb, h_adding)))
-+		return 1;
-+	if (h_adding->d_sb != h_root->d_sb)
-+		return 0;
-+	return au_test_subdir(h_adding, h_root)
-+		|| au_test_subdir(h_root, h_adding);
-+}
-+
-+/*
-+ * returns a newly allocated branch. @new_nbranch is a number of branches
-+ * after adding a branch.
-+ */
-+static struct au_branch *au_br_alloc(struct super_block *sb, int new_nbranch,
-+				     int perm)
-+{
-+	struct au_branch *add_branch;
-+	struct dentry *root;
-+	int err;
-+
-+	err = -ENOMEM;
-+	root = sb->s_root;
-+	add_branch = kmalloc(sizeof(*add_branch), GFP_NOFS);
-+	if (unlikely(!add_branch))
-+		goto out;
-+
-+	err = au_hnotify_init_br(add_branch, perm);
-+	if (unlikely(err))
-+		goto out_br;
-+
-+	add_branch->br_wbr = NULL;
-+	if (au_br_writable(perm)) {
-+		/* may be freed separately at changing the branch permission */
-+		add_branch->br_wbr = kmalloc(sizeof(*add_branch->br_wbr),
-+					     GFP_NOFS);
-+		if (unlikely(!add_branch->br_wbr))
-+			goto out_hnotify;
-+	}
-+
-+	add_branch->br_fhsm = NULL;
-+	if (au_br_fhsm(perm)) {
-+		err = au_fhsm_br_alloc(add_branch);
-+		if (unlikely(err))
-+			goto out_wbr;
-+	}
-+
-+	err = au_sbr_realloc(au_sbi(sb), new_nbranch);
-+	if (!err)
-+		err = au_di_realloc(au_di(root), new_nbranch);
-+	if (!err)
-+		err = au_ii_realloc(au_ii(root->d_inode), new_nbranch);
-+	if (!err)
-+		return add_branch; /* success */
-+
-+out_wbr:
-+	kfree(add_branch->br_wbr);
-+out_hnotify:
-+	au_hnotify_fin_br(add_branch);
-+out_br:
-+	kfree(add_branch);
-+out:
-+	return ERR_PTR(err);
-+}
-+
-+/*
-+ * test if the branch permission is legal or not.
-+ */
-+static int test_br(struct inode *inode, int brperm, char *path)
-+{
-+	int err;
-+
-+	err = (au_br_writable(brperm) && IS_RDONLY(inode));
-+	if (!err)
-+		goto out;
-+
-+	err = -EINVAL;
-+	pr_err("write permission for readonly mount or inode, %s\n", path);
-+
-+out:
-+	return err;
-+}
-+
-+/*
-+ * returns:
-+ * 0: success, the caller will add it
-+ * plus: success, it is already unified, the caller should ignore it
-+ * minus: error
-+ */
-+static int test_add(struct super_block *sb, struct au_opt_add *add, int remount)
-+{
-+	int err;
-+	aufs_bindex_t bend, bindex;
-+	struct dentry *root;
-+	struct inode *inode, *h_inode;
-+
-+	root = sb->s_root;
-+	bend = au_sbend(sb);
-+	if (unlikely(bend >= 0
-+		     && au_find_dbindex(root, add->path.dentry) >= 0)) {
-+		err = 1;
-+		if (!remount) {
-+			err = -EINVAL;
-+			pr_err("%s duplicated\n", add->pathname);
-+		}
-+		goto out;
-+	}
-+
-+	err = -ENOSPC; /* -E2BIG; */
-+	if (unlikely(AUFS_BRANCH_MAX <= add->bindex
-+		     || AUFS_BRANCH_MAX - 1 <= bend)) {
-+		pr_err("number of branches exceeded %s\n", add->pathname);
-+		goto out;
-+	}
-+
-+	err = -EDOM;
-+	if (unlikely(add->bindex < 0 || bend + 1 < add->bindex)) {
-+		pr_err("bad index %d\n", add->bindex);
-+		goto out;
-+	}
-+
-+	inode = add->path.dentry->d_inode;
-+	err = -ENOENT;
-+	if (unlikely(!inode->i_nlink)) {
-+		pr_err("no existence %s\n", add->pathname);
-+		goto out;
-+	}
-+
-+	err = -EINVAL;
-+	if (unlikely(inode->i_sb == sb)) {
-+		pr_err("%s must be outside\n", add->pathname);
-+		goto out;
-+	}
-+
-+	if (unlikely(au_test_fs_unsuppoted(inode->i_sb))) {
-+		pr_err("unsupported filesystem, %s (%s)\n",
-+		       add->pathname, au_sbtype(inode->i_sb));
-+		goto out;
-+	}
-+
-+	if (unlikely(inode->i_sb->s_stack_depth)) {
-+		pr_err("already stacked, %s (%s)\n",
-+		       add->pathname, au_sbtype(inode->i_sb));
-+		goto out;
-+	}
-+
-+	err = test_br(add->path.dentry->d_inode, add->perm, add->pathname);
-+	if (unlikely(err))
-+		goto out;
-+
-+	if (bend < 0)
-+		return 0; /* success */
-+
-+	err = -EINVAL;
-+	for (bindex = 0; bindex <= bend; bindex++)
-+		if (unlikely(test_overlap(sb, add->path.dentry,
-+					  au_h_dptr(root, bindex)))) {
-+			pr_err("%s is overlapped\n", add->pathname);
-+			goto out;
-+		}
-+
-+	err = 0;
-+	if (au_opt_test(au_mntflags(sb), WARN_PERM)) {
-+		h_inode = au_h_dptr(root, 0)->d_inode;
-+		if ((h_inode->i_mode & S_IALLUGO) != (inode->i_mode & S_IALLUGO)
-+		    || !uid_eq(h_inode->i_uid, inode->i_uid)
-+		    || !gid_eq(h_inode->i_gid, inode->i_gid))
-+			pr_warn("uid/gid/perm %s %u/%u/0%o, %u/%u/0%o\n",
-+				add->pathname,
-+				i_uid_read(inode), i_gid_read(inode),
-+				(inode->i_mode & S_IALLUGO),
-+				i_uid_read(h_inode), i_gid_read(h_inode),
-+				(h_inode->i_mode & S_IALLUGO));
-+	}
-+
-+out:
-+	return err;
-+}
-+
-+/*
-+ * initialize or clean the whiteouts for an adding branch
-+ */
-+static int au_br_init_wh(struct super_block *sb, struct au_branch *br,
-+			 int new_perm)
-+{
-+	int err, old_perm;
-+	aufs_bindex_t bindex;
-+	struct mutex *h_mtx;
-+	struct au_wbr *wbr;
-+	struct au_hinode *hdir;
-+
-+	err = vfsub_mnt_want_write(au_br_mnt(br));
-+	if (unlikely(err))
-+		goto out;
-+
-+	wbr = br->br_wbr;
-+	old_perm = br->br_perm;
-+	br->br_perm = new_perm;
-+	hdir = NULL;
-+	h_mtx = NULL;
-+	bindex = au_br_index(sb, br->br_id);
-+	if (0 <= bindex) {
-+		hdir = au_hi(sb->s_root->d_inode, bindex);
-+		au_hn_imtx_lock_nested(hdir, AuLsc_I_PARENT);
-+	} else {
-+		h_mtx = &au_br_dentry(br)->d_inode->i_mutex;
-+		mutex_lock_nested(h_mtx, AuLsc_I_PARENT);
-+	}
-+	if (!wbr)
-+		err = au_wh_init(br, sb);
-+	else {
-+		wbr_wh_write_lock(wbr);
-+		err = au_wh_init(br, sb);
-+		wbr_wh_write_unlock(wbr);
-+	}
-+	if (hdir)
-+		au_hn_imtx_unlock(hdir);
-+	else
-+		mutex_unlock(h_mtx);
-+	vfsub_mnt_drop_write(au_br_mnt(br));
-+	br->br_perm = old_perm;
-+
-+	if (!err && wbr && !au_br_writable(new_perm)) {
-+		kfree(wbr);
-+		br->br_wbr = NULL;
-+	}
-+
-+out:
-+	return err;
-+}
-+
-+static int au_wbr_init(struct au_branch *br, struct super_block *sb,
-+		       int perm)
-+{
-+	int err;
-+	struct kstatfs kst;
-+	struct au_wbr *wbr;
-+
-+	wbr = br->br_wbr;
-+	au_rw_init(&wbr->wbr_wh_rwsem);
-+	memset(wbr->wbr_wh, 0, sizeof(wbr->wbr_wh));
-+	atomic_set(&wbr->wbr_wh_running, 0);
-+	wbr->wbr_bytes = 0;
-+
-+	/*
-+	 * a limit for rmdir/rename a dir
-+	 * cf. AUFS_MAX_NAMELEN in include/uapi/linux/aufs_type.h
-+	 */
-+	err = vfs_statfs(&br->br_path, &kst);
-+	if (unlikely(err))
-+		goto out;
-+	err = -EINVAL;
-+	if (kst.f_namelen >= NAME_MAX)
-+		err = au_br_init_wh(sb, br, perm);
-+	else
-+		pr_err("%pd(%s), unsupported namelen %ld\n",
-+		       au_br_dentry(br),
-+		       au_sbtype(au_br_dentry(br)->d_sb), kst.f_namelen);
-+
-+out:
-+	return err;
-+}
-+
-+/* initialize a new branch */
-+static int au_br_init(struct au_branch *br, struct super_block *sb,
-+		      struct au_opt_add *add)
-+{
-+	int err;
-+
-+	err = 0;
-+	memset(&br->br_xino, 0, sizeof(br->br_xino));
-+	mutex_init(&br->br_xino.xi_nondir_mtx);
-+	br->br_perm = add->perm;
-+	br->br_path = add->path; /* set first, path_get() later */
-+	spin_lock_init(&br->br_dykey_lock);
-+	memset(br->br_dykey, 0, sizeof(br->br_dykey));
-+	atomic_set(&br->br_count, 0);
-+	atomic_set(&br->br_xino_running, 0);
-+	br->br_id = au_new_br_id(sb);
-+	AuDebugOn(br->br_id < 0);
-+
-+	if (au_br_writable(add->perm)) {
-+		err = au_wbr_init(br, sb, add->perm);
-+		if (unlikely(err))
-+			goto out_err;
-+	}
-+
-+	if (au_opt_test(au_mntflags(sb), XINO)) {
-+		err = au_xino_br(sb, br, add->path.dentry->d_inode->i_ino,
-+				 au_sbr(sb, 0)->br_xino.xi_file, /*do_test*/1);
-+		if (unlikely(err)) {
-+			AuDebugOn(br->br_xino.xi_file);
-+			goto out_err;
-+		}
-+	}
-+
-+	sysaufs_br_init(br);
-+	path_get(&br->br_path);
-+	goto out; /* success */
-+
-+out_err:
-+	memset(&br->br_path, 0, sizeof(br->br_path));
-+out:
-+	return err;
-+}
-+
-+static void au_br_do_add_brp(struct au_sbinfo *sbinfo, aufs_bindex_t bindex,
-+			     struct au_branch *br, aufs_bindex_t bend,
-+			     aufs_bindex_t amount)
-+{
-+	struct au_branch **brp;
-+
-+	AuRwMustWriteLock(&sbinfo->si_rwsem);
-+
-+	brp = sbinfo->si_branch + bindex;
-+	memmove(brp + 1, brp, sizeof(*brp) * amount);
-+	*brp = br;
-+	sbinfo->si_bend++;
-+	if (unlikely(bend < 0))
-+		sbinfo->si_bend = 0;
-+}
-+
-+static void au_br_do_add_hdp(struct au_dinfo *dinfo, aufs_bindex_t bindex,
-+			     aufs_bindex_t bend, aufs_bindex_t amount)
-+{
-+	struct au_hdentry *hdp;
-+
-+	AuRwMustWriteLock(&dinfo->di_rwsem);
-+
-+	hdp = dinfo->di_hdentry + bindex;
-+	memmove(hdp + 1, hdp, sizeof(*hdp) * amount);
-+	au_h_dentry_init(hdp);
-+	dinfo->di_bend++;
-+	if (unlikely(bend < 0))
-+		dinfo->di_bstart = 0;
-+}
-+
-+static void au_br_do_add_hip(struct au_iinfo *iinfo, aufs_bindex_t bindex,
-+			     aufs_bindex_t bend, aufs_bindex_t amount)
-+{
-+	struct au_hinode *hip;
-+
-+	AuRwMustWriteLock(&iinfo->ii_rwsem);
-+
-+	hip = iinfo->ii_hinode + bindex;
-+	memmove(hip + 1, hip, sizeof(*hip) * amount);
-+	hip->hi_inode = NULL;
-+	au_hn_init(hip);
-+	iinfo->ii_bend++;
-+	if (unlikely(bend < 0))
-+		iinfo->ii_bstart = 0;
-+}
-+
-+static void au_br_do_add(struct super_block *sb, struct au_branch *br,
-+			 aufs_bindex_t bindex)
-+{
-+	struct dentry *root, *h_dentry;
-+	struct inode *root_inode;
-+	aufs_bindex_t bend, amount;
-+
-+	root = sb->s_root;
-+	root_inode = root->d_inode;
-+	bend = au_sbend(sb);
-+	amount = bend + 1 - bindex;
-+	h_dentry = au_br_dentry(br);
-+	au_sbilist_lock();
-+	au_br_do_add_brp(au_sbi(sb), bindex, br, bend, amount);
-+	au_br_do_add_hdp(au_di(root), bindex, bend, amount);
-+	au_br_do_add_hip(au_ii(root_inode), bindex, bend, amount);
-+	au_set_h_dptr(root, bindex, dget(h_dentry));
-+	au_set_h_iptr(root_inode, bindex, au_igrab(h_dentry->d_inode),
-+		      /*flags*/0);
-+	au_sbilist_unlock();
-+}
-+
-+int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount)
-+{
-+	int err;
-+	aufs_bindex_t bend, add_bindex;
-+	struct dentry *root, *h_dentry;
-+	struct inode *root_inode;
-+	struct au_branch *add_branch;
-+
-+	root = sb->s_root;
-+	root_inode = root->d_inode;
-+	IMustLock(root_inode);
-+	err = test_add(sb, add, remount);
-+	if (unlikely(err < 0))
-+		goto out;
-+	if (err) {
-+		err = 0;
-+		goto out; /* success */
-+	}
-+
-+	bend = au_sbend(sb);
-+	add_branch = au_br_alloc(sb, bend + 2, add->perm);
-+	err = PTR_ERR(add_branch);
-+	if (IS_ERR(add_branch))
-+		goto out;
-+
-+	err = au_br_init(add_branch, sb, add);
-+	if (unlikely(err)) {
-+		au_br_do_free(add_branch);
-+		goto out;
-+	}
-+
-+	add_bindex = add->bindex;
-+	if (!remount)
-+		au_br_do_add(sb, add_branch, add_bindex);
-+	else {
-+		sysaufs_brs_del(sb, add_bindex);
-+		au_br_do_add(sb, add_branch, add_bindex);
-+		sysaufs_brs_add(sb, add_bindex);
-+	}
-+
-+	h_dentry = add->path.dentry;
-+	if (!add_bindex) {
-+		au_cpup_attr_all(root_inode, /*force*/1);
-+		sb->s_maxbytes = h_dentry->d_sb->s_maxbytes;
-+	} else
-+		au_add_nlink(root_inode, h_dentry->d_inode);
-+
-+	/*
-+	 * this test/set prevents aufs from handling unnecesary notify events
-+	 * of xino files, in case of re-adding a writable branch which was
-+	 * once detached from aufs.
-+	 */
-+	if (au_xino_brid(sb) < 0
-+	    && au_br_writable(add_branch->br_perm)
-+	    && !au_test_fs_bad_xino(h_dentry->d_sb)
-+	    && add_branch->br_xino.xi_file
-+	    && add_branch->br_xino.xi_file->f_path.dentry->d_parent == h_dentry)
-+		au_xino_brid_set(sb, add_branch->br_id);
-+
-+out:
-+	return err;
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+static unsigned long long au_farray_cb(void *a,
-+				       unsigned long long max __maybe_unused,
-+				       void *arg)
-+{
-+	unsigned long long n;
-+	struct file **p, *f;
-+	struct au_sphlhead *files;
-+	struct au_finfo *finfo;
-+	struct super_block *sb = arg;
-+
-+	n = 0;
-+	p = a;
-+	files = &au_sbi(sb)->si_files;
-+	spin_lock(&files->spin);
-+	hlist_for_each_entry(finfo, &files->head, fi_hlist) {
-+		f = finfo->fi_file;
-+		if (file_count(f)
-+		    && !special_file(file_inode(f)->i_mode)) {
-+			get_file(f);
-+			*p++ = f;
-+			n++;
-+			AuDebugOn(n > max);
-+		}
-+	}
-+	spin_unlock(&files->spin);
-+
-+	return n;
-+}
-+
-+static struct file **au_farray_alloc(struct super_block *sb,
-+				     unsigned long long *max)
-+{
-+	*max = atomic_long_read(&au_sbi(sb)->si_nfiles);
-+	return au_array_alloc(max, au_farray_cb, sb);
-+}
-+
-+static void au_farray_free(struct file **a, unsigned long long max)
-+{
-+	unsigned long long ull;
-+
-+	for (ull = 0; ull < max; ull++)
-+		if (a[ull])
-+			fput(a[ull]);
-+	au_array_free(a);
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/*
-+ * delete a branch
-+ */
-+
-+/* to show the line number, do not make it inlined function */
-+#define AuVerbose(do_info, fmt, ...) do { \
-+	if (do_info) \
-+		pr_info(fmt, ##__VA_ARGS__); \
-+} while (0)
-+
-+static int au_test_ibusy(struct inode *inode, aufs_bindex_t bstart,
-+			 aufs_bindex_t bend)
-+{
-+	return (inode && !S_ISDIR(inode->i_mode)) || bstart == bend;
-+}
-+
-+static int au_test_dbusy(struct dentry *dentry, aufs_bindex_t bstart,
-+			 aufs_bindex_t bend)
-+{
-+	return au_test_ibusy(dentry->d_inode, bstart, bend);
-+}
-+
-+/*
-+ * test if the branch is deletable or not.
-+ */
-+static int test_dentry_busy(struct dentry *root, aufs_bindex_t bindex,
-+			    unsigned int sigen, const unsigned int verbose)
-+{
-+	int err, i, j, ndentry;
-+	aufs_bindex_t bstart, bend;
-+	struct au_dcsub_pages dpages;
-+	struct au_dpage *dpage;
-+	struct dentry *d;
-+
-+	err = au_dpages_init(&dpages, GFP_NOFS);
-+	if (unlikely(err))
-+		goto out;
-+	err = au_dcsub_pages(&dpages, root, NULL, NULL);
-+	if (unlikely(err))
-+		goto out_dpages;
-+
-+	for (i = 0; !err && i < dpages.ndpage; i++) {
-+		dpage = dpages.dpages + i;
-+		ndentry = dpage->ndentry;
-+		for (j = 0; !err && j < ndentry; j++) {
-+			d = dpage->dentries[j];
-+			AuDebugOn(au_dcount(d) <= 0);
-+			if (!au_digen_test(d, sigen)) {
-+				di_read_lock_child(d, AuLock_IR);
-+				if (unlikely(au_dbrange_test(d))) {
-+					di_read_unlock(d, AuLock_IR);
-+					continue;
-+				}
-+			} else {
-+				di_write_lock_child(d);
-+				if (unlikely(au_dbrange_test(d))) {
-+					di_write_unlock(d);
-+					continue;
-+				}
-+				err = au_reval_dpath(d, sigen);
-+				if (!err)
-+					di_downgrade_lock(d, AuLock_IR);
-+				else {
-+					di_write_unlock(d);
-+					break;
-+				}
-+			}
-+
-+			/* AuDbgDentry(d); */
-+			bstart = au_dbstart(d);
-+			bend = au_dbend(d);
-+			if (bstart <= bindex
-+			    && bindex <= bend
-+			    && au_h_dptr(d, bindex)
-+			    && au_test_dbusy(d, bstart, bend)) {
-+				err = -EBUSY;
-+				AuVerbose(verbose, "busy %pd\n", d);
-+				AuDbgDentry(d);
-+			}
-+			di_read_unlock(d, AuLock_IR);
-+		}
-+	}
-+
-+out_dpages:
-+	au_dpages_free(&dpages);
-+out:
-+	return err;
-+}
-+
-+static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex,
-+			   unsigned int sigen, const unsigned int verbose)
-+{
-+	int err;
-+	unsigned long long max, ull;
-+	struct inode *i, **array;
-+	aufs_bindex_t bstart, bend;
-+
-+	array = au_iarray_alloc(sb, &max);
-+	err = PTR_ERR(array);
-+	if (IS_ERR(array))
-+		goto out;
-+
-+	err = 0;
-+	AuDbg("b%d\n", bindex);
-+	for (ull = 0; !err && ull < max; ull++) {
-+		i = array[ull];
-+		if (unlikely(!i))
-+			break;
-+		if (i->i_ino == AUFS_ROOT_INO)
-+			continue;
-+
-+		/* AuDbgInode(i); */
-+		if (au_iigen(i, NULL) == sigen)
-+			ii_read_lock_child(i);
-+		else {
-+			ii_write_lock_child(i);
-+			err = au_refresh_hinode_self(i);
-+			au_iigen_dec(i);
-+			if (!err)
-+				ii_downgrade_lock(i);
-+			else {
-+				ii_write_unlock(i);
-+				break;
-+			}
-+		}
-+
-+		bstart = au_ibstart(i);
-+		bend = au_ibend(i);
-+		if (bstart <= bindex
-+		    && bindex <= bend
-+		    && au_h_iptr(i, bindex)
-+		    && au_test_ibusy(i, bstart, bend)) {
-+			err = -EBUSY;
-+			AuVerbose(verbose, "busy i%lu\n", i->i_ino);
-+			AuDbgInode(i);
-+		}
-+		ii_read_unlock(i);
-+	}
-+	au_iarray_free(array, max);
-+
-+out:
-+	return err;
-+}
-+
-+static int test_children_busy(struct dentry *root, aufs_bindex_t bindex,
-+			      const unsigned int verbose)
-+{
-+	int err;
-+	unsigned int sigen;
-+
-+	sigen = au_sigen(root->d_sb);
-+	DiMustNoWaiters(root);
-+	IiMustNoWaiters(root->d_inode);
-+	di_write_unlock(root);
-+	err = test_dentry_busy(root, bindex, sigen, verbose);
-+	if (!err)
-+		err = test_inode_busy(root->d_sb, bindex, sigen, verbose);
-+	di_write_lock_child(root); /* aufs_write_lock() calls ..._child() */
-+
-+	return err;
-+}
-+
-+static int test_dir_busy(struct file *file, aufs_bindex_t br_id,
-+			 struct file **to_free, int *idx)
-+{
-+	int err;
-+	unsigned char matched, root;
-+	aufs_bindex_t bindex, bend;
-+	struct au_fidir *fidir;
-+	struct au_hfile *hfile;
-+
-+	err = 0;
-+	root = IS_ROOT(file->f_path.dentry);
-+	if (root) {
-+		get_file(file);
-+		to_free[*idx] = file;
-+		(*idx)++;
-+		goto out;
-+	}
-+
-+	matched = 0;
-+	fidir = au_fi(file)->fi_hdir;
-+	AuDebugOn(!fidir);
-+	bend = au_fbend_dir(file);
-+	for (bindex = au_fbstart(file); bindex <= bend; bindex++) {
-+		hfile = fidir->fd_hfile + bindex;
-+		if (!hfile->hf_file)
-+			continue;
-+
-+		if (hfile->hf_br->br_id == br_id) {
-+			matched = 1;
-+			break;
-+		}
-+	}
-+	if (matched)
-+		err = -EBUSY;
-+
-+out:
-+	return err;
-+}
-+
-+static int test_file_busy(struct super_block *sb, aufs_bindex_t br_id,
-+			  struct file **to_free, int opened)
-+{
-+	int err, idx;
-+	unsigned long long ull, max;
-+	aufs_bindex_t bstart;
-+	struct file *file, **array;
-+	struct dentry *root;
-+	struct au_hfile *hfile;
-+
-+	array = au_farray_alloc(sb, &max);
-+	err = PTR_ERR(array);
-+	if (IS_ERR(array))
-+		goto out;
-+
-+	err = 0;
-+	idx = 0;
-+	root = sb->s_root;
-+	di_write_unlock(root);
-+	for (ull = 0; ull < max; ull++) {
-+		file = array[ull];
-+		if (unlikely(!file))
-+			break;
-+
-+		/* AuDbg("%pD\n", file); */
-+		fi_read_lock(file);
-+		bstart = au_fbstart(file);
-+		if (!d_is_dir(file->f_path.dentry)) {
-+			hfile = &au_fi(file)->fi_htop;
-+			if (hfile->hf_br->br_id == br_id)
-+				err = -EBUSY;
-+		} else
-+			err = test_dir_busy(file, br_id, to_free, &idx);
-+		fi_read_unlock(file);
-+		if (unlikely(err))
-+			break;
-+	}
-+	di_write_lock_child(root);
-+	au_farray_free(array, max);
-+	AuDebugOn(idx > opened);
-+
-+out:
-+	return err;
-+}
-+
-+static void br_del_file(struct file **to_free, unsigned long long opened,
-+			  aufs_bindex_t br_id)
-+{
-+	unsigned long long ull;
-+	aufs_bindex_t bindex, bstart, bend, bfound;
-+	struct file *file;
-+	struct au_fidir *fidir;
-+	struct au_hfile *hfile;
-+
-+	for (ull = 0; ull < opened; ull++) {
-+		file = to_free[ull];
-+		if (unlikely(!file))
-+			break;
-+
-+		/* AuDbg("%pD\n", file); */
-+		AuDebugOn(!d_is_dir(file->f_path.dentry));
-+		bfound = -1;
-+		fidir = au_fi(file)->fi_hdir;
-+		AuDebugOn(!fidir);
-+		fi_write_lock(file);
-+		bstart = au_fbstart(file);
-+		bend = au_fbend_dir(file);
-+		for (bindex = bstart; bindex <= bend; bindex++) {
-+			hfile = fidir->fd_hfile + bindex;
-+			if (!hfile->hf_file)
-+				continue;
-+
-+			if (hfile->hf_br->br_id == br_id) {
-+				bfound = bindex;
-+				break;
-+			}
-+		}
-+		AuDebugOn(bfound < 0);
-+		au_set_h_fptr(file, bfound, NULL);
-+		if (bfound == bstart) {
-+			for (bstart++; bstart <= bend; bstart++)
-+				if (au_hf_dir(file, bstart)) {
-+					au_set_fbstart(file, bstart);
-+					break;
-+				}
-+		}
-+		fi_write_unlock(file);
-+	}
-+}
-+
-+static void au_br_do_del_brp(struct au_sbinfo *sbinfo,
-+			     const aufs_bindex_t bindex,
-+			     const aufs_bindex_t bend)
-+{
-+	struct au_branch **brp, **p;
-+
-+	AuRwMustWriteLock(&sbinfo->si_rwsem);
-+
-+	brp = sbinfo->si_branch + bindex;
-+	if (bindex < bend)
-+		memmove(brp, brp + 1, sizeof(*brp) * (bend - bindex));
-+	sbinfo->si_branch[0 + bend] = NULL;
-+	sbinfo->si_bend--;
-+
-+	p = krealloc(sbinfo->si_branch, sizeof(*p) * bend, AuGFP_SBILIST);
-+	if (p)
-+		sbinfo->si_branch = p;
-+	/* harmless error */
-+}
-+
-+static void au_br_do_del_hdp(struct au_dinfo *dinfo, const aufs_bindex_t bindex,
-+			     const aufs_bindex_t bend)
-+{
-+	struct au_hdentry *hdp, *p;
-+
-+	AuRwMustWriteLock(&dinfo->di_rwsem);
-+
-+	hdp = dinfo->di_hdentry;
-+	if (bindex < bend)
-+		memmove(hdp + bindex, hdp + bindex + 1,
-+			sizeof(*hdp) * (bend - bindex));
-+	hdp[0 + bend].hd_dentry = NULL;
-+	dinfo->di_bend--;
-+
-+	p = krealloc(hdp, sizeof(*p) * bend, AuGFP_SBILIST);
-+	if (p)
-+		dinfo->di_hdentry = p;
-+	/* harmless error */
-+}
-+
-+static void au_br_do_del_hip(struct au_iinfo *iinfo, const aufs_bindex_t bindex,
-+			     const aufs_bindex_t bend)
-+{
-+	struct au_hinode *hip, *p;
-+
-+	AuRwMustWriteLock(&iinfo->ii_rwsem);
-+
-+	hip = iinfo->ii_hinode + bindex;
-+	if (bindex < bend)
-+		memmove(hip, hip + 1, sizeof(*hip) * (bend - bindex));
-+	iinfo->ii_hinode[0 + bend].hi_inode = NULL;
-+	au_hn_init(iinfo->ii_hinode + bend);
-+	iinfo->ii_bend--;
-+
-+	p = krealloc(iinfo->ii_hinode, sizeof(*p) * bend, AuGFP_SBILIST);
-+	if (p)
-+		iinfo->ii_hinode = p;
-+	/* harmless error */
-+}
-+
-+static void au_br_do_del(struct super_block *sb, aufs_bindex_t bindex,
-+			 struct au_branch *br)
-+{
-+	aufs_bindex_t bend;
-+	struct au_sbinfo *sbinfo;
-+	struct dentry *root, *h_root;
-+	struct inode *inode, *h_inode;
-+	struct au_hinode *hinode;
-+
-+	SiMustWriteLock(sb);
-+
-+	root = sb->s_root;
-+	inode = root->d_inode;
-+	sbinfo = au_sbi(sb);
-+	bend = sbinfo->si_bend;
-+
-+	h_root = au_h_dptr(root, bindex);
-+	hinode = au_hi(inode, bindex);
-+	h_inode = au_igrab(hinode->hi_inode);
-+	au_hiput(hinode);
-+
-+	au_sbilist_lock();
-+	au_br_do_del_brp(sbinfo, bindex, bend);
-+	au_br_do_del_hdp(au_di(root), bindex, bend);
-+	au_br_do_del_hip(au_ii(inode), bindex, bend);
-+	au_sbilist_unlock();
-+
-+	dput(h_root);
-+	iput(h_inode);
-+	au_br_do_free(br);
-+}
-+
-+static unsigned long long empty_cb(void *array, unsigned long long max,
-+				   void *arg)
-+{
-+	return max;
-+}
-+
-+int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount)
-+{
-+	int err, rerr, i;
-+	unsigned long long opened;
-+	unsigned int mnt_flags;
-+	aufs_bindex_t bindex, bend, br_id;
-+	unsigned char do_wh, verbose;
-+	struct au_branch *br;
-+	struct au_wbr *wbr;
-+	struct dentry *root;
-+	struct file **to_free;
-+
-+	err = 0;
-+	opened = 0;
-+	to_free = NULL;
-+	root = sb->s_root;
-+	bindex = au_find_dbindex(root, del->h_path.dentry);
-+	if (bindex < 0) {
-+		if (remount)
-+			goto out; /* success */
-+		err = -ENOENT;
-+		pr_err("%s no such branch\n", del->pathname);
-+		goto out;
-+	}
-+	AuDbg("bindex b%d\n", bindex);
-+
-+	err = -EBUSY;
-+	mnt_flags = au_mntflags(sb);
-+	verbose = !!au_opt_test(mnt_flags, VERBOSE);
-+	bend = au_sbend(sb);
-+	if (unlikely(!bend)) {
-+		AuVerbose(verbose, "no more branches left\n");
-+		goto out;
-+	}
-+	br = au_sbr(sb, bindex);
-+	AuDebugOn(!path_equal(&br->br_path, &del->h_path));
-+
-+	br_id = br->br_id;
-+	opened = atomic_read(&br->br_count);
-+	if (unlikely(opened)) {
-+		to_free = au_array_alloc(&opened, empty_cb, NULL);
-+		err = PTR_ERR(to_free);
-+		if (IS_ERR(to_free))
-+			goto out;
-+
-+		err = test_file_busy(sb, br_id, to_free, opened);
-+		if (unlikely(err)) {
-+			AuVerbose(verbose, "%llu file(s) opened\n", opened);
-+			goto out;
-+		}
-+	}
-+
-+	wbr = br->br_wbr;
-+	do_wh = wbr && (wbr->wbr_whbase || wbr->wbr_plink || wbr->wbr_orph);
-+	if (do_wh) {
-+		/* instead of WbrWhMustWriteLock(wbr) */
-+		SiMustWriteLock(sb);
-+		for (i = 0; i < AuBrWh_Last; i++) {
-+			dput(wbr->wbr_wh[i]);
-+			wbr->wbr_wh[i] = NULL;
-+		}
-+	}
-+
-+	err = test_children_busy(root, bindex, verbose);
-+	if (unlikely(err)) {
-+		if (do_wh)
-+			goto out_wh;
-+		goto out;
-+	}
-+
-+	err = 0;
-+	if (to_free) {
-+		/*
-+		 * now we confirmed the branch is deletable.
-+		 * let's free the remaining opened dirs on the branch.
-+		 */
-+		di_write_unlock(root);
-+		br_del_file(to_free, opened, br_id);
-+		di_write_lock_child(root);
-+	}
-+
-+	if (!remount)
-+		au_br_do_del(sb, bindex, br);
-+	else {
-+		sysaufs_brs_del(sb, bindex);
-+		au_br_do_del(sb, bindex, br);
-+		sysaufs_brs_add(sb, bindex);
-+	}
-+
-+	if (!bindex) {
-+		au_cpup_attr_all(root->d_inode, /*force*/1);
-+		sb->s_maxbytes = au_sbr_sb(sb, 0)->s_maxbytes;
-+	} else
-+		au_sub_nlink(root->d_inode, del->h_path.dentry->d_inode);
-+	if (au_opt_test(mnt_flags, PLINK))
-+		au_plink_half_refresh(sb, br_id);
-+
-+	if (au_xino_brid(sb) == br_id)
-+		au_xino_brid_set(sb, -1);
-+	goto out; /* success */
-+
-+out_wh:
-+	/* revert */
-+	rerr = au_br_init_wh(sb, br, br->br_perm);
-+	if (rerr)
-+		pr_warn("failed re-creating base whiteout, %s. (%d)\n",
-+			del->pathname, rerr);
-+out:
-+	if (to_free)
-+		au_farray_free(to_free, opened);
-+	return err;
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+static int au_ibusy(struct super_block *sb, struct aufs_ibusy __user *arg)
-+{
-+	int err;
-+	aufs_bindex_t bstart, bend;
-+	struct aufs_ibusy ibusy;
-+	struct inode *inode, *h_inode;
-+
-+	err = -EPERM;
-+	if (unlikely(!capable(CAP_SYS_ADMIN)))
-+		goto out;
-+
-+	err = copy_from_user(&ibusy, arg, sizeof(ibusy));
-+	if (!err)
-+		err = !access_ok(VERIFY_WRITE, &arg->h_ino, sizeof(arg->h_ino));
-+	if (unlikely(err)) {
-+		err = -EFAULT;
-+		AuTraceErr(err);
-+		goto out;
-+	}
-+
-+	err = -EINVAL;
-+	si_read_lock(sb, AuLock_FLUSH);
-+	if (unlikely(ibusy.bindex < 0 || ibusy.bindex > au_sbend(sb)))
-+		goto out_unlock;
-+
-+	err = 0;
-+	ibusy.h_ino = 0; /* invalid */
-+	inode = ilookup(sb, ibusy.ino);
-+	if (!inode
-+	    || inode->i_ino == AUFS_ROOT_INO
-+	    || is_bad_inode(inode))
-+		goto out_unlock;
-+
-+	ii_read_lock_child(inode);
-+	bstart = au_ibstart(inode);
-+	bend = au_ibend(inode);
-+	if (bstart <= ibusy.bindex && ibusy.bindex <= bend) {
-+		h_inode = au_h_iptr(inode, ibusy.bindex);
-+		if (h_inode && au_test_ibusy(inode, bstart, bend))
-+			ibusy.h_ino = h_inode->i_ino;
-+	}
-+	ii_read_unlock(inode);
-+	iput(inode);
-+
-+out_unlock:
-+	si_read_unlock(sb);
-+	if (!err) {
-+		err = __put_user(ibusy.h_ino, &arg->h_ino);
-+		if (unlikely(err)) {
-+			err = -EFAULT;
-+			AuTraceErr(err);
-+		}
-+	}
-+out:
-+	return err;
-+}
-+
-+long au_ibusy_ioctl(struct file *file, unsigned long arg)
-+{
-+	return au_ibusy(file->f_path.dentry->d_sb, (void __user *)arg);
-+}
-+
-+#ifdef CONFIG_COMPAT
-+long au_ibusy_compat_ioctl(struct file *file, unsigned long arg)
-+{
-+	return au_ibusy(file->f_path.dentry->d_sb, compat_ptr(arg));
-+}
-+#endif
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/*
-+ * change a branch permission
-+ */
-+
-+static void au_warn_ima(void)
-+{
-+#ifdef CONFIG_IMA
-+	/* since it doesn't support mark_files_ro() */
-+	AuWarn1("RW -> RO makes IMA to produce wrong message\n");
-+#endif
-+}
-+
-+static int do_need_sigen_inc(int a, int b)
-+{
-+	return au_br_whable(a) && !au_br_whable(b);
-+}
-+
-+static int need_sigen_inc(int old, int new)
-+{
-+	return do_need_sigen_inc(old, new)
-+		|| do_need_sigen_inc(new, old);
-+}
-+
-+static int au_br_mod_files_ro(struct super_block *sb, aufs_bindex_t bindex)
-+{
-+	int err, do_warn;
-+	unsigned int mnt_flags;
-+	unsigned long long ull, max;
-+	aufs_bindex_t br_id;
-+	unsigned char verbose, writer;
-+	struct file *file, *hf, **array;
-+	struct au_hfile *hfile;
-+
-+	mnt_flags = au_mntflags(sb);
-+	verbose = !!au_opt_test(mnt_flags, VERBOSE);
-+
-+	array = au_farray_alloc(sb, &max);
-+	err = PTR_ERR(array);
-+	if (IS_ERR(array))
-+		goto out;
-+
-+	do_warn = 0;
-+	br_id = au_sbr_id(sb, bindex);
-+	for (ull = 0; ull < max; ull++) {
-+		file = array[ull];
-+		if (unlikely(!file))
-+			break;
-+
-+		/* AuDbg("%pD\n", file); */
-+		fi_read_lock(file);
-+		if (unlikely(au_test_mmapped(file))) {
-+			err = -EBUSY;
-+			AuVerbose(verbose, "mmapped %pD\n", file);
-+			AuDbgFile(file);
-+			FiMustNoWaiters(file);
-+			fi_read_unlock(file);
-+			goto out_array;
-+		}
-+
-+		hfile = &au_fi(file)->fi_htop;
-+		hf = hfile->hf_file;
-+		if (!d_is_reg(file->f_path.dentry)
-+		    || !(file->f_mode & FMODE_WRITE)
-+		    || hfile->hf_br->br_id != br_id
-+		    || !(hf->f_mode & FMODE_WRITE))
-+			array[ull] = NULL;
-+		else {
-+			do_warn = 1;
-+			get_file(file);
-+		}
-+
-+		FiMustNoWaiters(file);
-+		fi_read_unlock(file);
-+		fput(file);
-+	}
-+
-+	err = 0;
-+	if (do_warn)
-+		au_warn_ima();
-+
-+	for (ull = 0; ull < max; ull++) {
-+		file = array[ull];
-+		if (!file)
-+			continue;
-+
-+		/* todo: already flushed? */
-+		/*
-+		 * fs/super.c:mark_files_ro() is gone, but aufs keeps its
-+		 * approach which resets f_mode and calls mnt_drop_write() and
-+		 * file_release_write() for each file, because the branch
-+		 * attribute in aufs world is totally different from the native
-+		 * fs rw/ro mode.
-+		*/
-+		/* fi_read_lock(file); */
-+		hfile = &au_fi(file)->fi_htop;
-+		hf = hfile->hf_file;
-+		/* fi_read_unlock(file); */
-+		spin_lock(&hf->f_lock);
-+		writer = !!(hf->f_mode & FMODE_WRITER);
-+		hf->f_mode &= ~(FMODE_WRITE | FMODE_WRITER);
-+		spin_unlock(&hf->f_lock);
-+		if (writer) {
-+			put_write_access(file_inode(hf));
-+			__mnt_drop_write(hf->f_path.mnt);
-+		}
-+	}
-+
-+out_array:
-+	au_farray_free(array, max);
-+out:
-+	AuTraceErr(err);
-+	return err;
-+}
-+
-+int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount,
-+	      int *do_refresh)
-+{
-+	int err, rerr;
-+	aufs_bindex_t bindex;
-+	struct dentry *root;
-+	struct au_branch *br;
-+	struct au_br_fhsm *bf;
-+
-+	root = sb->s_root;
-+	bindex = au_find_dbindex(root, mod->h_root);
-+	if (bindex < 0) {
-+		if (remount)
-+			return 0; /* success */
-+		err = -ENOENT;
-+		pr_err("%s no such branch\n", mod->path);
-+		goto out;
-+	}
-+	AuDbg("bindex b%d\n", bindex);
-+
-+	err = test_br(mod->h_root->d_inode, mod->perm, mod->path);
-+	if (unlikely(err))
-+		goto out;
-+
-+	br = au_sbr(sb, bindex);
-+	AuDebugOn(mod->h_root != au_br_dentry(br));
-+	if (br->br_perm == mod->perm)
-+		return 0; /* success */
-+
-+	/* pre-allocate for non-fhsm --> fhsm */
-+	bf = NULL;
-+	if (!au_br_fhsm(br->br_perm) && au_br_fhsm(mod->perm)) {
-+		err = au_fhsm_br_alloc(br);
-+		if (unlikely(err))
-+			goto out;
-+		bf = br->br_fhsm;
-+		br->br_fhsm = NULL;
-+	}
-+
-+	if (au_br_writable(br->br_perm)) {
-+		/* remove whiteout base */
-+		err = au_br_init_wh(sb, br, mod->perm);
-+		if (unlikely(err))
-+			goto out_bf;
-+
-+		if (!au_br_writable(mod->perm)) {
-+			/* rw --> ro, file might be mmapped */
-+			DiMustNoWaiters(root);
-+			IiMustNoWaiters(root->d_inode);
-+			di_write_unlock(root);
-+			err = au_br_mod_files_ro(sb, bindex);
-+			/* aufs_write_lock() calls ..._child() */
-+			di_write_lock_child(root);
-+
-+			if (unlikely(err)) {
-+				rerr = -ENOMEM;
-+				br->br_wbr = kmalloc(sizeof(*br->br_wbr),
-+						     GFP_NOFS);
-+				if (br->br_wbr)
-+					rerr = au_wbr_init(br, sb, br->br_perm);
-+				if (unlikely(rerr)) {
-+					AuIOErr("nested error %d (%d)\n",
-+						rerr, err);
-+					br->br_perm = mod->perm;
-+				}
-+			}
-+		}
-+	} else if (au_br_writable(mod->perm)) {
-+		/* ro --> rw */
-+		err = -ENOMEM;
-+		br->br_wbr = kmalloc(sizeof(*br->br_wbr), GFP_NOFS);
-+		if (br->br_wbr) {
-+			err = au_wbr_init(br, sb, mod->perm);
-+			if (unlikely(err)) {
-+				kfree(br->br_wbr);
-+				br->br_wbr = NULL;
-+			}
-+		}
-+	}
-+	if (unlikely(err))
-+		goto out_bf;
-+
-+	if (au_br_fhsm(br->br_perm)) {
-+		if (!au_br_fhsm(mod->perm)) {
-+			/* fhsm --> non-fhsm */
-+			au_br_fhsm_fin(br->br_fhsm);
-+			kfree(br->br_fhsm);
-+			br->br_fhsm = NULL;
-+		}
-+	} else if (au_br_fhsm(mod->perm))
-+		/* non-fhsm --> fhsm */
-+		br->br_fhsm = bf;
-+
-+	*do_refresh |= need_sigen_inc(br->br_perm, mod->perm);
-+	br->br_perm = mod->perm;
-+	goto out; /* success */
-+
-+out_bf:
-+	kfree(bf);
-+out:
-+	AuTraceErr(err);
-+	return err;
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+int au_br_stfs(struct au_branch *br, struct aufs_stfs *stfs)
-+{
-+	int err;
-+	struct kstatfs kstfs;
-+
-+	err = vfs_statfs(&br->br_path, &kstfs);
-+	if (!err) {
-+		stfs->f_blocks = kstfs.f_blocks;
-+		stfs->f_bavail = kstfs.f_bavail;
-+		stfs->f_files = kstfs.f_files;
-+		stfs->f_ffree = kstfs.f_ffree;
-+	}
-+
-+	return err;
-+}
-diff -Nur linux-4.0.5.orig/fs/aufs/branch.h linux-4.0.5/fs/aufs/branch.h
---- linux-4.0.5.orig/fs/aufs/branch.h	1969-12-31 18:00:00.000000000 -0600
-+++ linux-4.0.5/fs/aufs/branch.h	2015-06-21 14:07:48.682432781 -0500
-@@ -0,0 +1,279 @@
-+/*
-+ * Copyright (C) 2005-2015 Junjiro R. 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, see <http://www.gnu.org/licenses/>.
-+ */
-+
-+/*
-+ * branch filesystems and xino for them
-+ */
-+
-+#ifndef __AUFS_BRANCH_H__
-+#define __AUFS_BRANCH_H__
-+
-+#ifdef __KERNEL__
-+
-+#include <linux/mount.h>
-+#include "dynop.h"
-+#include "rwsem.h"
-+#include "super.h"
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/* a xino file */
-+struct au_xino_file {
-+	struct file		*xi_file;
-+	struct mutex		xi_nondir_mtx;
-+
-+	/* todo: make xino files an array to support huge inode number */
-+
-+#ifdef CONFIG_DEBUG_FS
-+	struct dentry		 *xi_dbgaufs;
-+#endif
-+};
-+
-+/* File-based Hierarchical Storage Management */
-+struct au_br_fhsm {
-+#ifdef CONFIG_AUFS_FHSM
-+	struct mutex		bf_lock;
-+	unsigned long		bf_jiffy;
-+	struct aufs_stfs	bf_stfs;
-+	int			bf_readable;
-+#endif
-+};
-+
-+/* members for writable branch only */
-+enum {AuBrWh_BASE, AuBrWh_PLINK, AuBrWh_ORPH, AuBrWh_Last};
-+struct au_wbr {
-+	struct au_rwsem		wbr_wh_rwsem;
-+	struct dentry		*wbr_wh[AuBrWh_Last];
-+	atomic_t		wbr_wh_running;
-+#define wbr_whbase		wbr_wh[AuBrWh_BASE]	/* whiteout base */
-+#define wbr_plink		wbr_wh[AuBrWh_PLINK]	/* pseudo-link dir */
-+#define wbr_orph		wbr_wh[AuBrWh_ORPH]	/* dir for orphans */
-+
-+	/* mfs mode */
-+	unsigned long long	wbr_bytes;
-+};
-+
-+/* ext2 has 3 types of operations at least, ext3 has 4 */
-+#define AuBrDynOp (AuDyLast * 4)
-+
-+#ifdef CONFIG_AUFS_HFSNOTIFY
-+/* support for asynchronous destruction */
-+struct au_br_hfsnotify {
-+	struct fsnotify_group	*hfsn_group;
-+};
-+#endif
-+
-+/* sysfs entries */
-+struct au_brsysfs {
-+	char			name[16];
-+	struct attribute	attr;
-+};
-+
-+enum {
-+	AuBrSysfs_BR,
-+	AuBrSysfs_BRID,
-+	AuBrSysfs_Last
-+};
-+
-+/* protected by superblock rwsem */
-+struct au_branch {
-+	struct au_xino_file	br_xino;
-+
-+	aufs_bindex_t		br_id;
-+
-+	int			br_perm;
-+	struct path		br_path;
-+	spinlock_t		br_dykey_lock;
-+	struct au_dykey		*br_dykey[AuBrDynOp];
-+	atomic_t		br_count;
-+
-+	struct au_wbr		*br_wbr;
-+	struct au_br_fhsm	*br_fhsm;
-+
-+	/* xino truncation */
-+	atomic_t		br_xino_running;
-+
-+#ifdef CONFIG_AUFS_HFSNOTIFY
-+	struct au_br_hfsnotify	*br_hfsn;
-+#endif
-+
-+#ifdef CONFIG_SYSFS
-+	/* entries under sysfs per mount-point */
-+	struct au_brsysfs	br_sysfs[AuBrSysfs_Last];
-+#endif
-+};
-+
-+/* ---------------------------------------------------------------------- */
-+
-+static inline struct vfsmount *au_br_mnt(struct au_branch *br)
-+{
-+	return br->br_path.mnt;
-+}
-+
-+static inline struct dentry *au_br_dentry(struct au_branch *br)
-+{
-+	return br->br_path.dentry;
-+}
-+
-+static inline struct super_block *au_br_sb(struct au_branch *br)
-+{
-+	return au_br_mnt(br)->mnt_sb;
-+}
-+
-+static inline int au_br_rdonly(struct au_branch *br)
-+{
-+	return ((au_br_sb(br)->s_flags & MS_RDONLY)
-+		|| !au_br_writable(br->br_perm))
-+		? -EROFS : 0;
-+}
-+
-+static inline int au_br_hnotifyable(int brperm __maybe_unused)
-+{
-+#ifdef CONFIG_AUFS_HNOTIFY
-+	return !(brperm & AuBrPerm_RR);
-+#else
-+	return 0;
-+#endif
-+}
-+
-+static inline int au_br_test_oflag(int oflag, struct au_branch *br)
-+{
-+	int err, exec_flag;
-+
-+	err = 0;
-+	exec_flag = oflag & __FMODE_EXEC;
-+	if (unlikely(exec_flag && (au_br_mnt(br)->mnt_flags & MNT_NOEXEC)))
-+		err = -EACCES;
-+
-+	return err;
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/* branch.c */
-+struct au_sbinfo;
-+void au_br_free(struct au_sbinfo *sinfo);
-+int au_br_index(struct super_block *sb, aufs_bindex_t br_id);
-+struct au_opt_add;
-+int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount);
-+struct au_opt_del;
-+int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount);
-+long au_ibusy_ioctl(struct file *file, unsigned long arg);
-+#ifdef CONFIG_COMPAT
-+long au_ibusy_compat_ioctl(struct file *file, unsigned long arg);
-+#endif
-+struct au_opt_mod;
-+int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount,
-+	      int *do_refresh);
-+struct aufs_stfs;
-+int au_br_stfs(struct au_branch *br, struct aufs_stfs *stfs);
-+
-+/* xino.c */
-+static const loff_t au_loff_max = LLONG_MAX;
-+
-+int au_xib_trunc(struct super_block *sb);
-+ssize_t xino_fread(au_readf_t func, struct file *file, void *buf, size_t size,
-+		   loff_t *pos);
-+ssize_t xino_fwrite(au_writef_t func, struct file *file, void *buf, size_t size,
-+		    loff_t *pos);
-+struct file *au_xino_create2(struct file *base_file, struct file *copy_src);
-+struct file *au_xino_create(struct super_block *sb, char *fname, int silent);
-+ino_t au_xino_new_ino(struct super_block *sb);
-+void au_xino_delete_inode(struct inode *inode, const int unlinked);
-+int au_xino_write(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino,
-+		  ino_t ino);
-+int au_xino_read(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino,
-+		 ino_t *ino);
-+int au_xino_br(struct super_block *sb, struct au_branch *br, ino_t hino,
-+	       struct file *base_file, int do_test);
-+int au_xino_trunc(struct super_block *sb, aufs_bindex_t bindex);
-+
-+struct au_opt_xino;
-+int au_xino_set(struct super_block *sb, struct au_opt_xino *xino, int remount);
-+void au_xino_clr(struct super_block *sb);
-+struct file *au_xino_def(struct super_block *sb);
-+int au_xino_path(struct seq_file *seq, struct file *file);
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/* Superblock to branch */
-+static inline
-+aufs_bindex_t au_sbr_id(struct super_block *sb, aufs_bindex_t bindex)
-+{
-+	return au_sbr(sb, bindex)->br_id;
-+}
-+
-+static inline
-+struct vfsmount *au_sbr_mnt(struct super_block *sb, aufs_bindex_t bindex)
-+{
-+	return au_br_mnt(au_sbr(sb, bindex));
-+}
-+
-+static inline
-+struct super_block *au_sbr_sb(struct super_block *sb, aufs_bindex_t bindex)
-+{
-+	return au_br_sb(au_sbr(sb, bindex));
-+}
-+
-+static inline void au_sbr_put(struct super_block *sb, aufs_bindex_t bindex)
-+{
-+	atomic_dec(&au_sbr(sb, bindex)->br_count);
-+}
-+
-+static inline int au_sbr_perm(struct super_block *sb, aufs_bindex_t bindex)
-+{
-+	return au_sbr(sb, bindex)->br_perm;
-+}
-+
-+static inline int au_sbr_whable(struct super_block *sb, aufs_bindex_t bindex)
-+{
-+	return au_br_whable(au_sbr_perm(sb, bindex));
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/*
-+ * wbr_wh_read_lock, wbr_wh_write_lock
-+ * wbr_wh_read_unlock, wbr_wh_write_unlock, wbr_wh_downgrade_lock
-+ */
-+AuSimpleRwsemFuncs(wbr_wh, struct au_wbr *wbr, &wbr->wbr_wh_rwsem);
-+
-+#define WbrWhMustNoWaiters(wbr)	AuRwMustNoWaiters(&wbr->wbr_wh_rwsem)
-+#define WbrWhMustAnyLock(wbr)	AuRwMustAnyLock(&wbr->wbr_wh_rwsem)
-+#define WbrWhMustWriteLock(wbr)	AuRwMustWriteLock(&wbr->wbr_wh_rwsem)
-+
-+/* ---------------------------------------------------------------------- */
-+
-+#ifdef CONFIG_AUFS_FHSM
-+static inline void au_br_fhsm_init(struct au_br_fhsm *brfhsm)
-+{
-+	mutex_init(&brfhsm->bf_lock);
-+	brfhsm->bf_jiffy = 0;
-+	brfhsm->bf_readable = 0;
-+}
-+
-+static inline void au_br_fhsm_fin(struct au_br_fhsm *brfhsm)
-+{
-+	mutex_destroy(&brfhsm->bf_lock);
-+}
-+#else
-+AuStubVoid(au_br_fhsm_init, struct au_br_fhsm *brfhsm)
-+AuStubVoid(au_br_fhsm_fin, struct au_br_fhsm *brfhsm)
-+#endif
-+
-+#endif /* __KERNEL__ */
-+#endif /* __AUFS_BRANCH_H__ */
-diff -Nur linux-4.0.5.orig/fs/aufs/conf.mk linux-4.0.5/fs/aufs/conf.mk
---- linux-4.0.5.orig/fs/aufs/conf.mk	1969-12-31 18:00:00.000000000 -0600
-+++ linux-4.0.5/fs/aufs/conf.mk	2015-06-21 14:07:48.682432781 -0500
-@@ -0,0 +1,38 @@
-+
-+AuConfStr = CONFIG_AUFS_FS=${CONFIG_AUFS_FS}
-+
-+define AuConf
-+ifdef ${1}
-+AuConfStr += ${1}=${${1}}
-+endif
-+endef
-+
-+AuConfAll = BRANCH_MAX_127 BRANCH_MAX_511 BRANCH_MAX_1023 BRANCH_MAX_32767 \
-+	SBILIST \
-+	HNOTIFY HFSNOTIFY \
-+	EXPORT INO_T_64 \
-+	XATTR \
-+	FHSM \
-+	RDU \
-+	SHWH \
-+	BR_RAMFS \
-+	BR_FUSE POLL \
-+	BR_HFSPLUS \
-+	BDEV_LOOP \
-+	DEBUG MAGIC_SYSRQ
-+$(foreach i, ${AuConfAll}, \
-+	$(eval $(call AuConf,CONFIG_AUFS_${i})))
-+
-+AuConfName = ${obj}/conf.str
-+${AuConfName}.tmp: FORCE
-+	@echo ${AuConfStr} | tr ' ' '\n' | sed -e 's/^/"/' -e 's/$$/\\n"/' > $@
-+${AuConfName}: ${AuConfName}.tmp
-+	@diff -q $< $@ > /dev/null 2>&1 || { \
-+	echo '  GEN    ' $@; \
-+	cp -p $< $@; \
-+	}
-+FORCE:
-+clean-files += ${AuConfName} ${AuConfName}.tmp
-+${obj}/sysfs.o: ${AuConfName}
-+
-+-include ${srctree}/${src}/conf_priv.mk
-diff -Nur linux-4.0.5.orig/fs/aufs/cpup.c linux-4.0.5/fs/aufs/cpup.c
---- linux-4.0.5.orig/fs/aufs/cpup.c	1969-12-31 18:00:00.000000000 -0600
-+++ linux-4.0.5/fs/aufs/cpup.c	2015-06-21 14:07:48.682432781 -0500
-@@ -0,0 +1,1308 @@
-+/*
-+ * Copyright (C) 2005-2015 Junjiro R. 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, see <http://www.gnu.org/licenses/>.
-+ */
-+
-+/*
-+ * copy-up functions, see wbr_policy.c for copy-down
-+ */
-+
-+#include <linux/fs_stack.h>
-+#include <linux/mm.h>
-+#include "aufs.h"
-+
-+void au_cpup_attr_flags(struct inode *dst, unsigned int iflags)
-+{
-+	const unsigned int mask = S_DEAD | S_SWAPFILE | S_PRIVATE
-+		| S_NOATIME | S_NOCMTIME | S_AUTOMOUNT;
-+
-+	BUILD_BUG_ON(sizeof(iflags) != sizeof(dst->i_flags));
-+
-+	dst->i_flags |= iflags & ~mask;
-+	if (au_test_fs_notime(dst->i_sb))
-+		dst->i_flags |= S_NOATIME | S_NOCMTIME;
-+}
-+
-+void au_cpup_attr_timesizes(struct inode *inode)
-+{
-+	struct inode *h_inode;
-+
-+	h_inode = au_h_iptr(inode, au_ibstart(inode));
-+	fsstack_copy_attr_times(inode, h_inode);
-+	fsstack_copy_inode_size(inode, h_inode);
-+}
-+
-+void au_cpup_attr_nlink(struct inode *inode, int force)
-+{
-+	struct inode *h_inode;
-+	struct super_block *sb;
-+	aufs_bindex_t bindex, bend;
-+
-+	sb = inode->i_sb;
-+	bindex = au_ibstart(inode);
-+	h_inode = au_h_iptr(inode, bindex);
-+	if (!force
-+	    && !S_ISDIR(h_inode->i_mode)
-+	    && au_opt_test(au_mntflags(sb), PLINK)
-+	    && au_plink_test(inode))
-+		return;
-+
-+	/*
-+	 * 0 can happen in revalidating.
-+	 * h_inode->i_mutex may not be held here, but it is harmless since once
-+	 * i_nlink reaches 0, it will never become positive except O_TMPFILE
-+	 * case.
-+	 * todo: O_TMPFILE+linkat(AT_SYMLINK_FOLLOW) bypassing aufs may cause
-+	 *	 the incorrect link count.
-+	 */
-+	set_nlink(inode, h_inode->i_nlink);
-+
-+	/*
-+	 * fewer nlink makes find(1) noisy, but larger nlink doesn't.
-+	 * it may includes whplink directory.
-+	 */
-+	if (S_ISDIR(h_inode->i_mode)) {
-+		bend = au_ibend(inode);
-+		for (bindex++; 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;
-+
-+	h_inode = au_h_iptr(inode, au_ibstart(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);
-+	au_cpup_attr_flags(inode, h_inode->i_flags);
-+}
-+
-+void au_cpup_igen(struct inode *inode, struct inode *h_inode)
-+{
-+	struct au_iinfo *iinfo = au_ii(inode);
-+
-+	IiMustWriteLock(inode);
-+
-+	iinfo->ii_higen = h_inode->i_generation;
-+	iinfo->ii_hsb1 = h_inode->i_sb;
-+}
-+
-+void au_cpup_attr_all(struct inode *inode, int force)
-+{
-+	struct inode *h_inode;
-+
-+	h_inode = au_h_iptr(inode, au_ibstart(inode));
-+	au_cpup_attr_changeable(inode);
-+	if (inode->i_nlink > 0)
-+		au_cpup_attr_nlink(inode, force);
-+	inode->i_rdev = h_inode->i_rdev;
-+	inode->i_blkbits = h_inode->i_blkbits;
-+	au_cpup_igen(inode, h_inode);
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/* Note: dt_dentry and dt_h_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 path *h_path)
-+{
-+	struct inode *h_inode;
-+
-+	dt->dt_dentry = dentry;
-+	dt->dt_h_path = *h_path;
-+	h_inode = h_path->dentry->d_inode;
-+	dt->dt_atime = h_inode->i_atime;
-+	dt->dt_mtime = h_inode->i_mtime;
-+	/* smp_mb(); */
-+}
-+
-+void au_dtime_revert(struct au_dtime *dt)
-+{
-+	struct iattr attr;
-+	int err;
-+
-+	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;
-+
-+	/* no delegation since this is a directory */
-+	err = vfsub_notify_change(&dt->dt_h_path, &attr, /*delegated*/NULL);
-+	if (unlikely(err))
-+		pr_warn("restoring timestamps failed(%d). ignored\n", err);
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+/* internal use only */
-+struct au_cpup_reg_attr {
-+	int		valid;
-+	struct kstat	st;
-+	unsigned int	iflags; /* inode->i_flags */
-+};
-+
-+static noinline_for_stack
-+int cpup_iattr(struct dentry *dst, aufs_bindex_t bindex, struct dentry *h_src,
-+	       struct au_cpup_reg_attr *h_src_attr)
-+{
-+	int err, sbits, icex;
-+	unsigned int mnt_flags;
-+	unsigned char verbose;
-+	struct iattr ia;
-+	struct path h_path;
-+	struct inode *h_isrc, *h_idst;
-+	struct kstat *h_st;
-+	struct au_branch *br;
-+
-+	h_path.dentry = au_h_dptr(dst, bindex);
-+	h_idst = h_path.dentry->d_inode;
-+	br = au_sbr(dst->d_sb, bindex);
-+	h_path.mnt = au_br_mnt(br);
-+	h_isrc = h_src->d_inode;
-+	ia.ia_valid = ATTR_FORCE | ATTR_UID | ATTR_GID
-+		| ATTR_ATIME | ATTR_MTIME
-+		| ATTR_ATIME_SET | ATTR_MTIME_SET;
-+	if (h_src_attr && h_src_attr->valid) {
-+		h_st = &h_src_attr->st;
-+		ia.ia_uid = h_st->uid;
-+		ia.ia_gid = h_st->gid;
-+		ia.ia_atime = h_st->atime;
-+		ia.ia_mtime = h_st->mtime;
-+		if (h_idst->i_mode != h_st->mode
-+		    && !S_ISLNK(h_idst->i_mode)) {
-+			ia.ia_valid |= ATTR_MODE;
-+			ia.ia_mode = h_st->mode;
-+		}
-+		sbits = !!(h_st->mode & (S_ISUID | S_ISGID));
-+		au_cpup_attr_flags(h_idst, h_src_attr->iflags);
-+	} else {
-+		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;
-+		if (h_idst->i_mode != h_isrc->i_mode
-+		    && !S_ISLNK(h_idst->i_mode)) {
-+			ia.ia_valid |= ATTR_MODE;
-+			ia.ia_mode = h_isrc->i_mode;
-+		}
-+		sbits = !!(h_isrc->i_mode & (S_ISUID | S_ISGID));
-+		au_cpup_attr_flags(h_idst, h_isrc->i_flags);
-+	}
-+	/* no delegation since it is just created */
-+	err = vfsub_notify_change(&h_path, &ia, /*delegated*/NULL);
-+
-+	/* is this nfs only? */
-+	if (!err && sbits && au_test_nfs(h_path.dentry->d_sb)) {
-+		ia.ia_valid = ATTR_FORCE | ATTR_MODE;
-+		ia.ia_mode = h_isrc->i_mode;
-+		err = vfsub_notify_change(&h_path, &ia, /*delegated*/NULL);
-+	}
-+
-+	icex = br->br_perm & AuBrAttr_ICEX;
-+	if (!err) {
-+		mnt_flags = au_mntflags(dst->d_sb);
-+		verbose = !!au_opt_test(mnt_flags, VERBOSE);
-+		err = au_cpup_xattr(h_path.dentry, h_src, icex, verbose);
-+	}
-+
-+	return err;
-+}
-+
-+/* ---------------------------------------------------------------------- */
-+
-+static int au_do_copy_file(struct file *dst, struct file *src, loff_t len,
-+			   char *buf, unsigned long blksize)
-+{
-+	int err;
-+	size_t sz, rbytes, wbytes;
-+	unsigned char all_zero;
-+	char *p, *zp;
-+	struct mutex *h_mtx;
-+	/* reduce stack usage */
-+	struct iattr *ia;
-+
-+	zp = page_address(ZERO_PAGE(0));
-+	if (unlikely(!zp))
-+		return -ENOMEM; /* possible? */
-+
-+	err = 0;
-+	all_zero = 0;
-+	while (len) {
-+		AuDbg("len %lld\n", len);
-+		sz = blksize;
-+		if (len < blksize)
-+			sz = len;
-+
-+		rbytes = 0;
-+		/* todo: signal_pending? */
-+		while (!rbytes || err == -EAGAIN || err == -EINTR) {
-+			rbytes = vfsub_read_k(src, buf, sz, &src->f_pos);
-+			err = rbytes;
-+		}
-+		if (unlikely(err < 0))
-+			break;
-+
-+		all_zero = 0;
-+		if (len >= rbytes && rbytes == blksize)
-+			all_zero = !memcmp(buf, zp, rbytes);
-+		if (!all_zero) {
-+			wbytes = rbytes;
-+			p = buf;
-+			while (wbytes) {
-+				size_t b;
-+
-+				b = vfsub_write_k(dst, p, wbytes, &dst->f_pos);
-+				err = b;
-+				/* todo: signal_pending? */
-+				if (unlikely(err == -EAGAIN || err == -EINTR))
-+					continue;
-+				if (unlikely(err < 0))
-+					break;
-+				wbytes -= b;
-+				p += b;
-+			}
-+			if (unlikely(err < 0))
-+				break;
-+		} else {
-+			loff_t res;
-+
-+			AuLabel(hole);
-+			res = vfsub_llseek(dst, rbytes, SEEK_CUR);
-+			err = res;
-+			if (unlikely(res < 0))
-+				break;
-+		}
-+		len -= rbytes;
-+		err = 0;
-+	}
-+
-+	/* the last block may be a hole */
-+	if (!err && all_zero) {
-+		AuLabel(last hole);
-+
-+		err = 1;
-+		if (au_test_nfs(dst->f_path.dentry->d_sb)) {
-+			/* nfs requires this step to make last hole */
-+			/* is this only nfs? */
-+			do {
-+				/* todo: signal_pending? */
-+				err = vfsub_write_k(dst, "\0", 1, &dst->f_pos);
-+			} while (err == -EAGAIN || err == -EINTR);
-+			if (err == 1)
-+				dst->f_pos--;
-+		}
-+
-+		if (err == 1) {
-+			ia = (void *)buf;
-+			ia->ia_size = dst->f_pos;
-+			ia->ia_valid = ATTR_SIZE | ATTR_FILE;
-+			ia->ia_file = dst;
-+			h_mtx = &file_inode(dst)->i_mutex;
-+			mutex_lock_nested(h_mtx, AuLsc_I_CHILD2);
-+			/* no delegation since it is just created */
-+			err = vfsub_notify_change(&dst->f_path, ia,
-+						  /*delegated*/NULL);
-+			mutex_unlock(h_mtx);
-+		}
-+	}
-+
-+	return err;
-+}
-+
-+int au_copy_file(struct file *dst, struct file *src, loff_t len)
-+{
-+	int err;
-+	unsigned long blksize;
-+	unsigned char do_kfree;
-+	char *buf;
-+
-+	err = -ENOMEM;
-+	blksize = dst->f_path.dentry->d_sb->s_blocksize;
-+	if (!blksize || PAGE_SIZE < blksize)
-+		blksize = PAGE_SIZE;
-+	AuDbg("blksize %lu\n", blksize);
-+	do_kfree = (blksize != PAGE_SIZE && blksize >= sizeof(struct iattr *));
-+	if (do_kfree)
-+		buf = kmalloc(blksize, GFP_NOFS);
-+	else
-+		buf = (void *)__get_free_page(GFP_NOFS);
-+	if (unlikely(!buf))
-+		goto out;
-+
-+	if (len > (1 << 22))
-+		AuDbg("copying a large file %lld\n", (long long)len);
-+
-+	src->f_pos = 0;
-+	dst->f_pos = 0;
-+	err = au_do_copy_file(dst, src, len, buf, blksize);
-+	if (do_kfree)
-+		kfree(buf);
-+	else
-+		free_page((unsigned long)buf);
-+
-+out:
-+	return err;
-+}
-+
-+/*
-+ * to support a sparse file which is opened with O_APPEND,
-+ * we need to close the file.
-+ */
-+static int au_cp_regular(struct au_cp_generic *cpg)
-+{
-+	int err, i;
-+	enum { SRC, DST };
-+	struct {
-+		aufs_bindex_t bindex;
-+		unsigned int flags;
-+		struct dentry *dentry;
-+		int force_wr;
-+		struct file *file;
-+		void *label;
-+	} *f, file[] = {
-+		{
-+			.bindex = cpg->bsrc,
-+			.flags = O_RDONLY | O_NOATIME | O_LARGEFILE,
-+			.label = &&out
-+		},
-+		{
-+			.bindex = cpg->bdst,
-+			.flags = O_WRONLY | O_NOATIME | O_LARGEFILE,
-+			.force_wr = !!au_ftest_cpup(cpg->flags, RWDST),
-+			.label = &&out_src
-+		}
-+	};
-+	struct super_block *sb;
-+
-+	/* bsrc branch can be ro/rw. */
-+	sb = cpg->dentry->d_sb;
-+	f = file;
-+	for (i = 0; i < 2; i++, f++) {
-+		f->dentry = au_h_dptr(cpg->dentry, f->bindex);
-+		f->file = au_h_open(cpg->dentry, f->bindex, f->flags,
-+				    /*file*/NULL, f->force_wr);
-+		err = PTR_ERR(f->file);
-+		if (IS_ERR(f->file))
-+			goto *f->label;
-+	}
-+
-+	/* try stopping to update while we copyup */
-+	IMustLock(file[SRC].dentry->d_inode);
-+	err = au_copy_file(file[DST].file, file[SRC].file, cpg->len);
-+
-+	fput(file[DST].file);
-+	au_sbr_put(sb, file[DST].bindex);
-+
-+out_src:
-+	fput(file[SRC].file);
-+	au_sbr_put(sb, file[SRC].bindex);
-+out:
-+	return err;
-+}
-+
-+static int au_do_cpup_regular(struct au_cp_generic *cpg,
-+			      struct au_cpup_reg_attr *h_src_attr)
-+{
-+	int err, rerr;
-+	loff_t l;
-+	struct path h_path;
-+	struct inode *h_src_inode, *h_dst_inode;
-+
-+	err = 0;
-+	h_src_inode = au_h_iptr(cpg->dentry->d_inode, cpg->bsrc);
-+	l = i_size_read(h_src_inode);
-+	if (cpg->len == -1 || l < cpg->len)
-+		cpg->len = l;
-+	if (cpg->len) {
-+		/* try stopping to update while we are referencing */
-+		mutex_lock_nested(&h_src_inode->i_mutex, AuLsc_I_CHILD);
-+		au_pin_hdir_unlock(cpg->pin);
-+
-+		h_path.dentry = au_h_dptr(cpg->dentry, cpg->bsrc);
-+		h_path.mnt = au_sbr_mnt(cpg->dentry->d_sb, cpg->bsrc);
-+		h_src_attr->iflags = h_src_inode->i_flags;
-+		err = vfs_getattr(&h_path, &h_src_attr->st);
-+		if (unlikely(err)) {
-+			mutex_unlock(&h_src_inode->i_mutex);
-+			goto out;
-+		}
-+		h_src_attr->valid = 1;
-+		err = au_cp_regular(cpg);
-+		mutex_unlock(&h_src_inode->i_mutex);
-+		rerr = au_pin_hdir_relock(cpg->pin);
-+		if (!err && rerr)
-+			err = rerr;
-+	}
-+	if (!err && (h_src_inode->i_state & I_LINKABLE)) {
-+		h_path.dentry = au_h_dptr(cpg->dentry, cpg->bdst);
-+		h_dst_inode = h_path.dentry->d_inode;
-+		spin_lock(&h_dst_inode->i_lock);
-+		h_dst_inode->i_state |= I_LINKABLE;
-+		spin_unlock(&h_dst_inode->i_lock);
-+	}
-+
-+out:
-+	return err;
-+}
-+
-+static int au_do_cpup_symlink(struct path *h_path, struct dentry *h_src,
-+			      struct inode *h_dir)
-+{
-+	int err, symlen;
-+	mm_segment_t old_fs;
-+	union {
-+		char *k;
-+		char __user *u;
-+	} sym;
-+
-+	err = -ENOSYS;
-+	if (unlikely(!h_src->d_inode->i_op->readlink))
-+		goto out;
-+
-+	err = -ENOMEM;
-+	sym.k = (void *)__get_free_page(GFP_NOFS);
-+	if (unlikely(!sym.k))
-+		goto out;
-+
-+	/* unnecessary to support mmap_sem since symlink is not mmap-able */
-+	old_fs = get_fs();
-+	set_fs(KERNEL_DS);
-+	symlen = h_src->d_inode->i_op->readlink(h_src, sym.u, PATH_MAX);
-+	err = symlen;
-+	set_fs(old_fs);
-+
-+	if (symlen > 0) {
-+		sym.k[symlen] = 0;
-+		err = vfsub_symlink(h_dir, h_path, sym.k);
-+	}
-+	free_page((unsigned long)sym.k);
-+
-+out:
-+	return err;
-+}
-+
-+static noinline_for_stack
-+int cpup_entry(struct au_cp_generic *cpg, struct dentry *dst_parent,
-+	       struct au_cpup_reg_attr *h_src_attr)
-+{
-+	int err;
-+	umode_t mode;
-+	unsigned int mnt_flags;
-+	unsigned char isdir, isreg, force;
-+	const unsigned char do_dt = !!au_ftest_cpup(cpg->flags, DTIME);
-+	struct au_dtime dt;
-+	struct path h_path;
-+	struct dentry *h_src, *h_dst, *h_parent;
-+	struct inode *h_inode, *h_dir;
-+	struct super_block *sb;
-+
-+	/* bsrc branch can be ro/rw. */
-+	h_src = au_h_dptr(cpg->dentry, cpg->bsrc);
-+	h_inode = h_src->d_inode;
-+	AuDebugOn(h_inode != au_h_iptr(cpg->dentry->d_inode, cpg->bsrc));
-+
-+	/* try stopping to be referenced while we are creating */
-+	h_dst = au_h_dptr(cpg->dentry, cpg->bdst);
-+	if (au_ftest_cpup(cpg->flags, RENAME))
-+		AuDebugOn(strncmp(h_dst->d_name.name, AUFS_WH_PFX,
-+				  AUFS_WH_PFX_LEN));
-+	h_parent = h_dst->d_parent; /* dir inode is locked */
-+	h_dir = h_parent->d_inode;
-+	IMustLock(h_dir);
-+	AuDebugOn(h_parent != h_dst->d_parent);
-+
-+	sb = cpg->dentry->d_sb;
-+	h_path.mnt = au_sbr_mnt(sb, cpg->bdst);
-+	if (do_dt) {
-+		h_path.dentry = h_parent;
-+		au_dtime_store(&dt, dst_parent, &h_path);
-+	}
-+	h_path.dentry = h_dst;
-+
-+	isreg = 0;
-+	isdir = 0;
-+	mode = h_inode->i_mode;
-+	switch (mode & S_IFMT) {
-+	case S_IFREG:
-+		isreg = 1;
-+		err = vfsub_create(h_dir, &h_path, mode | S_IWUSR,
-+				   /*want_excl*/true);
-+		if (!err)
-+			err = au_do_cpup_regular(cpg, h_src_attr);
-+		break;
-+	case S_IFDIR:
-+		isdir = 1;
-+		err = vfsub_mkdir(h_dir, &h_path, mode);
-+		if (!err) {
-+			/*
-+			 * strange behaviour from the users view,
-+			 * particularry setattr case
-+			 */
-+			if (au_ibstart(dst_parent->d_inode) == cpg->bdst)
-+				au_cpup_attr_nlink(dst_parent->d_inode,
-+						   /*force*/1);
-+			au_cpup_attr_nlink(cpg->dentry->d_inode, /*force*/1);
-+		}
-+		break;
-+	case S_IFLNK:
-+		err = au_do_cpup_symlink(&h_path, h_src, h_dir);
-+		break;
-+	case S_IFCHR:
-+	case S_IFBLK:
-+		AuDebugOn(!capable(CAP_MKNOD));
-+		/*FALLTHROUGH*/
-+	case S_IFIFO:
-+	case S_IFSOCK:
-+		err = vfsub_mknod(h_dir, &h_path, mode, h_inode->i_rdev);
-+		break;
-+	default:
-+		AuIOErr("Unknown inode type 0%o\n", mode);
-+		err = -EIO;
-+	}
-+
-+	mnt_flags = au_mntflags(sb);
-+	if (!au_opt_test(mnt_flags, UDBA_NONE)
-+	    && !isdir
-+	    && au_opt_test(mnt_flags, XINO)
-+	    && (h_inode->i_nlink == 1
-+		|| (h_inode->i_state & I_LINKABLE))
-+	    /* todo: unnecessary? */
-+	    /* && cpg->dentry->d_inode->i_nlink == 1 */
-+	    && cpg->bdst < cpg->bsrc
-+	    && !au_ftest_cpup(cpg->flags, KEEPLINO))
-+		au_xino_write(sb, cpg->bsrc, h_inode->i_ino, /*ino*/0);
-+		/* ignore this error */
-+
-+	if (!err) {
-+		force = 0;
-+		if (isreg) {
-+			force = !!cpg->len;
-+			if (cpg->len == -1)
-+				force = !!i_size_read(h_inode);
-+		}
-+		au_fhsm_wrote(sb, cpg->bdst, force);
-+	}
-+
-+	if (do_dt)
-+		au_dtime_revert(&dt);
-+	return err;
-+}
-+
-+static int au_do_ren_after_cpup(struct au_cp_generic *cpg, struct path *h_path)
-+{
-+	int err;
-+	struct dentry *dentry, *h_dentry, *h_parent, *parent;
-+	struct inode *h_dir;
-+	aufs_bindex_t bdst;
-+
-+	dentry = cpg->dentry;
-+	bdst = cpg->bdst;
-+	h_dentry = au_h_dptr(dentry, bdst);
-+	if (!au_ftest_cpup(cpg->flags, OVERWRITE)) {
-+		dget(h_dentry);
-+		au_set_h_dptr(dentry, bdst, NULL);
-+		err = au_lkup_neg(dentry, bdst, /*wh*/0);
-+		if (!err)
-+			h_path->dentry = dget(au_h_dptr(dentry, bdst));
-+		au_set_h_dptr(dentry, bdst, h_dentry);
-+	} else {
-+		err = 0;
-+		parent = dget_parent(dentry);
-+		h_parent