/*

 * 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

 */

/*

 * main header files

 *

 * $Id: aufs.h,v 1.2 2008/04/21 01:31:49 sfjro Exp $

 */

#ifndef __AUFS_H__

#define __AUFS_H__

#ifdef __KERNEL__

#include <linux/version.h>

#include "debug.h"

#include "branch.h"

#include "cpup.h"

#include "dcsub.h"

#include "dentry.h"

#include "dir.h"

#include "file.h"

#include "hinode.h"

#include "inode.h"

#include "misc.h"

#include "module.h"

#include "opts.h"

#include "super.h"

#include "sysaufs.h"

#include "vfsub.h"

#include "whout.h"

#include "wkq.h"

//#include "xattr.h"

#endif /* __KERNEL__ */

#endif /* __AUFS_H__ */

/*

 * 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

 */

/*

 * branch management

 *

 * $Id: branch.c,v 1.5 2008/05/19 01:52:18 sfjro Exp $

 */

#include <linux/iso_fs.h>

#include <linux/loop.h>

#include <linux/romfs_fs.h>

#include <linux/smp_lock.h>

#include "aufs.h"

static void free_branch(struct au_branch *br)

{

	AuTraceEnter();

	if (br->br_xino)

		fput(br->br_xino);

	dput(br->br_wh);

	dput(br->br_plink);

	if (!au_test_nfs(br->br_mnt->mnt_sb))

		mntput(br->br_mnt);

	else {

		lockdep_off();

		mntput(br->br_mnt);

		lockdep_on();

	}

	AuDebugOn(au_br_count(br) || atomic_read(&br->br_wh_running));

	//AuDbg("free\n");

	kfree(br);

}

/*

 * frees all branches

 */

void au_br_free(struct au_sbinfo *sbinfo)

