[mirror_ubuntu-zesty-kernel.git] / fs / aufs / wbr_policy.c

/*
 * Copyright (C) 2005-2016 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/>.
 */

/*
 * policies for selecting one among multiple writable branches
 */

#include <linux/statfs.h>
#include "aufs.h"

/* subset of cpup_attr() */
static noinline_for_stack
int au_cpdown_attr(struct path *h_path, struct dentry *h_src)
{
	int err, sbits;
	struct iattr ia;
	struct inode *h_isrc;

	h_isrc = d_inode(h_src);
	ia.ia_valid = ATTR_FORCE | ATTR_MODE | ATTR_UID | ATTR_GID;
	ia.ia_mode = h_isrc->i_mode;
	ia.ia_uid = h_isrc->i_uid;
	ia.ia_gid = h_isrc->i_gid;
	sbits = !!(ia.ia_mode & (S_ISUID | S_ISGID));
	au_cpup_attr_flags(d_inode(h_path->dentry), h_isrc->i_flags);
	/* no delegation since it is just created */
	err = vfsub_sio_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_sio_notify_change(h_path, &ia, /*delegated*/NULL);
	}

	return err;
}

#define AuCpdown_PARENT_OPQ	1
#define AuCpdown_WHED		(1 << 1)
#define AuCpdown_MADE_DIR	(1 << 2)
#define AuCpdown_DIROPQ		(1 << 3)
#define au_ftest_cpdown(flags, name)	((flags) & AuCpdown_##name)
#define au_fset_cpdown(flags, name) \
	do { (flags) |= AuCpdown_##name; } while (0)
#define au_fclr_cpdown(flags, name) \
	do { (flags) &= ~AuCpdown_##name; } while (0)

static int au_cpdown_dir_opq(struct dentry *dentry, aufs_bindex_t bdst,
			     unsigned int *flags)
{
	int err;
	struct dentry *opq_dentry;

	opq_dentry = au_diropq_create(dentry, bdst);
	err = PTR_ERR(opq_dentry);
	if (IS_ERR(opq_dentry))
		goto out;
	dput(opq_dentry);
	au_fset_cpdown(*flags, DIROPQ);

out:
	return err;
}

static int au_cpdown_dir_wh(struct dentry *dentry, struct dentry *h_parent,
			    struct inode *dir, aufs_bindex_t bdst)
{
	int err;
	struct path h_path;
	struct au_branch *br;

	br = au_sbr(dentry->d_sb, bdst);
	h_path.dentry = au_wh_lkup(h_parent, &dentry->d_name, br);
	err = PTR_ERR(h_path.dentry);
	if (IS_ERR(h_path.dentry))
		goto out;

	err = 0;
	if (d_is_positive(h_path.dentry)) {
		h_path.mnt = au_br_mnt(br);
		err = au_wh_unlink_dentry(au_h_iptr(dir, bdst), &h_path,
					  dentry);
	}
	dput(h_path.dentry);

out:
	return err;
}

static int au_cpdown_dir(struct dentry *dentry, aufs_bindex_t bdst,
			 struct au_pin *pin,
			 struct dentry *h_parent, void *arg)
{
	int err, rerr;
	aufs_bindex_t bopq, btop;
	struct path h_path;
	struct dentry *parent;
	struct inode *h_dir, *h_inode, *inode, *dir;
	unsigned int *flags = arg;

	btop = au_dbtop(dentry);
	/* dentry is di-locked */
	parent = dget_parent(dentry);
	dir = d_inode(parent);
	h_dir = d_inode(h_parent);
	AuDebugOn(h_dir != au_h_iptr(dir, bdst));
	IMustLock(h_dir);

	err = au_lkup_neg(dentry, bdst, /*wh*/0);
	if (unlikely(err < 0))
		goto out;
	h_path.dentry = au_h_dptr(dentry, bdst);
	h_path.mnt = au_sbr_mnt(dentry->d_sb, bdst);
	err = vfsub_sio_mkdir(au_h_iptr(dir, bdst), &h_path,
			      S_IRWXU | S_IRUGO | S_IXUGO);
	if (unlikely(err))
		goto out_put;
	au_fset_cpdown(*flags, MADE_DIR);

	bopq = au_dbdiropq(dentry);
	au_fclr_cpdown(*flags, WHED);
	au_fclr_cpdown(*flags, DIROPQ);
	if (au_dbwh(dentry) == bdst)
		au_fset_cpdown(*flags, WHED);
	if (!au_ftest_cpdown(*flags, PARENT_OPQ) && bopq <= bdst)
		au_fset_cpdown(*flags, PARENT_OPQ);
	h_inode = d_inode(h_path.dentry);
	inode_lock_nested(h_inode, AuLsc_I_CHILD);
	if (au_ftest_cpdown(*flags, WHED)) {
		err = au_cpdown_dir_opq(dentry, bdst, flags);
		if (unlikely(err)) {
			inode_unlock(h_inode);
			goto out_dir;
		}
	}

	err = au_cpdown_attr(&h_path, au_h_dptr(dentry, btop));
	inode_unlock(h_inode);
	if (unlikely(err))
		goto out_opq;

	if (au_ftest_cpdown(*flags, WHED)) {
		err = au_cpdown_dir_wh(dentry, h_parent, dir, bdst);
		if (unlikely(err))
			goto out_opq;
	}

	inode = d_inode(dentry);
	if (au_ibbot(inode) < bdst)
		au_set_ibbot(inode, bdst);
	au_set_h_iptr(inode, bdst, au_igrab(h_inode),
		      au_hi_flags(inode, /*isdir*/1));
	au_fhsm_wrote(dentry->d_sb, bdst, /*force*/0);
	goto out; /* success */

	/* revert */
out_opq:
	if (au_ftest_cpdown(*flags, DIROPQ)) {
		inode_lock_nested(h_inode, AuLsc_I_CHILD);
		rerr = au_diropq_remove(dentry, bdst);
		inode_unlock(h_inode);
		if (unlikely(rerr)) {
			AuIOErr("failed removing diropq for %pd b%d (%d)\n",
				dentry, bdst, rerr);
			err = -EIO;
			goto out;
		}
	}
out_dir:
	if (au_ftest_cpdown(*flags, MADE_DIR)) {
		rerr = vfsub_sio_rmdir(au_h_iptr(dir, bdst), &h_path);
		if (unlikely(rerr)) {
			AuIOErr("failed removing %pd b%d (%d)\n",
				dentry, bdst, rerr);
			err = -EIO;
		}
	}
out_put:
	au_set_h_dptr(dentry, bdst, NULL);
	if (au_dbbot(dentry) == bdst)
		au_update_dbbot(dentry);
out:
	dput(parent);
	return err;
}

int au_cpdown_dirs(struct dentry *dentry, aufs_bindex_t bdst)
{
	int err;
	unsigned int flags;

	flags = 0;
	err = au_cp_dirs(dentry, bdst, au_cpdown_dir, &flags);

	return err;
}

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

/* policies for create */

int au_wbr_nonopq(struct dentry *dentry, aufs_bindex_t bindex)
{
	int err, i, j, ndentry;
	aufs_bindex_t bopq;
	struct au_dcsub_pages dpages;
	struct au_dpage *dpage;
	struct dentry **dentries, *parent, *d;

	err = au_dpages_init(&dpages, GFP_NOFS);
	if (unlikely(err))
		goto out;
	parent = dget_parent(dentry);
	err = au_dcsub_pages_rev_aufs(&dpages, parent, /*do_include*/0);
	if (unlikely(err))
		goto out_free;

	err = bindex;
	for (i = 0; i < dpages.ndpage; i++) {
		dpage = dpages.dpages + i;
		dentries = dpage->dentries;
		ndentry = dpage->ndentry;
		for (j = 0; j < ndentry; j++) {
			d = dentries[j];
			di_read_lock_parent2(d, !AuLock_IR);
			bopq = au_dbdiropq(d);
			di_read_unlock(d, !AuLock_IR);
			if (bopq >= 0 && bopq < err)
				err = bopq;
		}
	}

out_free:
	dput(parent);
	au_dpages_free(&dpages);
out:
	return err;
}

static int au_wbr_bu(struct super_block *sb, aufs_bindex_t bindex)
{
	for (; bindex >= 0; bindex--)
		if (!au_br_rdonly(au_sbr(sb, bindex)))
			return bindex;
	return -EROFS;
}

/* top down parent */
static int au_wbr_create_tdp(struct dentry *dentry,
			     unsigned int flags __maybe_unused)
{
	int err;
	aufs_bindex_t btop, bindex;
	struct super_block *sb;
	struct dentry *parent, *h_parent;

	sb = dentry->d_sb;
	btop = au_dbtop(dentry);
	err = btop;
	if (!au_br_rdonly(au_sbr(sb, btop)))
		goto out;

	err = -EROFS;
	parent = dget_parent(dentry);
	for (bindex = au_dbtop(parent); bindex < btop; bindex++) {
		h_parent = au_h_dptr(parent, bindex);
		if (!h_parent || d_is_negative(h_parent))
			continue;

		if (!au_br_rdonly(au_sbr(sb, bindex))) {
			err = bindex;
			break;
		}
	}
	dput(parent);

	/* bottom up here */
	if (unlikely(err < 0)) {
		err = au_wbr_bu(sb, btop - 1);
		if (err >= 0)
			err = au_wbr_nonopq(dentry, err);
	}

out:
	AuDbg("b%d\n", err);
	return err;
}

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

/* an exception for the policy other than tdp */
static int au_wbr_create_exp(struct dentry *dentry)
{
	int err;
	aufs_bindex_t bwh, bdiropq;
	struct dentry *parent;

	err = -1;
	bwh = au_dbwh(dentry);
	parent = dget_parent(dentry);
	bdiropq = au_dbdiropq(parent);
	if (bwh >= 0) {
		if (bdiropq >= 0)
			err = min(bdiropq, bwh);
		else
			err = bwh;
		AuDbg("%d\n", err);
	} else if (bdiropq >= 0) {
		err = bdiropq;
		AuDbg("%d\n", err);
	}
	dput(parent);

	if (err >= 0)
		err = au_wbr_nonopq(dentry, err);

	if (err >= 0 && au_br_rdonly(au_sbr(dentry->d_sb, err)))
		err = -1;

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

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

/* round robin */
static int au_wbr_create_init_rr(struct super_block *sb)
{
	int err;

	err = au_wbr_bu(sb, au_sbbot(sb));
	atomic_set(&au_sbi(sb)->si_wbr_rr_next, -err); /* less important */
	/* smp_mb(); */

	AuDbg("b%d\n", err);
	return err;
}

static int au_wbr_create_rr(struct dentry *dentry, unsigned int flags)
{
	int err, nbr;
	unsigned int u;
	aufs_bindex_t bindex, bbot;
	struct super_block *sb;
	atomic_t *next;

	err = au_wbr_create_exp(dentry);
	if (err >= 0)
		goto out;

	sb = dentry->d_sb;
	next = &au_sbi(sb)->si_wbr_rr_next;
	bbot = au_sbbot(sb);
	nbr = bbot + 1;
	for (bindex = 0; bindex <= bbot; bindex++) {
		if (!au_ftest_wbr(flags, DIR)) {
			err = atomic_dec_return(next) + 1;
			/* modulo for 0 is meaningless */
			if (unlikely(!err))
				err = atomic_dec_return(next) + 1;
		} else
			err = atomic_read(next);
		AuDbg("%d\n", err);
		u = err;
		err = u % nbr;
		AuDbg("%d\n", err);
		if (!au_br_rdonly(au_sbr(sb, err)))
			break;
		err = -EROFS;
	}

	if (err >= 0)
		err = au_wbr_nonopq(dentry, err);

out:
	AuDbg("%d\n", err);
	return err;
}

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

/* most free space */
static void au_mfs(struct dentry *dentry, struct dentry *parent)
{
	struct super_block *sb;
	struct au_branch *br;
	struct au_wbr_mfs *mfs;
	struct dentry *h_parent;
	aufs_bindex_t bindex, bbot;
	int err;
	unsigned long long b, bavail;
	struct path h_path;
	/* reduce the stack usage */
	struct kstatfs *st;

	st = kmalloc(sizeof(*st), GFP_NOFS);
	if (unlikely(!st)) {
		AuWarn1("failed updating mfs(%d), ignored\n", -ENOMEM);
		return;
	}

	bavail = 0;
	sb = dentry->d_sb;
	mfs = &au_sbi(sb)->si_wbr_mfs;
	MtxMustLock(&mfs->mfs_lock);
	mfs->mfs_bindex = -EROFS;
	mfs->mfsrr_bytes = 0;
	if (!parent) {
		bindex = 0;
		bbot = au_sbbot(sb);
	} else {
		bindex = au_dbtop(parent);
		bbot = au_dbtaildir(parent);
	}

	for (; bindex <= bbot; bindex++) {
		if (parent) {
			h_parent = au_h_dptr(parent, bindex);
			if (!h_parent || d_is_negative(h_parent))
				continue;
		}
		br = au_sbr(sb, bindex);
		if (au_br_rdonly(br))
			continue;

		/* sb->s_root for NFS is unreliable */
		h_path.mnt = au_br_mnt(br);
		h_path.dentry = h_path.mnt->mnt_root;
		err = vfs_statfs(&h_path, st);
		if (unlikely(err)) {
			AuWarn1("failed statfs, b%d, %d\n", bindex, err);
			continue;
		}

		/* when the available size is equal, select the lower one */
		BUILD_BUG_ON(sizeof(b) < sizeof(st->f_bavail)
			     || sizeof(b) < sizeof(st->f_bsize));
		b = st->f_bavail * st->f_bsize;
		br->br_wbr->wbr_bytes = b;
		if (b >= bavail) {
			bavail = b;
			mfs->mfs_bindex = bindex;
			mfs->mfs_jiffy = jiffies;
		}
	}

	mfs->mfsrr_bytes = bavail;
	AuDbg("b%d\n", mfs->mfs_bindex);
	au_delayed_kfree(st);
}

static int au_wbr_create_mfs(struct dentry *dentry, unsigned int flags)
{
	int err;
	struct dentry *parent;
	struct super_block *sb;
	struct au_wbr_mfs *mfs;

	err = au_wbr_create_exp(dentry);
	if (err >= 0)
		goto out;

	sb = dentry->d_sb;
	parent = NULL;
	if (au_ftest_wbr(flags, PARENT))
		parent = dget_parent(dentry);
	mfs = &au_sbi(sb)->si_wbr_mfs;
	mutex_lock(&mfs->mfs_lock);
	if (time_after(jiffies, mfs->mfs_jiffy + mfs->mfs_expire)
	    || mfs->mfs_bindex < 0
	    || au_br_rdonly(au_sbr(sb, mfs->mfs_bindex)))
		au_mfs(dentry, parent);
	mutex_unlock(&mfs->mfs_lock);
	err = mfs->mfs_bindex;
	dput(parent);

	if (err >= 0)
		err = au_wbr_nonopq(dentry, err);

out:
	AuDbg("b%d\n", err);
	return err;
}

static int au_wbr_create_init_mfs(struct super_block *sb)
{
	struct au_wbr_mfs *mfs;

	mfs = &au_sbi(sb)->si_wbr_mfs;
	mutex_init(&mfs->mfs_lock);
	mfs->mfs_jiffy = 0;
	mfs->mfs_bindex = -EROFS;

	return 0;
}

static int au_wbr_create_fin_mfs(struct super_block *sb __maybe_unused)
{
	mutex_destroy(&au_sbi(sb)->si_wbr_mfs.mfs_lock);
	return 0;
}

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

/* most free space and then round robin */
static int au_wbr_create_mfsrr(struct dentry *dentry, unsigned int flags)
{
	int err;
	struct au_wbr_mfs *mfs;

	err = au_wbr_create_mfs(dentry, flags);
	if (err >= 0) {
		mfs = &au_sbi(dentry->d_sb)->si_wbr_mfs;
		mutex_lock(&mfs->mfs_lock);
		if (mfs->mfsrr_bytes < mfs->mfsrr_watermark)
			err = au_wbr_create_rr(dentry, flags);
		mutex_unlock(&mfs->mfs_lock);
	}

	AuDbg("b%d\n", err);
	return err;
}

static int au_wbr_create_init_mfsrr(struct super_block *sb)
{
	int err;

	au_wbr_create_init_mfs(sb); /* ignore */
	err = au_wbr_create_init_rr(sb);

	return err;
}

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

/* top down parent and most free space */
static int au_wbr_create_pmfs(struct dentry *dentry, unsigned int flags)
{
	int err, e2;
	unsigned long long b;
	aufs_bindex_t bindex, btop, bbot;
	struct super_block *sb;
	struct dentry *parent, *h_parent;
	struct au_branch *br;

	err = au_wbr_create_tdp(dentry, flags);
	if (unlikely(err < 0))
		goto out;
	parent = dget_parent(dentry);
	btop = au_dbtop(parent);
	bbot = au_dbtaildir(parent);
	if (btop == bbot)
		goto out_parent; /* success */

	e2 = au_wbr_create_mfs(dentry, flags);
	if (e2 < 0)
		goto out_parent; /* success */

	/* when the available size is equal, select upper one */
	sb = dentry->d_sb;
	br = au_sbr(sb, err);
	b = br->br_wbr->wbr_bytes;
	AuDbg("b%d, %llu\n", err, b);

	for (bindex = btop; bindex <= bbot; bindex++) {
		h_parent = au_h_dptr(parent, bindex);
		if (!h_parent || d_is_negative(h_parent))
			continue;

		br = au_sbr(sb, bindex);
		if (!au_br_rdonly(br) && br->br_wbr->wbr_bytes > b) {
			b = br->br_wbr->wbr_bytes;
			err = bindex;
			AuDbg("b%d, %llu\n", err, b);
		}
	}

	if (err >= 0)
		err = au_wbr_nonopq(dentry, err);

out_parent:
	dput(parent);
out:
	AuDbg("b%d\n", err);
	return err;
}

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

/*
 * - top down parent
 * - most free space with parent
 * - most free space round-robin regardless parent
 */
static int au_wbr_create_pmfsrr(struct dentry *dentry, unsigned int flags)
{
	int err;
	unsigned long long watermark;
	struct super_block *sb;
	struct au_branch *br;
	struct au_wbr_mfs *mfs;

	err = au_wbr_create_pmfs(dentry, flags | AuWbr_PARENT);
	if (unlikely(err < 0))
		goto out;

	sb = dentry->d_sb;
	br = au_sbr(sb, err);
	mfs = &au_sbi(sb)->si_wbr_mfs;
	mutex_lock(&mfs->mfs_lock);
	watermark = mfs->mfsrr_watermark;
	mutex_unlock(&mfs->mfs_lock);
	if (br->br_wbr->wbr_bytes < watermark)
		/* regardless the parent dir */
		err = au_wbr_create_mfsrr(dentry, flags);

out:
	AuDbg("b%d\n", err);
	return err;
}

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

/* policies for copyup */

/* top down parent */
static int au_wbr_copyup_tdp(struct dentry *dentry)
{
	return au_wbr_create_tdp(dentry, /*flags, anything is ok*/0);
}

/* bottom up parent */
static int au_wbr_copyup_bup(struct dentry *dentry)
{
	int err;
	aufs_bindex_t bindex, btop;
	struct dentry *parent, *h_parent;
	struct super_block *sb;

	err = -EROFS;
	sb = dentry->d_sb;
	parent = dget_parent(dentry);
	btop = au_dbtop(parent);
	for (bindex = au_dbtop(dentry); bindex >= btop; bindex--) {
		h_parent = au_h_dptr(parent, bindex);
		if (!h_parent || d_is_negative(h_parent))
			continue;

		if (!au_br_rdonly(au_sbr(sb, bindex))) {
			err = bindex;
			break;
		}
	}
	dput(parent);

	/* bottom up here */
	if (unlikely(err < 0))
		err = au_wbr_bu(sb, btop - 1);

	AuDbg("b%d\n", err);
	return err;
}

/* bottom up */
int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t btop)
{
	int err;

	err = au_wbr_bu(dentry->d_sb, btop);
	AuDbg("b%d\n", err);
	if (err > btop)
		err = au_wbr_nonopq(dentry, err);

	AuDbg("b%d\n", err);
	return err;
}

static int au_wbr_copyup_bu(struct dentry *dentry)
{
	int err;
	aufs_bindex_t btop;

	btop = au_dbtop(dentry);
	err = au_wbr_do_copyup_bu(dentry, btop);
	return err;
}

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

struct au_wbr_copyup_operations au_wbr_copyup_ops[] = {
	[AuWbrCopyup_TDP] = {
		.copyup	= au_wbr_copyup_tdp
	},
	[AuWbrCopyup_BUP] = {
		.copyup	= au_wbr_copyup_bup
	},
	[AuWbrCopyup_BU] = {
		.copyup	= au_wbr_copyup_bu
	}
};

struct au_wbr_create_operations au_wbr_create_ops[] = {
	[AuWbrCreate_TDP] = {
		.create	= au_wbr_create_tdp
	},
	[AuWbrCreate_RR] = {
		.create	= au_wbr_create_rr,
		.init	= au_wbr_create_init_rr
	},
	[AuWbrCreate_MFS] = {
		.create	= au_wbr_create_mfs,
		.init	= au_wbr_create_init_mfs,
		.fin	= au_wbr_create_fin_mfs
	},
	[AuWbrCreate_MFSV] = {
		.create	= au_wbr_create_mfs,
		.init	= au_wbr_create_init_mfs,
		.fin	= au_wbr_create_fin_mfs
	},
	[AuWbrCreate_MFSRR] = {
		.create	= au_wbr_create_mfsrr,
		.init	= au_wbr_create_init_mfsrr,
		.fin	= au_wbr_create_fin_mfs
	},
	[AuWbrCreate_MFSRRV] = {
		.create	= au_wbr_create_mfsrr,
		.init	= au_wbr_create_init_mfsrr,
		.fin	= au_wbr_create_fin_mfs
	},
	[AuWbrCreate_PMFS] = {
		.create	= au_wbr_create_pmfs,
		.init	= au_wbr_create_init_mfs,
		.fin	= au_wbr_create_fin_mfs
	},
	[AuWbrCreate_PMFSV] = {
		.create	= au_wbr_create_pmfs,
		.init	= au_wbr_create_init_mfs,
		.fin	= au_wbr_create_fin_mfs
	},
	[AuWbrCreate_PMFSRR] = {
		.create	= au_wbr_create_pmfsrr,
		.init	= au_wbr_create_init_mfsrr,
		.fin	= au_wbr_create_fin_mfs
	},
	[AuWbrCreate_PMFSRRV] = {
		.create	= au_wbr_create_pmfsrr,
		.init	= au_wbr_create_init_mfsrr,
		.fin	= au_wbr_create_fin_mfs
	}
};
Commit	Line	Data
5b88fdd9 SF	1	/*
	2	* Copyright (C) 2005-2016 Junjiro R. Okajima
	3	*
	4	* This program, aufs is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	16	*/
	17
	18	/*
	19	* policies for selecting one among multiple writable branches
	20	*/
	21
	22	#include <linux/statfs.h>
	23	#include "aufs.h"
	24
	25	/* subset of cpup_attr() */
	26	static noinline_for_stack
	27	int au_cpdown_attr(struct path h_path, struct dentry h_src)
	28	{
	29	int err, sbits;
	30	struct iattr ia;
	31	struct inode *h_isrc;
	32
	33	h_isrc = d_inode(h_src);
	34	ia.ia_valid = ATTR_FORCE \| ATTR_MODE \| ATTR_UID \| ATTR_GID;
	35	ia.ia_mode = h_isrc->i_mode;
	36	ia.ia_uid = h_isrc->i_uid;
	37	ia.ia_gid = h_isrc->i_gid;
	38	sbits = !!(ia.ia_mode & (S_ISUID \| S_ISGID));
	39	au_cpup_attr_flags(d_inode(h_path->dentry), h_isrc->i_flags);
	40	/* no delegation since it is just created */
	41	err = vfsub_sio_notify_change(h_path, &ia, /delegated/NULL);
	42
	43	/* is this nfs only? */
	44	if (!err && sbits && au_test_nfs(h_path->dentry->d_sb)) {
	45	ia.ia_valid = ATTR_FORCE \| ATTR_MODE;
	46	ia.ia_mode = h_isrc->i_mode;
	47	err = vfsub_sio_notify_change(h_path, &ia, /delegated/NULL);
	48	}
	49
	50	return err;
	51	}
	52
	53	#define AuCpdown_PARENT_OPQ 1
	54	#define AuCpdown_WHED (1 << 1)
	55	#define AuCpdown_MADE_DIR (1 << 2)
	56	#define AuCpdown_DIROPQ (1 << 3)
	57	#define au_ftest_cpdown(flags, name) ((flags) & AuCpdown_##name)
	58	#define au_fset_cpdown(flags, name) \
	59	do { (flags) \|= AuCpdown_##name; } while (0)
	60	#define au_fclr_cpdown(flags, name) \
	61	do { (flags) &= ~AuCpdown_##name; } while (0)
	62
	63	static int au_cpdown_dir_opq(struct dentry *dentry, aufs_bindex_t bdst,
	64	unsigned int *flags)
65	{
66	int err;
67	struct dentry *opq_dentry;
68
69	opq_dentry = au_diropq_create(dentry, bdst);
70	err = PTR_ERR(opq_dentry);
71	if (IS_ERR(opq_dentry))
72	goto out;
73	dput(opq_dentry);
74	au_fset_cpdown(*flags, DIROPQ);
75
76	out:
77	return err;
78	}
79
80	static int au_cpdown_dir_wh(struct dentry dentry, struct dentry h_parent,
81	struct inode *dir, aufs_bindex_t bdst)
82	{
83	int err;
84	struct path h_path;
85	struct au_branch *br;
86
87	br = au_sbr(dentry->d_sb, bdst);
88	h_path.dentry = au_wh_lkup(h_parent, &dentry->d_name, br);
89	err = PTR_ERR(h_path.dentry);
90	if (IS_ERR(h_path.dentry))
91	goto out;
92
93	err = 0;
94	if (d_is_positive(h_path.dentry)) {
95	h_path.mnt = au_br_mnt(br);
96	err = au_wh_unlink_dentry(au_h_iptr(dir, bdst), &h_path,
97	dentry);
98	}
99	dput(h_path.dentry);
100
101	out:
102	return err;
103	}
104
105	static int au_cpdown_dir(struct dentry *dentry, aufs_bindex_t bdst,
106	struct au_pin *pin,
107	struct dentry h_parent, void arg)
108	{
109	int err, rerr;
110	aufs_bindex_t bopq, btop;
111	struct path h_path;
112	struct dentry *parent;
113	struct inode h_dir, h_inode, inode, dir;
114	unsigned int *flags = arg;
115
116	btop = au_dbtop(dentry);
117	/* dentry is di-locked */
118	parent = dget_parent(dentry);
119	dir = d_inode(parent);
120	h_dir = d_inode(h_parent);
121	AuDebugOn(h_dir != au_h_iptr(dir, bdst));
122	IMustLock(h_dir);
123
124	err = au_lkup_neg(dentry, bdst, /wh/0);
125	if (unlikely(err < 0))
126	goto out;
127	h_path.dentry = au_h_dptr(dentry, bdst);
128	h_path.mnt = au_sbr_mnt(dentry->d_sb, bdst);
129	err = vfsub_sio_mkdir(au_h_iptr(dir, bdst), &h_path,
130	S_IRWXU \| S_IRUGO \| S_IXUGO);
131	if (unlikely(err))
132	goto out_put;
133	au_fset_cpdown(*flags, MADE_DIR);
134
135	bopq = au_dbdiropq(dentry);
136	au_fclr_cpdown(*flags, WHED);
137	au_fclr_cpdown(*flags, DIROPQ);
138	if (au_dbwh(dentry) == bdst)
139	au_fset_cpdown(*flags, WHED);
140	if (!au_ftest_cpdown(*flags, PARENT_OPQ) && bopq <= bdst)
141	au_fset_cpdown(*flags, PARENT_OPQ);
142	h_inode = d_inode(h_path.dentry);
143	inode_lock_nested(h_inode, AuLsc_I_CHILD);
144	if (au_ftest_cpdown(*flags, WHED)) {
145	err = au_cpdown_dir_opq(dentry, bdst, flags);
146	if (unlikely(err)) {
147	inode_unlock(h_inode);
148	goto out_dir;
149	}
150	}
151
152	err = au_cpdown_attr(&h_path, au_h_dptr(dentry, btop));
153	inode_unlock(h_inode);
154	if (unlikely(err))
155	goto out_opq;
156
157	if (au_ftest_cpdown(*flags, WHED)) {
158	err = au_cpdown_dir_wh(dentry, h_parent, dir, bdst);
159	if (unlikely(err))
160	goto out_opq;
161	}
162
163	inode = d_inode(dentry);
164	if (au_ibbot(inode) < bdst)
165	au_set_ibbot(inode, bdst);
166	au_set_h_iptr(inode, bdst, au_igrab(h_inode),
167	au_hi_flags(inode, /isdir/1));
168	au_fhsm_wrote(dentry->d_sb, bdst, /force/0);
169	goto out; /* success */
170
171	/* revert */
172	out_opq:
173	if (au_ftest_cpdown(*flags, DIROPQ)) {
174	inode_lock_nested(h_inode, AuLsc_I_CHILD);
175	rerr = au_diropq_remove(dentry, bdst);
176	inode_unlock(h_inode);
177	if (unlikely(rerr)) {
178	AuIOErr("failed removing diropq for %pd b%d (%d)\n",
179	dentry, bdst, rerr);
180	err = -EIO;
181	goto out;
182	}
183	}
184	out_dir:
185	if (au_ftest_cpdown(*flags, MADE_DIR)) {
186	rerr = vfsub_sio_rmdir(au_h_iptr(dir, bdst), &h_path);
187	if (unlikely(rerr)) {
188	AuIOErr("failed removing %pd b%d (%d)\n",
189	dentry, bdst, rerr);
190	err = -EIO;
191	}
192	}
193	out_put:
194	au_set_h_dptr(dentry, bdst, NULL);
195	if (au_dbbot(dentry) == bdst)
196	au_update_dbbot(dentry);
197	out:
198	dput(parent);
199	return err;
200	}
201
202	int au_cpdown_dirs(struct dentry *dentry, aufs_bindex_t bdst)
203	{
204	int err;
205	unsigned int flags;
206
207	flags = 0;
208	err = au_cp_dirs(dentry, bdst, au_cpdown_dir, &flags);
209
210	return err;
211	}
212
213	/* ---------------------------------------------------------------------- */
214
215	/* policies for create */
216
217	int au_wbr_nonopq(struct dentry *dentry, aufs_bindex_t bindex)
218	{
219	int err, i, j, ndentry;
220	aufs_bindex_t bopq;
221	struct au_dcsub_pages dpages;
222	struct au_dpage *dpage;
223	struct dentry *dentries, parent, *d;
224
225	err = au_dpages_init(&dpages, GFP_NOFS);
226	if (unlikely(err))
227	goto out;
228	parent = dget_parent(dentry);
229	err = au_dcsub_pages_rev_aufs(&dpages, parent, /do_include/0);
230	if (unlikely(err))
231	goto out_free;
232
233	err = bindex;
234	for (i = 0; i < dpages.ndpage; i++) {
235	dpage = dpages.dpages + i;
236	dentries = dpage->dentries;
237	ndentry = dpage->ndentry;
238	for (j = 0; j < ndentry; j++) {
239	d = dentries[j];
240	di_read_lock_parent2(d, !AuLock_IR);
241	bopq = au_dbdiropq(d);
242	di_read_unlock(d, !AuLock_IR);
243	if (bopq >= 0 && bopq < err)
244	err = bopq;
245	}
246	}
247
248	out_free:
249	dput(parent);
250	au_dpages_free(&dpages);
251	out:
252	return err;
253	}
254
255	static int au_wbr_bu(struct super_block *sb, aufs_bindex_t bindex)
256	{
257	for (; bindex >= 0; bindex--)
258	if (!au_br_rdonly(au_sbr(sb, bindex)))
259	return bindex;
260	return -EROFS;
261	}
262
263	/* top down parent */
264	static int au_wbr_create_tdp(struct dentry *dentry,
265	unsigned int flags __maybe_unused)
266	{
267	int err;
268	aufs_bindex_t btop, bindex;
269	struct super_block *sb;
270	struct dentry parent, h_parent;
271
272	sb = dentry->d_sb;
273	btop = au_dbtop(dentry);
274	err = btop;
275	if (!au_br_rdonly(au_sbr(sb, btop)))
276	goto out;
277
278	err = -EROFS;
279	parent = dget_parent(dentry);
280	for (bindex = au_dbtop(parent); bindex < btop; bindex++) {
281	h_parent = au_h_dptr(parent, bindex);
282	if (!h_parent \|\| d_is_negative(h_parent))
283	continue;
284
285	if (!au_br_rdonly(au_sbr(sb, bindex))) {
286	err = bindex;
287	break;
288	}
289	}
290	dput(parent);
291
292	/* bottom up here */
293	if (unlikely(err < 0)) {
294	err = au_wbr_bu(sb, btop - 1);
295	if (err >= 0)
296	err = au_wbr_nonopq(dentry, err);
297	}
298
299	out:
300	AuDbg("b%d\n", err);
301	return err;
302	}
303
304	/* ---------------------------------------------------------------------- */
305
306	/* an exception for the policy other than tdp */
307	static int au_wbr_create_exp(struct dentry *dentry)
308	{
309	int err;
310	aufs_bindex_t bwh, bdiropq;
311	struct dentry *parent;
312
313	err = -1;
314	bwh = au_dbwh(dentry);
315	parent = dget_parent(dentry);
316	bdiropq = au_dbdiropq(parent);
317	if (bwh >= 0) {
318	if (bdiropq >= 0)
319	err = min(bdiropq, bwh);
320	else
321	err = bwh;
322	AuDbg("%d\n", err);
323	} else if (bdiropq >= 0) {
324	err = bdiropq;
325	AuDbg("%d\n", err);
326	}
327	dput(parent);
328
329	if (err >= 0)
330	err = au_wbr_nonopq(dentry, err);
331
332	if (err >= 0 && au_br_rdonly(au_sbr(dentry->d_sb, err)))
333	err = -1;
334
335	AuDbg("%d\n", err);
336	return err;
337	}
338
339	/* ---------------------------------------------------------------------- */
340
341	/* round robin */
342	static int au_wbr_create_init_rr(struct super_block *sb)
343	{
344	int err;
345
346	err = au_wbr_bu(sb, au_sbbot(sb));
347	atomic_set(&au_sbi(sb)->si_wbr_rr_next, -err); /* less important */
348	/* smp_mb(); */
349
350	AuDbg("b%d\n", err);
351	return err;
352	}
353
354	static int au_wbr_create_rr(struct dentry *dentry, unsigned int flags)
355	{
356	int err, nbr;
357	unsigned int u;
358	aufs_bindex_t bindex, bbot;
359	struct super_block *sb;
360	atomic_t *next;
361
362	err = au_wbr_create_exp(dentry);
363	if (err >= 0)
364	goto out;
365
366	sb = dentry->d_sb;
367	next = &au_sbi(sb)->si_wbr_rr_next;
368	bbot = au_sbbot(sb);
369	nbr = bbot + 1;
370	for (bindex = 0; bindex <= bbot; bindex++) {
371	if (!au_ftest_wbr(flags, DIR)) {
372	err = atomic_dec_return(next) + 1;
373	/* modulo for 0 is meaningless */
374	if (unlikely(!err))
375	err = atomic_dec_return(next) + 1;
376	} else
377	err = atomic_read(next);
378	AuDbg("%d\n", err);
379	u = err;
380	err = u % nbr;
381	AuDbg("%d\n", err);
382	if (!au_br_rdonly(au_sbr(sb, err)))
383	break;
384	err = -EROFS;
385	}
386
387	if (err >= 0)
388	err = au_wbr_nonopq(dentry, err);
389
390	out:
391	AuDbg("%d\n", err);
392	return err;
393	}
394
395	/* ---------------------------------------------------------------------- */
396
397	/* most free space */
398	static void au_mfs(struct dentry dentry, struct dentry parent)
399	{
400	struct super_block *sb;
401	struct au_branch *br;
402	struct au_wbr_mfs *mfs;
403	struct dentry *h_parent;
404	aufs_bindex_t bindex, bbot;
405	int err;
406	unsigned long long b, bavail;
407	struct path h_path;
408	/* reduce the stack usage */
409	struct kstatfs *st;
410
411	st = kmalloc(sizeof(*st), GFP_NOFS);
412	if (unlikely(!st)) {
413	AuWarn1("failed updating mfs(%d), ignored\n", -ENOMEM);
414	return;
415	}
416
417	bavail = 0;
418	sb = dentry->d_sb;
419	mfs = &au_sbi(sb)->si_wbr_mfs;
420	MtxMustLock(&mfs->mfs_lock);
421	mfs->mfs_bindex = -EROFS;
422	mfs->mfsrr_bytes = 0;
423	if (!parent) {
424	bindex = 0;
425	bbot = au_sbbot(sb);
426	} else {
427	bindex = au_dbtop(parent);
428	bbot = au_dbtaildir(parent);
429	}
430
431	for (; bindex <= bbot; bindex++) {
432	if (parent) {
433	h_parent = au_h_dptr(parent, bindex);
434	if (!h_parent \|\| d_is_negative(h_parent))
435	continue;
436	}
437	br = au_sbr(sb, bindex);
438	if (au_br_rdonly(br))
439	continue;
440
441	/* sb->s_root for NFS is unreliable */
442	h_path.mnt = au_br_mnt(br);
443	h_path.dentry = h_path.mnt->mnt_root;
444	err = vfs_statfs(&h_path, st);
445	if (unlikely(err)) {
446	AuWarn1("failed statfs, b%d, %d\n", bindex, err);
447	continue;
448	}
449
450	/* when the available size is equal, select the lower one */
451	BUILD_BUG_ON(sizeof(b) < sizeof(st->f_bavail)
452	\|\| sizeof(b) < sizeof(st->f_bsize));
453	b = st->f_bavail * st->f_bsize;
454	br->br_wbr->wbr_bytes = b;
455	if (b >= bavail) {
456	bavail = b;
457	mfs->mfs_bindex = bindex;
458	mfs->mfs_jiffy = jiffies;
459	}
460	}
461
462	mfs->mfsrr_bytes = bavail;
463	AuDbg("b%d\n", mfs->mfs_bindex);
464	au_delayed_kfree(st);
465	}
466
467	static int au_wbr_create_mfs(struct dentry *dentry, unsigned int flags)
468	{
469	int err;
470	struct dentry *parent;
471	struct super_block *sb;
472	struct au_wbr_mfs *mfs;
473
474	err = au_wbr_create_exp(dentry);
475	if (err >= 0)
476	goto out;
477
478	sb = dentry->d_sb;
479	parent = NULL;
480	if (au_ftest_wbr(flags, PARENT))
481	parent = dget_parent(dentry);
482	mfs = &au_sbi(sb)->si_wbr_mfs;
483	mutex_lock(&mfs->mfs_lock);
484	if (time_after(jiffies, mfs->mfs_jiffy + mfs->mfs_expire)
485	\|\| mfs->mfs_bindex < 0
486	\|\| au_br_rdonly(au_sbr(sb, mfs->mfs_bindex)))
487	au_mfs(dentry, parent);
488	mutex_unlock(&mfs->mfs_lock);
489	err = mfs->mfs_bindex;
490	dput(parent);
491
492	if (err >= 0)
493	err = au_wbr_nonopq(dentry, err);
494
495	out:
496	AuDbg("b%d\n", err);
497	return err;
498	}
499
500	static int au_wbr_create_init_mfs(struct super_block *sb)
501	{
502	struct au_wbr_mfs *mfs;
503
504	mfs = &au_sbi(sb)->si_wbr_mfs;
505	mutex_init(&mfs->mfs_lock);
506	mfs->mfs_jiffy = 0;
507	mfs->mfs_bindex = -EROFS;
508
509	return 0;
510	}
511
512	static int au_wbr_create_fin_mfs(struct super_block *sb __maybe_unused)
513	{
514	mutex_destroy(&au_sbi(sb)->si_wbr_mfs.mfs_lock);
515	return 0;
516	}
517
518	/* ---------------------------------------------------------------------- */
519
520	/* most free space and then round robin */
521	static int au_wbr_create_mfsrr(struct dentry *dentry, unsigned int flags)
522	{
523	int err;
524	struct au_wbr_mfs *mfs;
525
526	err = au_wbr_create_mfs(dentry, flags);
527	if (err >= 0) {
528	mfs = &au_sbi(dentry->d_sb)->si_wbr_mfs;
529	mutex_lock(&mfs->mfs_lock);
530	if (mfs->mfsrr_bytes < mfs->mfsrr_watermark)
531	err = au_wbr_create_rr(dentry, flags);
532	mutex_unlock(&mfs->mfs_lock);
533	}
534
535	AuDbg("b%d\n", err);
536	return err;
537	}
538
539	static int au_wbr_create_init_mfsrr(struct super_block *sb)
540	{
541	int err;
542
543	au_wbr_create_init_mfs(sb); /* ignore */
544	err = au_wbr_create_init_rr(sb);
545
546	return err;
547	}
548
549	/* ---------------------------------------------------------------------- */
550
551	/* top down parent and most free space */
552	static int au_wbr_create_pmfs(struct dentry *dentry, unsigned int flags)
553	{
554	int err, e2;
555	unsigned long long b;
556	aufs_bindex_t bindex, btop, bbot;
557	struct super_block *sb;
558	struct dentry parent, h_parent;
559	struct au_branch *br;
560
561	err = au_wbr_create_tdp(dentry, flags);
562	if (unlikely(err < 0))
563	goto out;
564	parent = dget_parent(dentry);
565	btop = au_dbtop(parent);
566	bbot = au_dbtaildir(parent);
567	if (btop == bbot)
568	goto out_parent; /* success */
569
570	e2 = au_wbr_create_mfs(dentry, flags);
571	if (e2 < 0)
572	goto out_parent; /* success */
573
574	/* when the available size is equal, select upper one */
575	sb = dentry->d_sb;
576	br = au_sbr(sb, err);
577	b = br->br_wbr->wbr_bytes;
578	AuDbg("b%d, %llu\n", err, b);
579
580	for (bindex = btop; bindex <= bbot; bindex++) {
581	h_parent = au_h_dptr(parent, bindex);
582	if (!h_parent \|\| d_is_negative(h_parent))
583	continue;
584
585	br = au_sbr(sb, bindex);
586	if (!au_br_rdonly(br) && br->br_wbr->wbr_bytes > b) {
587	b = br->br_wbr->wbr_bytes;
588	err = bindex;
589	AuDbg("b%d, %llu\n", err, b);
590	}
591	}
592
593	if (err >= 0)
594	err = au_wbr_nonopq(dentry, err);
595
596	out_parent:
597	dput(parent);
598	out:
599	AuDbg("b%d\n", err);
600	return err;
601	}
602
603	/* ---------------------------------------------------------------------- */
604
605	/*
606	* - top down parent
607	* - most free space with parent
608	* - most free space round-robin regardless parent
609	*/
610	static int au_wbr_create_pmfsrr(struct dentry *dentry, unsigned int flags)
611	{
612	int err;
613	unsigned long long watermark;
614	struct super_block *sb;
615	struct au_branch *br;
616	struct au_wbr_mfs *mfs;
617
618	err = au_wbr_create_pmfs(dentry, flags \| AuWbr_PARENT);
619	if (unlikely(err < 0))
620	goto out;
621
622	sb = dentry->d_sb;
623	br = au_sbr(sb, err);
624	mfs = &au_sbi(sb)->si_wbr_mfs;
625	mutex_lock(&mfs->mfs_lock);
626	watermark = mfs->mfsrr_watermark;
627	mutex_unlock(&mfs->mfs_lock);
628	if (br->br_wbr->wbr_bytes < watermark)
629	/* regardless the parent dir */
630	err = au_wbr_create_mfsrr(dentry, flags);
631
632	out:
633	AuDbg("b%d\n", err);
634	return err;
635	}
636
637	/* ---------------------------------------------------------------------- */
638
639	/* policies for copyup */
640
641	/* top down parent */
642	static int au_wbr_copyup_tdp(struct dentry *dentry)
643	{
644	return au_wbr_create_tdp(dentry, /flags, anything is ok/0);
645	}
646
647	/* bottom up parent */
648	static int au_wbr_copyup_bup(struct dentry *dentry)
649	{
650	int err;
651	aufs_bindex_t bindex, btop;
652	struct dentry parent, h_parent;
653	struct super_block *sb;
654
655	err = -EROFS;
656	sb = dentry->d_sb;
657	parent = dget_parent(dentry);
658	btop = au_dbtop(parent);
659	for (bindex = au_dbtop(dentry); bindex >= btop; bindex--) {
660	h_parent = au_h_dptr(parent, bindex);
661	if (!h_parent \|\| d_is_negative(h_parent))
662	continue;
663
664	if (!au_br_rdonly(au_sbr(sb, bindex))) {
665	err = bindex;
666	break;
667	}
668	}
669	dput(parent);
670
671	/* bottom up here */
672	if (unlikely(err < 0))
673	err = au_wbr_bu(sb, btop - 1);
674
675	AuDbg("b%d\n", err);
676	return err;
677	}
678
679	/* bottom up */
680	int au_wbr_do_copyup_bu(struct dentry *dentry, aufs_bindex_t btop)
681	{
682	int err;
683
684	err = au_wbr_bu(dentry->d_sb, btop);
685	AuDbg("b%d\n", err);
686	if (err > btop)
687	err = au_wbr_nonopq(dentry, err);
688
689	AuDbg("b%d\n", err);
690	return err;
691	}
692
693	static int au_wbr_copyup_bu(struct dentry *dentry)
694	{
695	int err;
696	aufs_bindex_t btop;
697
698	btop = au_dbtop(dentry);
699	err = au_wbr_do_copyup_bu(dentry, btop);
700	return err;
701	}
702
703	/* ---------------------------------------------------------------------- */
704
705	struct au_wbr_copyup_operations au_wbr_copyup_ops[] = {
706	[AuWbrCopyup_TDP] = {
707	.copyup = au_wbr_copyup_tdp
708	},
709	[AuWbrCopyup_BUP] = {
710	.copyup = au_wbr_copyup_bup
711	},
712	[AuWbrCopyup_BU] = {
713	.copyup = au_wbr_copyup_bu
714	}
715	};
716
717	struct au_wbr_create_operations au_wbr_create_ops[] = {
718	[AuWbrCreate_TDP] = {
719	.create = au_wbr_create_tdp
720	},
721	[AuWbrCreate_RR] = {
722	.create = au_wbr_create_rr,
723	.init = au_wbr_create_init_rr
724	},
725	[AuWbrCreate_MFS] = {
726	.create = au_wbr_create_mfs,
727	.init = au_wbr_create_init_mfs,
728	.fin = au_wbr_create_fin_mfs
729	},
730	[AuWbrCreate_MFSV] = {
731	.create = au_wbr_create_mfs,
732	.init = au_wbr_create_init_mfs,
733	.fin = au_wbr_create_fin_mfs
734	},
735	[AuWbrCreate_MFSRR] = {
736	.create = au_wbr_create_mfsrr,
737	.init = au_wbr_create_init_mfsrr,
738	.fin = au_wbr_create_fin_mfs
739	},
740	[AuWbrCreate_MFSRRV] = {
741	.create = au_wbr_create_mfsrr,
742	.init = au_wbr_create_init_mfsrr,
743	.fin = au_wbr_create_fin_mfs
744	},
745	[AuWbrCreate_PMFS] = {
746	.create = au_wbr_create_pmfs,
747	.init = au_wbr_create_init_mfs,
748	.fin = au_wbr_create_fin_mfs
749	},
750	[AuWbrCreate_PMFSV] = {
751	.create = au_wbr_create_pmfs,
752	.init = au_wbr_create_init_mfs,
753	.fin = au_wbr_create_fin_mfs
754	},
755	[AuWbrCreate_PMFSRR] = {
756	.create = au_wbr_create_pmfsrr,
757	.init = au_wbr_create_init_mfsrr,
758	.fin = au_wbr_create_fin_mfs
759	},
760	[AuWbrCreate_PMFSRRV] = {
761	.create = au_wbr_create_pmfsrr,
762	.init = au_wbr_create_init_mfsrr,
763	.fin = au_wbr_create_fin_mfs
764	}
765	};