{

	aufs_bindex_t bmax;

	struct au_branch **br;

	AuTraceEnter();

	bmax = sbinfo->si_bend + 1;

	br = sbinfo->si_branch;

	while (bmax--)

		free_branch(*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;

	AuTraceEnter();

	bend = au_sbend(sb);

	for (bindex = 0; bindex <= bend; bindex++)

		if (au_sbr_id(sb, bindex) == br_id)

			return bindex;

	return -1;

}

/*

 * test if the @h_sb is real-readonly.

 */

int au_test_def_rr(struct super_block *h_sb)

{

	switch (h_sb->s_magic) {

#ifdef CONFIG_AUFS_RR_SQUASHFS

	case SQUASHFS_MAGIC_LZMA:

	case SQUASHFS_MAGIC:

	case SQUASHFS_MAGIC_LZMA_SWAP:

	case SQUASHFS_MAGIC_SWAP:

		return 1; /* real readonly */

#endif

#if defined(CONFIG_ISO9660_FS) || defined(CONFIG_ISO9660_FS_MODULE)

	case ISOFS_SUPER_MAGIC:

		return 1;

#endif

#if defined(CONFIG_CRAMFS) || defined(CONFIG_CRAMFS_MODULE)

	case CRAMFS_MAGIC:

		return 1;

#endif

#if defined(CONFIG_ROMFS_FS) || defined(CONFIG_ROMFS_FS_MODULE)

	case ROMFS_MAGIC:

		return 1;

#endif

	default:

		return 0;

	}

}

/* ---------------------------------------------------------------------- */

/*

 * test if two hidden_dentries have overlapping branches.

 */

static int do_test_overlap(struct super_block *sb, struct dentry *h_d1,

			   struct dentry *h_d2)

{

	int err;

	LKTRTrace("%.*s, %.*s\n", AuDLNPair(h_d1), AuDLNPair(h_d2));

	err = au_test_subdir(h_d1, h_d2);

	AuTraceErr(err);

	return err;

}

static int test_overlap_loopback(struct super_block *sb, struct dentry *h_d1,

				 struct dentry *h_d2)

{

#if defined(CONFIG_BLK_DEV_LOOP) || defined(CONFIG_BLK_DEV_LOOP_MODULE)

	struct inode *h_inode;

	struct loop_device *l;

	h_inode = h_d1->d_inode;

	if (MAJOR(h_inode->i_sb->s_dev) != LOOP_MAJOR)

		return 0;

	l = h_inode->i_sb->s_bdev->bd_disk->private_data;

	h_d1 = l->lo_backing_file->f_dentry;

	if (unlikely(h_d1->d_sb == sb))

		return 1;

	return do_test_overlap(sb, h_d1, h_d2);

#else

	return 0;

#endif

}

static int test_overlap(struct super_block *sb, struct dentry *h_d1,

			struct dentry *h_d2)

{

	LKTRTrace("d1 %.*s, d2 %.*s\n", AuDLNPair(h_d1), AuDLNPair(h_d2));

	if (unlikely(h_d1 == h_d2))

		return 1;

	return do_test_overlap(sb, h_d1, h_d2)

		|| do_test_overlap(sb, h_d2, h_d1)

		|| test_overlap_loopback(sb, h_d1, h_d2)

		|| test_overlap_loopback(sb, h_d2, h_d1);

}

/* ---------------------------------------------------------------------- */

static int init_br_wh(struct super_block *sb, aufs_bindex_t bindex,

		      struct au_branch *br, int new_perm,

		      struct dentry *h_root, struct vfsmount *h_mnt)

{

	int err, old_perm;

	struct inode *dir, *h_dir;

	const int new = (bindex < 0);

	LKTRTrace("b%d, new_perm %d\n", bindex, new_perm);

	dir = sb->s_root->d_inode;

	h_dir = h_root->d_inode;

	if (new)

		mutex_lock_nested(&h_dir->i_mutex, AuLsc_I_PARENT);

	else

		au_hdir_lock(h_dir, dir, bindex);

	br_wh_write_lock(br);

	old_perm = br->br_perm;

	br->br_perm = new_perm;

	err = au_wh_init(h_root, br, au_do_nfsmnt(h_mnt), sb);

	br->br_perm = old_perm;

	br_wh_write_unlock(br);

	if (new)

		mutex_unlock(&h_dir->i_mutex);

	else

		au_hdir_unlock(h_dir, dir, bindex);

	AuTraceErr(err);

	return err;

}

/* ---------------------------------------------------------------------- */

/*

 * returns a newly allocated branch. @new_nbranch is a number of branches

 * after adding a branch.

 */

static struct au_branch *alloc_addbr(struct super_block *sb, int new_nbranch)

{

	struct au_branch **branchp, *add_branch;

	int sz;

	void *p;

	struct dentry *root;

	struct inode *inode;

	struct au_hinode *hinodep;

	struct au_hdentry *hdentryp;

	LKTRTrace("new_nbranch %d\n", new_nbranch);

	SiMustWriteLock(sb);

	root = sb->s_root;

	DiMustWriteLock(root);

	inode = root->d_inode;

	IiMustWriteLock(inode);

	add_branch = kmalloc(sizeof(*add_branch), GFP_KERNEL);

	//if (LktrCond) {kfree(add_branch); add_branch = NULL;}

	if (unlikely(!add_branch))

		goto out;

	sz = sizeof(*branchp) * (new_nbranch - 1);

	if (unlikely(!sz))

		sz = sizeof(*branchp);

	p = au_sbi(sb)->si_branch;

	branchp = au_kzrealloc(p, sz, sizeof(*branchp) * new_nbranch,

			       GFP_KERNEL);

	//if (LktrCond) branchp = NULL;

	if (unlikely(!branchp))

		goto out_br;

	au_sbi(sb)->si_branch = branchp;

	sz = sizeof(*hdentryp) * (new_nbranch - 1);

	if (unlikely(!sz))

		sz = sizeof(*hdentryp);

	p = au_di(root)->di_hdentry;

	hdentryp = au_kzrealloc(p, sz, sizeof(*hdentryp) * new_nbranch,

				GFP_KERNEL);

	//if (LktrCond) hdentryp = NULL;

	if (unlikely(!hdentryp))

		goto out_br;

	au_di(root)->di_hdentry = hdentryp;

	sz = sizeof(*hinodep) * (new_nbranch - 1);

	if (unlikely(!sz))

		sz = sizeof(*hinodep);

	p = au_ii(inode)->ii_hinode;

	hinodep = au_kzrealloc(p, sz, sizeof(*hinodep) * new_nbranch,

			       GFP_KERNEL);

	//if (LktrCond) hinodep = NULL; // unavailable test

	if (unlikely(!hinodep))

		goto out_br;

	au_ii(inode)->ii_hinode = hinodep;

	return add_branch; /* success */

 out_br:

	kfree(add_branch);

 out:

	AuTraceErr(-ENOMEM);

	return ERR_PTR(-ENOMEM);

}

/*

 * test if the branch permission is legal or not.

 */

static int test_br(struct super_block *sb, struct inode *inode, int brperm,

		   char *path)

{

	int err;

	err = 0;

	if (unlikely(au_br_writable(brperm) && IS_RDONLY(inode))) {

		AuErr("write permission for readonly fs or inode, %s\n", path);

		err = -EINVAL;

	}

	AuTraceErr(err);

	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;

	struct dentry *root;

	struct inode *inode, *h_inode;

	aufs_bindex_t bend, bindex;

	LKTRTrace("%s, remo%d\n", add->path, remount);

	root = sb->s_root;

	bend = au_sbend(sb);

	if (unlikely(bend >= 0

		     && au_find_dbindex(root, add->nd.path.dentry) >= 0)) {

		err = 1;

		if (!remount) {

			err = -EINVAL;

			AuErr("%s duplicated\n", add->path);

		}

		goto out;

	}

	err = -ENOSPC; //-E2BIG;

	//if (LktrCond) bend = AUFS_BRANCH_MAX;

	if (unlikely(AUFS_BRANCH_MAX <= add->bindex

		     || AUFS_BRANCH_MAX - 1 <= bend)) {

		AuErr("number of branches exceeded %s\n", add->path);

		goto out;

	}

	err = -EDOM;

	if (unlikely(add->bindex < 0 || bend + 1 < add->bindex)) {

		AuErr("bad index %d\n", add->bindex);

		goto out;

	}

	inode = add->nd.path.dentry->d_inode;

	AuDebugOn(!inode || !S_ISDIR(inode->i_mode));

	err = -ENOENT;

	if (unlikely(!inode->i_nlink)) {

		AuErr("no existence %s\n", add->path);

		goto out;

	}

	err = -EINVAL;

	if (unlikely(inode->i_sb == sb)) {

		AuErr("%s must be outside\n", add->path);

		goto out;

	}

	if (unlikely(au_test_nested(inode->i_sb))) {

		AuErr("nested " AUFS_NAME " %s\n", add->path);

		goto out;

	}

	if (unlikely(!strcmp(au_sbtype(inode->i_sb), "unionfs"))) {

		AuErr("unsupported filesystem, %s\n", add->path);

		goto out;

	}

	if (unlikely(au_test_unsupported_nfs(inode->i_sb))) {

		AuErr(AuNoNfsBranchMsg " %s\n", add->path);

		goto out;

	}

	err = test_br(sb, add->nd.path.dentry->d_inode, add->perm, add->path);

	if (unlikely(err))

		goto out;

	if (bend < 0)

		return 0; /* success */

	h_inode = au_h_dptr(root, 0)->d_inode;

	if (unlikely(au_opt_test(au_mntflags(sb), WARN_PERM)

		     && ((h_inode->i_mode & S_IALLUGO)

			 != (inode->i_mode & S_IALLUGO)

			 || h_inode->i_uid != inode->i_uid

			 || h_inode->i_gid != inode->i_gid)))

		AuWarn("uid/gid/perm %s %u/%u/0%o, %u/%u/0%o\n",

		       add->path,

		       inode->i_uid, inode->i_gid, (inode->i_mode & S_IALLUGO),

		       h_inode->i_uid, h_inode->i_gid,

		       (h_inode->i_mode & S_IALLUGO));

	err = -EINVAL;

	for (bindex = 0; bindex <= bend; bindex++)

		if (unlikely(test_overlap(sb, add->nd.path.dentry,

					  au_h_dptr(root, bindex)))) {

			AuErr("%s is overlapped\n", add->path);

			goto out;

		}

	err = 0;

 out:

	AuTraceErr(err);

	return err;

}

static int au_br_init(struct au_branch *br, struct super_block *sb,

		      struct au_opt_add *add)

{

	int err;

	AuTraceEnter();

	err = 0;

	au_rw_init_nolock(&br->br_wh_rwsem);

	br->br_plink = NULL;

	br->br_wh = NULL;

	if (unlikely(au_br_writable(add->perm))) {

		err = init_br_wh(sb, /*bindex*/-1, br, add->perm,

				 add->nd.path.dentry, add->nd.path.mnt);

		if (unlikely(err))

			goto out;

	}

	br->br_xino = NULL;

	br->br_mnt = mntget(add->nd.path.mnt);

	if (au_opt_test(au_mntflags(sb), XINO)) {

		err = au_xino_br(sb, br, add->nd.path.dentry->d_inode->i_ino,

				 au_sbr(sb, 0)->br_xino, /*do_test*/1);

		if (unlikely(err)) {

			AuDebugOn(br->br_xino);

			goto out;

		}

	}

	atomic_set(&br->br_wh_running, 0);

	br->br_id = au_new_br_id(sb);

	br->br_perm = add->perm;

	atomic_set(&br->br_count, 0);

	br->br_bytes = 0;

	br->br_xino_upper = AUFS_XINO_TRUNC_INIT;

	atomic_set(&br->br_xino_running, 0);

	sysaufs_br_init(br);

	br->br_generation = au_sigen(sb);

	//smp_mb(); /* atomic_set */

 out:

	AuTraceErr(err);

	return err;

}

int au_br_add(struct super_block *sb, struct au_opt_add *add, int remount)

{

	int err, amount;

	aufs_bindex_t bend, add_bindex;

	struct dentry *root, *dentry;

	struct au_iinfo *iinfo;

	struct au_sbinfo *sbinfo;

	struct au_dinfo *dinfo;

	struct inode *root_inode, *inode;

	unsigned long long maxb;

	struct au_branch **branchp, *add_branch;

	struct au_hdentry *hdentryp;

	struct au_hinode *hinodep;

	dentry = add->nd.path.dentry;

	LKTRTrace("b%d, %s, 0x%x, %.*s\n",

		  add->bindex, add->path, add->perm, AuDLNPair(dentry));

	SiMustWriteLock(sb);

	root = sb->s_root;

	DiMustWriteLock(root);

	root_inode = root->d_inode;

	IMustLock(root_inode);

	IiMustWriteLock(root_inode);

	err = test_add(sb, add, remount);

	if (unlikely(err < 0))

		goto out;

	if (err)

		return 0; /* success */

	bend = au_sbend(sb);

	add_branch = alloc_addbr(sb, bend + 2);

	err = PTR_ERR(add_branch);

	if (IS_ERR(add_branch))

		goto out;

	err = au_br_init(add_branch, sb, add);

	if (unlikely(err)) {

		kfree(add_branch);

		goto out;

	}

	add_bindex = add->bindex;

	if (remount)

		sysaufs_brs_del(sb, add_bindex);

	sbinfo = au_sbi(sb);

	dinfo = au_di(root);

	iinfo = au_ii(root_inode);

	amount = bend + 1 - add_bindex;

	branchp = sbinfo->si_branch + add_bindex;

	memmove(branchp + 1, branchp, sizeof(*branchp) * amount);

	*branchp = add_branch;

	hdentryp = dinfo->di_hdentry + add_bindex;

	memmove(hdentryp + 1, hdentryp, sizeof(*hdentryp) * amount);

	au_h_dentry_init(hdentryp);

	hinodep = iinfo->ii_hinode + add_bindex;

	memmove(hinodep + 1, hinodep, sizeof(*hinodep) * amount);

	hinodep->hi_inode = NULL;

	au_hin_init(hinodep, NULL);

	sbinfo->si_bend++;

	dinfo->di_bend++;

	iinfo->ii_bend++;

	if (unlikely(bend < 0)) {

		sbinfo->si_bend = 0;

		dinfo->di_bstart = 0;

		iinfo->ii_bstart = 0;

	}

	inode = dentry->d_inode;

	au_set_h_dptr(root, add_bindex, dget(dentry));

	au_set_h_iptr(root_inode, add_bindex, igrab(inode), 0);

	if (remount)

		sysaufs_brs_add(sb, add_bindex);

	if (!add_bindex)

		au_cpup_attr_all(root_inode);

	else

		au_add_nlink(root_inode, inode);

	maxb = dentry->d_sb->s_maxbytes;

	if (sb->s_maxbytes < maxb)

		sb->s_maxbytes = maxb;

 out:

	AuTraceErr(err);

	return err;

}

/* ---------------------------------------------------------------------- */

#define AuVerbose(do_info, fmt, args...) do { \

	if (!do_info) \

		LKTRTrace(fmt, ##args); \

	else \

		AuInfo(fmt, ##args); \

} while (0)

/*

 * test if the branch is deletable or not.

 */

static int test_dentry_busy(struct dentry *root, aufs_bindex_t bindex,

			    au_gen_t sigen)

{

	int err, i, j, ndentry, verbose;

	struct au_dcsub_pages dpages;

	struct au_dpage *dpage;

	struct dentry *d;

	aufs_bindex_t bstart, bend;

	struct inode *inode;

	LKTRTrace("b%d, gen%d\n", bindex, sigen);

	SiMustWriteLock(root->d_sb);

	err = au_dpages_init(&dpages, GFP_TEMPORARY);

	if (unlikely(err))

		goto out;

	err = au_dcsub_pages(&dpages, root, NULL, NULL);

	if (unlikely(err))

		goto out_dpages;

	verbose = !!au_opt_test(au_mntflags(root->d_sb), VERBOSE);

	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(!atomic_read(&d->d_count));

			inode = d->d_inode;

			AuDebugOn(!inode);

			if (au_digen(d) == sigen

			    && au_iigen(inode) == sigen)

				di_read_lock_child(d, AuLock_IR);

			else {

				di_write_lock_child(d);

				err = au_reval_dpath(d, sigen);

				if (!err)

					di_downgrade_lock(d, AuLock_IR);

				else {

					di_write_unlock(d);

					break;

				}

			}

			bstart = au_dbstart(d);

			bend = au_dbend(d);

			if (bstart <= bindex

			    && bindex <= bend

			    && au_h_dptr(d, bindex)

			    && (!S_ISDIR(d->d_inode->i_mode)

				|| bstart == bend)) {

				err = -EBUSY;

				AuVerbose(verbose, "busy %.*s\n", AuDLNPair(d));

			}

			di_read_unlock(d, AuLock_IR);

		}

	}

 out_dpages:

	au_dpages_free(&dpages);

 out:

	AuTraceErr(err);

	return err;

}

static int test_inode_busy(struct super_block *sb, aufs_bindex_t bindex,

			   au_gen_t sigen)

{

	int err, verbose;

	struct inode *i;

	aufs_bindex_t bstart, bend;

	LKTRTrace("b%d, gen%d\n", bindex, sigen);

	SiMustWriteLock(sb);

	err = 0;

	verbose = !!au_opt_test(au_mntflags(sb), VERBOSE);

	list_for_each_entry(i, &sb->s_inodes, i_sb_list) {

		AuDebugOn(!atomic_read(&i->i_count));

		if (!list_empty(&i->i_dentry))

			continue;

		if (au_iigen(i) == sigen)

			ii_read_lock_child(i);

		else {

			ii_write_lock_child(i);

			err = au_refresh_hinode_self(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)

		    && (!S_ISDIR(i->i_mode) || bstart == bend)) {

			err = -EBUSY;

			AuVerbose(verbose, "busy i%lu\n", i->i_ino);

			//au_debug_on();

			//DbgInode(i);

			//au_debug_off();

			ii_read_unlock(i);

			break;

		}

		ii_read_unlock(i);

	}

	AuTraceErr(err);

	return err;

}

static int test_children_busy(struct dentry *root, aufs_bindex_t bindex)

{

	int err;

	au_gen_t sigen;

	LKTRTrace("b%d\n", bindex);

	SiMustWriteLock(root->d_sb);

	DiMustWriteLock(root);

	//todo: dont trust BKL.

	AuDebugOn(!kernel_locked());

	sigen = au_sigen(root->d_sb);

	DiMustNoWaiters(root);

	IiMustNoWaiters(root->d_inode);

	di_write_unlock(root);

	err = test_dentry_busy(root, bindex, sigen);

	if (!err)

		err = test_inode_busy(root->d_sb, bindex, sigen);

	di_write_lock_child(root); /* aufs_write_lock() calls ..._child() */

	AuTraceErr(err);

	return err;

}

int au_br_del(struct super_block *sb, struct au_opt_del *del, int remount)

{

	int err, do_wh, rerr, verbose;

	struct dentry *root;

	struct inode *inode, *hidden_dir;

	aufs_bindex_t bindex, bend, br_id;

	struct au_sbinfo *sbinfo;

	struct au_dinfo *dinfo;

	struct au_iinfo *iinfo;

	struct au_branch *br;

	unsigned int mnt_flags;

	//au_debug_on();

	LKTRTrace("%s, %.*s\n", del->path, AuDLNPair(del->h_root));

	SiMustWriteLock(sb);

	root = sb->s_root;

	DiMustWriteLock(root);

	inode = root->d_inode;

	IiMustWriteLock(inode);

	err = 0;

	bindex = au_find_dbindex(root, del->h_root);

	if (bindex < 0) {

		if (remount)

			goto out; /* success */

		err = -ENOENT;

		AuErr("%s no such branch\n", del->path);

		goto out;

	}

	LKTRTrace("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);

	if (unlikely(au_br_count(br))) {

		AuVerbose(verbose, "%d file(s) opened\n", au_br_count(br));

		goto out;

	}

	do_wh = 0;

	hidden_dir = del->h_root->d_inode;

	if (br->br_wh || br->br_plink) {

		dput(br->br_wh);

		dput(br->br_plink);

		br->br_plink = NULL;

		br->br_wh = NULL;

		do_wh = 1;

	}

	err = test_children_busy(root, bindex);

	if (unlikely(err)) {

		if (unlikely(do_wh))

			goto out_wh;

		goto out;

	}

	err = 0;

	if (remount)

		sysaufs_brs_del(sb, bindex);

	sbinfo = au_sbi(sb);

	dinfo = au_di(root);

	iinfo = au_ii(inode);

	dput(au_h_dptr(root, bindex));

	au_hiput(iinfo->ii_hinode + bindex);

	br_id = br->br_id;

	free_branch(br);

	//todo: realloc and shrink memory

	if (bindex < bend) {

		const aufs_bindex_t n = bend - bindex;

		struct au_branch **brp;

		struct au_hdentry *hdp;

		struct au_hinode *hip;

		brp = sbinfo->si_branch + bindex;

		memmove(brp, brp + 1, sizeof(*brp) * n);

		hdp = dinfo->di_hdentry + bindex;

		memmove(hdp, hdp + 1, sizeof(*hdp) * n);

		hip = iinfo->ii_hinode + bindex;

		memmove(hip, hip + 1, sizeof(*hip) * n);

	}

	sbinfo->si_branch[0 + bend] = NULL;

	dinfo->di_hdentry[0 + bend].hd_dentry = NULL;

	iinfo->ii_hinode[0 + bend].hi_inode = NULL;

	au_hin_init(iinfo->ii_hinode + bend, NULL);

	sbinfo->si_bend--;

	dinfo->di_bend--;

	iinfo->ii_bend--;

	if (remount)

		sysaufs_brs_add(sb, bindex);

	if (!bindex)

		au_cpup_attr_all(inode);

	else

		au_sub_nlink(inode, del->h_root->d_inode);

	if (au_opt_test(mnt_flags, PLINK))

		au_plink_half_refresh(sb, br_id);

	if (sb->s_maxbytes == del->h_root->d_sb->s_maxbytes) {

		bend--;

		sb->s_maxbytes = 0;

		for (bindex = 0; bindex <= bend; bindex++) {

			unsigned long long maxb;

			maxb = au_sbr_sb(sb, bindex)->s_maxbytes;

			if (sb->s_maxbytes < maxb)

				sb->s_maxbytes = maxb;

		}

	}

	goto out; /* success */

 out_wh:

	/* revert */

	rerr = init_br_wh(sb, bindex, br, br->br_perm, del->h_root, br->br_mnt);

	if (rerr)

		AuWarn("failed re-creating base whiteout, %s. (%d)\n",

		       del->path, rerr);

 out:

	AuTraceErr(err);

	//au_debug_off();

	return err;

}

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));

}

int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount,

	      int *do_update)

{

	int err;

	struct dentry *root;

	aufs_bindex_t bindex;

	struct au_branch *br;

	struct inode *hidden_dir;

	LKTRTrace("%s, %.*s, 0x%x\n",

		  mod->path, AuDLNPair(mod->h_root), mod->perm);

	SiMustWriteLock(sb);

	root = sb->s_root;

	DiMustWriteLock(root);

	IiMustWriteLock(root->d_inode);

	bindex = au_find_dbindex(root, mod->h_root);

	if (bindex < 0) {

		if (remount)

			return 0; /* success */

		err = -ENOENT;

		AuErr("%s no such branch\n", mod->path);

		goto out;

	}

	LKTRTrace("bindex b%d\n", bindex);

	hidden_dir = mod->h_root->d_inode;

	err = test_br(sb, hidden_dir, mod->perm, mod->path);

	if (unlikely(err))

		goto out;

	br = au_sbr(sb, bindex);

	if (br->br_perm == mod->perm)

		return 0; /* success */

	if (au_br_writable(br->br_perm)) {

		/* remove whiteout base */

		//todo: mod->perm?

		err = init_br_wh(sb, bindex, br, AuBr_RO, mod->h_root,

				 br->br_mnt);

		if (unlikely(err))

			goto out;

		if (!au_br_writable(mod->perm)) {

			/* rw --> ro, file might be mmapped */

			struct file *file, *hf;

			DiMustNoWaiters(root);

			IiMustNoWaiters(root->d_inode);

			di_write_unlock(root);

			/*

			 * no need file_list_lock()

			 * since BKL (and sbinfo) is locked

			 */

			AuDebugOn(!kernel_locked());

			list_for_each_entry(file, &sb->s_files, f_u.fu_list) {

				LKTRTrace("%.*s\n", AuDLNPair(file->f_dentry));

				if (!au_test_aufs_file(file))

					continue;

				fi_read_lock(file);

				if (!S_ISREG(file->f_dentry->d_inode->i_mode)

				    || !(file->f_mode & FMODE_WRITE)

				    || au_fbstart(file) != bindex) {

					FiMustNoWaiters(file);

					fi_read_unlock(file);

					continue;

				}

				if (unlikely(au_test_mmapped(file))) {

					err = -EBUSY;

					FiMustNoWaiters(file);

					fi_read_unlock(file);

					break;

				}

				// todo: already flushed?

				hf = au_h_fptr(file, au_fbstart(file));

				hf->f_flags = au_file_roflags(hf->f_flags);

				hf->f_mode &= ~FMODE_WRITE;

				put_write_access(hf->f_dentry->d_inode);

				FiMustNoWaiters(file);

				fi_read_unlock(file);

			}

			/* aufs_write_lock() calls ..._child() */

			di_write_lock_child(root);

		}

	}

	if (!err) {

		*do_update |= need_sigen_inc(br->br_perm, mod->perm);

		br->br_perm = mod->perm;

	}

 out:

	AuTraceErr(err);

	return err;

}

/*

 * 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

 */

/*

 * branch filesystems and xino for them

 *

 * $Id: branch.h,v 1.3 2008/04/28 03:03:32 sfjro Exp $

 */

#ifndef __AUFS_BRANCH_H__

#define __AUFS_BRANCH_H__

#ifdef __KERNEL__

#include <linux/fs.h>

#include <linux/mount.h>

#include <linux/sysfs.h>

#include <linux/aufs_type.h>

#include "misc.h"

#include "super.h"

/* ---------------------------------------------------------------------- */

/* an entry in a xino file */

struct au_xino_entry {

	ino_t ino;

	//__u32 h_gen;

} __packed;

//#define AuXino_INVALID_HGEN	(-1)

/* a xino file */

struct au_xino_file {

	//struct file		**xi_file;

	struct file		*xi_file;

	/* array management */

	//unsigned long long	xi_limit;	/* Max xino file size */

	//unsigned long long	xi_size; /* s_maxbytes */

	/* truncation */

	blkcnt_t		xi_upper;	/* watermark in blocks */

	//u64			xi_upper;	/* watermark in bytes */

	//u64			xi_step;	/* to next watermark in bytes */

	atomic_t 		xi_running;

};

/* protected by superblock rwsem */

struct au_branch {

	struct file		*br_xino;

	//struct au_xino_file		*br_xino;

	aufs_bindex_t		br_id;

	int			br_perm;

	struct vfsmount		*br_mnt;

	atomic_t		br_count;

	/* whiteout base */

	struct au_rwsem		br_wh_rwsem;

	struct dentry		*br_wh;

	atomic_t 		br_wh_running;

	/* pseudo-link dir */

	struct dentry		*br_plink;

	/* xino truncation */

	blkcnt_t		br_xino_upper;	/* watermark in blocks */

	atomic_t		br_xino_running;

	/* mfs mode */

	u64			br_bytes;

#ifdef CONFIG_SYSFS

	/* an entry under sysfs per mount-point */

	char			br_name[8];

	struct attribute	br_attr;

#endif

	au_gen_t		br_generation;

};

/* ---------------------------------------------------------------------- */

/* branch permission and attribute */

enum {

	AuBr_RW,		/* writable, linkable wh */

	AuBr_RO,		/* readonly, no wh */

	AuBr_RR,		/* natively readonly, no wh */

	AuBr_RWNoLinkWH,	/* un-linkable whiteouts */

	AuBr_ROWH,

	AuBr_RRWH,		/* whiteout-able */

	AuBr_Last

};

static inline int au_br_writable(int brperm)

{

	return (brperm == AuBr_RW || brperm == AuBr_RWNoLinkWH);

}

static inline int au_br_whable(int brperm)

{

	return (brperm == AuBr_RW

		|| brperm == AuBr_ROWH

		|| brperm == AuBr_RRWH);

}

static inline int au_br_hinotifyable(int brperm)

{

#ifdef CONFIG_AUFS_HINOTIFY

	return (brperm != AuBr_RR && brperm != AuBr_RRWH);

#else

	return 0;

#endif

}

/* ---------------------------------------------------------------------- */

/* branch.c */

struct au_sbinfo;

void au_br_free(struct au_sbinfo *sinfo);

int au_test_def_rr(struct super_block *h_sb);

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);

struct au_opt_mod;

int au_br_mod(struct super_block *sb, struct au_opt_mod *mod, int remount,

	      int *do_update);

/* xino.c */

int au_xib_trunc(struct super_block *sb);

struct file *au_xino_create(struct super_block *sb, char *fname, int silent,

			    struct dentry *parent);

ino_t au_xino_new_ino(struct super_block *sb);

int au_xino_write0(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino,

		   ino_t ino);

int au_xino_write(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino,

		  struct au_xino_entry *xinoe);

int au_xino_read(struct super_block *sb, aufs_bindex_t bindex, ino_t h_ino,

		 struct au_xino_entry *xinoe);

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);

/* ---------------------------------------------------------------------- */

//todo: memory barrier?

static inline int au_br_count(struct au_branch *br)

{

	return atomic_read(&br->br_count);

}

static inline int au_br_get(struct au_branch *br)

{

	return atomic_inc_return(&br->br_count);

}

static inline int au_br_put(struct au_branch *br)

{

	return atomic_dec_return(&br->br_count);

}

static inline au_gen_t au_br_gen(struct au_branch *br)

{

	return br->br_generation;

}

/*

 * test if the @br is readonly or not.

 */

static inline int au_br_rdonly(struct au_branch *br)

{

	return ((br->br_mnt->mnt_sb->s_flags & MS_RDONLY)

		|| !au_br_writable(br->br_perm))

		? -EROFS : 0;

}

/* ---------------------------------------------------------------------- */

/* 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_sbr(sb, bindex)->br_mnt;

}

static inline

struct super_block *au_sbr_sb(struct super_block *sb, aufs_bindex_t bindex)

{

	return au_sbr_mnt(sb, bindex)->mnt_sb;

}

static inline void au_sbr_put(struct super_block *sb, aufs_bindex_t bindex)

{

	au_br_put(au_sbr(sb, bindex));

}

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));

}

static inline int au_test_trunc_xino(struct super_block *sb)

{

	return au_test_tmpfs(sb);

}

/* temporary support for i#1 in cramfs */

static inline int au_test_unique_ino(struct dentry *h_dentry, ino_t h_ino)

{

#if defined(CONFIG_CRAMFS) || defined(CONFIG_CRAMFS_MODULE)

	if (unlikely(h_dentry->d_sb->s_magic == CRAMFS_MAGIC))

		return (h_ino != 1);

#endif

	return 1;

}

#ifdef CONFIG_AUFS_BR_NFS

static inline int au_test_unsupported_nfs(struct super_block *h_sb)

{

	return 0;

}

static inline struct vfsmount *au_do_nfsmnt(struct vfsmount *h_mnt)

{

	if (!au_test_nfs(h_mnt->mnt_sb))

		return NULL;

	return h_mnt;

}

/* it doesn't mntget() */

static inline

struct vfsmount *au_nfsmnt(struct super_block *sb, aufs_bindex_t bindex)

{

	return au_do_nfsmnt(au_sbr_mnt(sb, bindex));

}

#define AuNoNfsBranchMsg "dummy"

#else

static inline int au_test_unsupported_nfs(struct super_block *h_sb)

{

	return au_test_nfs(h_sb);

}

static inline struct vfsmount *au_do_nfsmnt(struct vfsmount *h_mnt)

{

	return NULL;

}

static inline

struct vfsmount *au_nfsmnt(struct super_block *sb, aufs_bindex_t bindex)

{

	return NULL;

}

#define AuNoNfsBranchMsg "NFS branch is not supported" \

	", try some configurations and patches included in aufs source CVS."

#endif /* CONFIG_AUFS_BR_NFS */

/* ---------------------------------------------------------------------- */

/*

 * br_wh_read_lock, br_wh_write_lock

 * br_wh_read_unlock, br_wh_write_unlock, br_wh_downgrade_lock

 */

AuSimpleRwsemFuncs(br_wh, struct au_branch *br, br->br_wh_rwsem);

/* to debug easier, do not make them inlined functions */

#define BrWhMustReadLock(br) do { \

	/* SiMustAnyLock(sb); */ \

	AuRwMustReadLock(&(br)->br_wh_rwsem); \

} while (0)

#define BrWhMustWriteLock(br) do { \

	/* SiMustAnyLock(sb); */ \

	AuRwMustWriteLock(&(br)->br_wh_rwsem); \

} while (0)

#define BrWhMustAnyLock(br) do { \

	/* SiMustAnyLock(sb); */ \

	AuRwMustAnyLock(&(br)->br_wh_rwsem); \

} while (0)

#endif /* __KERNEL__ */

#endif /* __AUFS_BRANCH_H__ */

/*

 * Copyright (C) 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

 */

/*

 * special handling for inode attributes on FUSE branch

 *

 * $Id: br_fuse.c,v 1.2 2008/04/21 01:32:05 sfjro Exp $

 */

#include "aufs.h"

/* h_mnt can be NULL, is it safe? */

int au_update_fuse_h_inode(struct vfsmount *h_mnt, struct dentry *h_dentry)

{

	int err;

	struct kstat st;

	LKTRTrace("%.*s\n", AuDLNPair(h_dentry));

	err = 0;

	if (unlikely(h_dentry->d_inode

		     //&& atomic_read(&h_dentry->d_inode->i_count)

		     && au_test_fuse(h_dentry->d_sb))) {

		err = vfsub_getattr(h_mnt, h_dentry, &st, /*dlgt*/0);

		if (unlikely(err)) {

			AuDbg("err %d\n", err);

			au_debug_on();

			AuDbgDentry(h_dentry);

			au_debug_off();

			WARN_ON(err);

		}

	}

	return err;

}

/* currently, for fuse only */

int aufs_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *st)

{

	int err;

	struct inode *inode, *h_inode;

	struct dentry *h_dentry;

	LKTRTrace("%.*s\n", AuDLNPair(dentry));

	err = 0;

	aufs_read_lock(dentry, AuLock_IR);

	inode = dentry->d_inode;

	h_inode = au_h_iptr(inode, au_ibstart(inode));

	if (unlikely(au_test_fuse(h_inode->i_sb))) {

		h_dentry = d_find_alias(h_inode);

		/* simply gave up updating fuse inode */

		if (h_dentry) {

			/*ignore*/

			if (!au_update_fuse_h_inode(NULL, h_dentry))

				au_cpup_attr_all(inode);

			dput(h_dentry);

		}

	}

	generic_fillattr(inode, st);

	aufs_read_unlock(dentry, AuLock_IR);

	return err;

}

/*

 * Copyright (C) 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

 */

/*

 * lookup functions for NFS branch in linux-2.6.19 and later

 *

 * $Id: br_nfs.c,v 1.3 2008/05/04 23:51:14 sfjro Exp $

 */

#include "aufs.h"

static struct file *au_find_h_intent(struct au_hdentry *hd, struct file *file)

{

	struct file *h_file, *hf;

	struct au_hdintent *hdi, *tmp, *do_free;

	LKTRTrace("%.*s\n", AuDLNPair(hd->hd_dentry));

	h_file = NULL;

	do_free = NULL;

	spin_lock(&hd->hd_lock);

	list_for_each_entry_safe(hdi, tmp, hd->hd_intent_list, hdi_list) {

		hf = hdi->hdi_file[AuIntent_BRANCH];

		if (hdi->hdi_file[AuIntent_AUFS] == file

		    && hf->f_dentry == hd->hd_dentry) {

			h_file = hf;

			do_free = hdi;

			list_del(&hdi->hdi_list);

			break;

		}

	}

	spin_unlock(&hd->hd_lock);

	kfree(do_free);

	return h_file;

}

struct file *au_h_intent(struct dentry *dentry, aufs_bindex_t bindex,

			 struct file *file)

{

	struct file *h_file;

	struct au_hdentry *hd = au_di(dentry)->di_hdentry + bindex;

	LKTRTrace("%.*s, b%d, f %p\n", AuDLNPair(dentry), bindex, file);

	DiMustAnyLock(dentry);

	AuDebugOn(bindex < au_di(dentry)->di_bstart

		  || bindex > au_di(dentry)->di_bend);

	h_file = NULL;

	if (!hd->hd_intent_list || !file)

		return h_file; /* success */

	//AuDebugOn(au_test_wkq(current));

	h_file = au_find_h_intent(hd, file);

	//AuDbgFile(h_file);

	return h_file;

}

static int au_set_h_intent(struct dentry *dentry, aufs_bindex_t bindex,

			   struct file *file, struct file *h_file)

{

	int err;

	struct au_hdentry *hd = au_di(dentry)->di_hdentry + bindex;

	struct au_hdintent *hdi;

	struct file *hf;

	LKTRTrace("%.*s, b%d, f %p\n", AuDLNPair(dentry), bindex, file);

	/* d_revalidate() holds read_lock */

	//DiMustWriteLock(dentry);

	AuDebugOn(bindex < au_di(dentry)->di_bstart

		  || bindex > au_di(dentry)->di_bend

		  || !file

		  || !h_file

		  /* || au_test_wkq(current) */);

	err = -ENOMEM;

	if (hd->hd_intent_list) {

		while (1) {

			hf = au_find_h_intent(hd, file);

			if (!hf)

				break;

			fput(hf);

			AuWarn("freed hfile %.*s b%d left\n",

			       AuDLNPair(dentry), bindex);

		}

	} else {

		spin_lock(&hd->hd_lock);

		if (!hd->hd_intent_list) {

			hd->hd_intent_list

				= kmalloc(sizeof(*hd->hd_intent_list),

					  GFP_ATOMIC);

			if (unlikely(!hd->hd_intent_list)) {

				spin_unlock(&hd->hd_lock);

				goto out;

			}

			INIT_LIST_HEAD(hd->hd_intent_list);

		}

		spin_unlock(&hd->hd_lock);

	}

	hdi = kmalloc(sizeof(*hdi), GFP_TEMPORARY);

	if (unlikely(!hdi))

		goto out;

	err = 0;

	//hdi->hdi_pid = current->pid;

	hdi->hdi_file[AuIntent_AUFS] = file;

	hdi->hdi_file[AuIntent_BRANCH] = h_file;

	spin_lock(&hd->hd_lock);

	list_add(&hdi->hdi_list, hd->hd_intent_list);

	spin_unlock(&hd->hd_lock);

	//AuDbgDentry(dentry);

	//AuDbgFile(h_file);

 out:

	AuTraceErr(err);

	return err;

}

int au_br_nfs_h_intent(struct file *nd_file, struct dentry *dentry,

		       aufs_bindex_t bindex, struct nameidata *nd)

{

	int err;

	AuTraceEnter();

	err = 0;

	if (!nd_file)

		goto out;

	AuDebugOn(!nd);

	err = au_set_h_intent(dentry, bindex, nd->intent.open.file, nd_file);

	//err = -1;

	if (unlikely(err)) {

		fput(nd_file);

		au_set_h_dptr(dentry, bindex, NULL);

		//todo: update bstart and bend?

	}

 out:

	AuTraceErr(err);

	return err;

}

/* ---------------------------------------------------------------------- */

void au_hintent_put(struct au_hdentry *hd, int do_free)

{

	struct au_hdintent *hdi, *tmp;

	struct file *hf;

	if (unlikely(hd->hd_intent_list)) {

		// no spin lock

		list_for_each_entry_safe(hdi, tmp, hd->hd_intent_list,

					 hdi_list) {

			LKTRTrace("hdi %p\n", hdi);

			hf = hdi->hdi_file[AuIntent_BRANCH];

			if (unlikely(hf))

				fput(hf);

			//list_del(&hdi->hdi_list);

			kfree(hdi);

		}

		if (do_free)

			kfree(hd->hd_intent_list);

	}

}

/* ---------------------------------------------------------------------- */

int au_fake_intent(/* struct au_ndsub *save,  */struct nameidata *nd,

		   int perm)

{

	int err;

	LKTRTrace("perm %d\n", perm);

	err = 0;

	nd->intent.open.file = NULL;

	if (nd->flags & LOOKUP_OPEN) {

		err = -ENFILE;

		nd->intent.open.file = get_empty_filp();

		if (unlikely(!nd->intent.open.file)) {

			//nd->intent.open.file = save->intent.open.file;

			goto out;

		}

		err = 0;

		if (!au_br_writable(perm)) {

			nd->intent.open.flags = FMODE_READ

				| au_file_roflags(nd->intent.open.flags);

			nd->flags &= ~LOOKUP_CREATE;

		}

	}

 out:

	AuTraceErr(err);

	return err;

}

int au_hin_after_reval(struct nameidata *nd, struct dentry *dentry,

		       aufs_bindex_t bindex, struct file *file)

{

	int err;

	LKTRTrace("nd %p, %.*s, b%d, f %d\n",

		  nd, AuDLNPair(dentry), bindex, !!file);

	err = 0;

	if ((nd->flags & LOOKUP_OPEN)

	    && nd->intent.open.file

	    && !IS_ERR(nd->intent.open.file)) {

		if (nd->intent.open.file->f_dentry) {

			//AuDbgFile(nd->intent.open.file);

			err = au_set_h_intent(dentry, bindex, file,

					      nd->intent.open.file);

			if (!err)

				nd->intent.open.file = NULL;

		}

		if (unlikely(nd->intent.open.file))

			put_filp(nd->intent.open.file);

	}

	return err;

}

#ifdef CONFIG_AUFS_DLGT

struct au_lookup_hash_args {

	struct dentry **errp;

	struct qstr *name;

	struct dentry *base;

	struct nameidata *nd;

};

static void au_call_lookup_hash(void *args)

{

	struct au_lookup_hash_args *a = args;

	*a->errp = vfsub__lookup_hash(a->name, a->base, a->nd);

}

static struct dentry *

au_lkup_hash_dlgt(struct qstr *this, struct dentry *parent,

		  struct nameidata *nd, unsigned int flags)

{

	struct dentry *dentry;

	int dirperm1;

	dirperm1 = au_ftest_ndx(flags, DIRPERM1);

	if (!dirperm1 && !au_ftest_ndx(flags, DLGT))

		dentry = vfsub__lookup_hash(this, parent, nd);

	else {

		int wkq_err;

		struct au_lookup_hash_args args = {

			.errp	= &dentry,

			.name	= this,

			.base	= parent,

			.nd	= nd

		};

		wkq_err = au_wkq_wait(au_call_lookup_hash, &args,

				      /*dlgt*/!dirperm1);

		if (unlikely(wkq_err))

			dentry = ERR_PTR(wkq_err);

	}

	AuTraceErrPtr(dentry);

	return dentry;

}

#else

static struct dentry *

au_lkup_hash_dlgt(struct qstr *this, struct dentry *parent,

		  struct nameidata *nd, unsigned int flags)

{

	return vfsub__lookup_hash(this, parent, nd);

}

#endif /* CONFIG_AUFS_DLGT */

struct dentry *au_lkup_hash(const char *name, struct dentry *parent,

			    int len, struct au_ndx *ndx)

{

	struct dentry *dentry;

	char *p;

	unsigned long hash;

	struct qstr this;

	unsigned int c;

	struct nameidata tmp_nd, *ndo;

	int err;

	LKTRTrace("%.*s/%.*s\n", AuDLNPair(parent), len, name);

	//todo: export and call __lookup_one_len() in fs/namei.c

	dentry = ERR_PTR(-EACCES);

	this.name = name;

	this.len = len;

	if (unlikely(!len))

		goto out;

	p = (void *)name;

	hash = init_name_hash();

	while (len--) {

		c = *p++;

		if (unlikely(c == '/' || c == '\0'))

			goto out;

		hash = partial_name_hash(c, hash);

	}

	this.hash = end_name_hash(hash);

	ndo = ndx->nd;

	if (ndo) {

		tmp_nd = *ndo;

		err = au_fake_intent(&tmp_nd, ndx->br->br_perm);

		dentry = ERR_PTR(err);

		if (unlikely(err))

			goto out_intent;

	} else

		memset(&tmp_nd, 0, sizeof(tmp_nd));

	tmp_nd.path.dentry = parent;

	tmp_nd.path.mnt = ndx->nfsmnt;

	path_get(&tmp_nd.path);

	dentry = au_lkup_hash_dlgt(&this, parent, &tmp_nd, ndx->flags);

	if (0 && !IS_ERR(dentry))

		AuDbgDentry(dentry);

	if (!IS_ERR(dentry)) {

		/* why negative dentry for a new dir was unhashed? */

		if (unlikely(d_unhashed(dentry)))

			d_rehash(dentry);

		if (tmp_nd.intent.open.file

		    && tmp_nd.intent.open.file->f_dentry) {

			//AuDbgFile(tmp_nd.intent.open.file);

			ndx->nd_file = tmp_nd.intent.open.file;

			tmp_nd.intent.open.file = NULL;

			//au_br_get(ndx->br);

		}

	}

	path_put(&tmp_nd.path);

 out_intent:

	if (tmp_nd.intent.open.file)

		put_filp(tmp_nd.intent.open.file);

 out:

	AuTraceErrPtr(dentry);

	return dentry;

}

/*

 * Copyright (C) 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

 */

/*

 * special handling inode attributes on XFS branch in linux-2.6.24 and later

 *

 * $Id: br_xfs.c,v 1.2 2008/04/21 01:33:00 sfjro Exp $

 */

#include "aufs.h"

/* h_mnt can be NULL, is it safe? */

dev_t au_h_rdev(struct inode *h_inode, struct vfsmount *h_mnt,

		struct dentry *h_dentry)

{

	dev_t rdev;

	int err;

	struct kstat st;

	LKTRTrace("hi%lu\n", h_inode->i_ino);

	if (h_dentry)

		LKTRTrace("%.*s\n", AuDLNPair(h_dentry));

	rdev = h_inode->i_rdev;

	if (!rdev || !au_test_xfs(h_inode->i_sb))

		goto out;

	rdev = 0;

	if (!h_dentry) {

		err = 0;

		h_dentry = d_find_alias(h_inode);

		if (unlikely(!h_dentry))

			goto failure;

		err = PTR_ERR(h_dentry);

		if (IS_ERR(h_dentry)) {

			h_dentry = NULL;

			goto failure;

		}

		LKTRTrace("%.*s\n", AuDLNPair(h_dentry));

	} else

		dget(h_dentry);

	err = vfsub_getattr(h_mnt, h_dentry, &st, /*dlgt*/0);

	dput(h_dentry);

	if (!err) {

		rdev = st.rdev;

		goto out; /* success */

	}

 failure:

	AuIOErr("failed rdev for XFS inode, hi%lu, %d\n", h_inode->i_ino, err);

 out:

	return rdev;

}

/*

 * 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;