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

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

/*
 * dynamically customizable operations for regular files
 */

#include "aufs.h"

#define DyPrSym(key)	AuDbgSym(key->dk_op.dy_hop)

/*
 * How large will these lists be?
 * Usually just a few elements, 20-30 at most for each, I guess.
 */
static struct au_sphlhead dynop[AuDyLast];

static struct au_dykey *dy_gfind_get(struct au_sphlhead *sphl, const void *h_op)
{
	struct au_dykey *key, *tmp;
	struct hlist_head *head;

	key = NULL;
	head = &sphl->head;
	rcu_read_lock();
	hlist_for_each_entry_rcu(tmp, head, dk_hnode)
		if (tmp->dk_op.dy_hop == h_op) {
			key = tmp;
			kref_get(&key->dk_kref);
			break;
		}
	rcu_read_unlock();

	return key;
}

static struct au_dykey *dy_bradd(struct au_branch *br, struct au_dykey *key)
{
	struct au_dykey **k, *found;
	const void *h_op = key->dk_op.dy_hop;
	int i;

	found = NULL;
	k = br->br_dykey;
	for (i = 0; i < AuBrDynOp; i++)
		if (k[i]) {
			if (k[i]->dk_op.dy_hop == h_op) {
				found = k[i];
				break;
			}
		} else
			break;
	if (!found) {
		spin_lock(&br->br_dykey_lock);
		for (; i < AuBrDynOp; i++)
			if (k[i]) {
				if (k[i]->dk_op.dy_hop == h_op) {
					found = k[i];
					break;
				}
			} else {
				k[i] = key;
				break;
			}
		spin_unlock(&br->br_dykey_lock);
		BUG_ON(i == AuBrDynOp); /* expand the array */
	}

	return found;
}

/* kref_get() if @key is already added */
static struct au_dykey *dy_gadd(struct au_sphlhead *sphl, struct au_dykey *key)
{
	struct au_dykey *tmp, *found;
	struct hlist_head *head;
	const void *h_op = key->dk_op.dy_hop;

	found = NULL;
	head = &sphl->head;
	spin_lock(&sphl->spin);
	hlist_for_each_entry(tmp, head, dk_hnode)
		if (tmp->dk_op.dy_hop == h_op) {
			kref_get(&tmp->dk_kref);
			found = tmp;
			break;
		}
	if (!found)
		hlist_add_head_rcu(&key->dk_hnode, head);
	spin_unlock(&sphl->spin);

	if (!found)
		DyPrSym(key);
	return found;
}

static void dy_free_rcu(struct rcu_head *rcu)
{
	struct au_dykey *key;

	key = container_of(rcu, struct au_dykey, dk_rcu);
	DyPrSym(key);
	kfree(key);	/* not delayed */
}

static void dy_free(struct kref *kref)
{
	struct au_dykey *key;
	struct au_sphlhead *sphl;

	key = container_of(kref, struct au_dykey, dk_kref);
	sphl = dynop + key->dk_op.dy_type;
	au_sphl_del_rcu(&key->dk_hnode, sphl);
	call_rcu(&key->dk_rcu, dy_free_rcu);
}

void au_dy_put(struct au_dykey *key)
{
	kref_put(&key->dk_kref, dy_free);
}

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

#define DyDbgSize(cnt, op)	AuDebugOn(cnt != sizeof(op)/sizeof(void *))

#ifdef CONFIG_AUFS_DEBUG
#define DyDbgDeclare(cnt)	unsigned int cnt = 0
#define DyDbgInc(cnt)		do { cnt++; } while (0)
#else
#define DyDbgDeclare(cnt)	do {} while (0)
#define DyDbgInc(cnt)		do {} while (0)
#endif

#define DySet(func, dst, src, h_op, h_sb) do {				\
	DyDbgInc(cnt);							\
	if (h_op->func) {						\
		if (src.func)						\
			dst.func = src.func;				\
		else							\
			AuDbg("%s %s\n", au_sbtype(h_sb), #func);	\
	}								\
} while (0)

#define DySetForce(func, dst, src) do {		\
	AuDebugOn(!src.func);			\
	DyDbgInc(cnt);				\
	dst.func = src.func;			\
} while (0)

#define DySetAop(func) \
	DySet(func, dyaop->da_op, aufs_aop, h_aop, h_sb)
#define DySetAopForce(func) \
	DySetForce(func, dyaop->da_op, aufs_aop)

static void dy_aop(struct au_dykey *key, const void *h_op,
		   struct super_block *h_sb __maybe_unused)
{
	struct au_dyaop *dyaop = (void *)key;
	const struct address_space_operations *h_aop = h_op;
	DyDbgDeclare(cnt);

	AuDbg("%s\n", au_sbtype(h_sb));

	DySetAop(writepage);
	DySetAopForce(readpage);	/* force */
	DySetAop(writepages);
	DySetAop(set_page_dirty);
	DySetAop(readpages);
	DySetAop(write_begin);
	DySetAop(write_end);
	DySetAop(bmap);
	DySetAop(invalidatepage);
	DySetAop(releasepage);
	DySetAop(freepage);
	/* this one will be changed according to an aufs mount option */
	DySetAop(direct_IO);
	DySetAop(migratepage);
	DySetAop(isolate_page);
	DySetAop(putback_page);
	DySetAop(launder_page);
	DySetAop(is_partially_uptodate);
	DySetAop(is_dirty_writeback);
	DySetAop(error_remove_page);
	DySetAop(swap_activate);
	DySetAop(swap_deactivate);

	DyDbgSize(cnt, *h_aop);
}

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

static void dy_bug(struct kref *kref)
{
	BUG();
}

static struct au_dykey *dy_get(struct au_dynop *op, struct au_branch *br)
{
	struct au_dykey *key, *old;
	struct au_sphlhead *sphl;
	struct op {
		unsigned int sz;
		void (*set)(struct au_dykey *key, const void *h_op,
			    struct super_block *h_sb __maybe_unused);
	};
	static const struct op a[] = {
		[AuDy_AOP] = {
			.sz	= sizeof(struct au_dyaop),
			.set	= dy_aop
		}
	};
	const struct op *p;

	sphl = dynop + op->dy_type;
	key = dy_gfind_get(sphl, op->dy_hop);
	if (key)
		goto out_add; /* success */

	p = a + op->dy_type;
	key = kzalloc(p->sz, GFP_NOFS);
	if (unlikely(!key)) {
		key = ERR_PTR(-ENOMEM);
		goto out;
	}

	key->dk_op.dy_hop = op->dy_hop;
	kref_init(&key->dk_kref);
	p->set(key, op->dy_hop, au_br_sb(br));
	old = dy_gadd(sphl, key);
	if (old) {
		au_delayed_kfree(key);
		key = old;
	}

out_add:
	old = dy_bradd(br, key);
	if (old)
		/* its ref-count should never be zero here */
		kref_put(&key->dk_kref, dy_bug);
out:
	return key;
}

/* ---------------------------------------------------------------------- */
/*
 * Aufs prohibits O_DIRECT by defaut even if the branch supports it.
 * This behaviour is necessary to return an error from open(O_DIRECT) instead
 * of the succeeding I/O. The dio mount option enables O_DIRECT and makes
 * open(O_DIRECT) always succeed, but the succeeding I/O may return an error.
 * See the aufs manual in detail.
 */
static void dy_adx(struct au_dyaop *dyaop, int do_dx)
{
	if (!do_dx)
		dyaop->da_op.direct_IO = NULL;
	else
		dyaop->da_op.direct_IO = aufs_aop.direct_IO;
}

static struct au_dyaop *dy_aget(struct au_branch *br,
				const struct address_space_operations *h_aop,
				int do_dx)
{
	struct au_dyaop *dyaop;
	struct au_dynop op;

	op.dy_type = AuDy_AOP;
	op.dy_haop = h_aop;
	dyaop = (void *)dy_get(&op, br);
	if (IS_ERR(dyaop))
		goto out;
	dy_adx(dyaop, do_dx);

out:
	return dyaop;
}

int au_dy_iaop(struct inode *inode, aufs_bindex_t bindex,
		struct inode *h_inode)
{
	int err, do_dx;
	struct super_block *sb;
	struct au_branch *br;
	struct au_dyaop *dyaop;

	AuDebugOn(!S_ISREG(h_inode->i_mode));
	IiMustWriteLock(inode);

	sb = inode->i_sb;
	br = au_sbr(sb, bindex);
	do_dx = !!au_opt_test(au_mntflags(sb), DIO);
	dyaop = dy_aget(br, h_inode->i_mapping->a_ops, do_dx);
	err = PTR_ERR(dyaop);
	if (IS_ERR(dyaop))
		/* unnecessary to call dy_fput() */
		goto out;

	err = 0;
	inode->i_mapping->a_ops = &dyaop->da_op;

out:
	return err;
}

/*
 * Is it safe to replace a_ops during the inode/file is in operation?
 * Yes, I hope so.
 */
int au_dy_irefresh(struct inode *inode)
{
	int err;
	aufs_bindex_t btop;
	struct inode *h_inode;

	err = 0;
	if (S_ISREG(inode->i_mode)) {
		btop = au_ibtop(inode);
		h_inode = au_h_iptr(inode, btop);
		err = au_dy_iaop(inode, btop, h_inode);
	}
	return err;
}

void au_dy_arefresh(int do_dx)
{
	struct au_sphlhead *sphl;
	struct hlist_head *head;
	struct au_dykey *key;

	sphl = dynop + AuDy_AOP;
	head = &sphl->head;
	spin_lock(&sphl->spin);
	hlist_for_each_entry(key, head, dk_hnode)
		dy_adx((void *)key, do_dx);
	spin_unlock(&sphl->spin);
}

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

void __init au_dy_init(void)
{
	int i;

	/* make sure that 'struct au_dykey *' can be any type */
	BUILD_BUG_ON(offsetof(struct au_dyaop, da_key));

	for (i = 0; i < AuDyLast; i++)
		au_sphl_init(dynop + i);
}

void au_dy_fin(void)
{
	int i;

	for (i = 0; i < AuDyLast; i++)
		WARN_ON(!hlist_empty(&dynop[i].head));
}
Commit	Line	Data
5b88fdd9 SF	1	/*
	2	* Copyright (C) 2010-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	* dynamically customizable operations for regular files
	20	*/
	21
	22	#include "aufs.h"
	23
	24	#define DyPrSym(key) AuDbgSym(key->dk_op.dy_hop)
	25
	26	/*
	27	* How large will these lists be?
	28	* Usually just a few elements, 20-30 at most for each, I guess.
	29	*/
	30	static struct au_sphlhead dynop[AuDyLast];
	31
	32	static struct au_dykey dy_gfind_get(struct au_sphlhead sphl, const void *h_op)
	33	{
	34	struct au_dykey key, tmp;
	35	struct hlist_head *head;
	36
	37	key = NULL;
	38	head = &sphl->head;
	39	rcu_read_lock();
	40	hlist_for_each_entry_rcu(tmp, head, dk_hnode)
	41	if (tmp->dk_op.dy_hop == h_op) {
	42	key = tmp;
	43	kref_get(&key->dk_kref);
	44	break;
	45	}
	46	rcu_read_unlock();
	47
	48	return key;
	49	}
	50
	51	static struct au_dykey dy_bradd(struct au_branch br, struct au_dykey *key)
	52	{
	53	struct au_dykey *k, found;
	54	const void *h_op = key->dk_op.dy_hop;
	55	int i;
	56
	57	found = NULL;
	58	k = br->br_dykey;
	59	for (i = 0; i < AuBrDynOp; i++)
	60	if (k[i]) {
	61	if (k[i]->dk_op.dy_hop == h_op) {
	62	found = k[i];
	63	break;
	64	}
65	} else
66	break;
67	if (!found) {
68	spin_lock(&br->br_dykey_lock);
69	for (; i < AuBrDynOp; i++)
70	if (k[i]) {
71	if (k[i]->dk_op.dy_hop == h_op) {
72	found = k[i];
73	break;
74	}
75	} else {
76	k[i] = key;
77	break;
78	}
79	spin_unlock(&br->br_dykey_lock);
80	BUG_ON(i == AuBrDynOp); /* expand the array */
81	}
82
83	return found;
84	}
85
86	/* kref_get() if @key is already added */
87	static struct au_dykey dy_gadd(struct au_sphlhead sphl, struct au_dykey *key)
88	{
89	struct au_dykey tmp, found;
90	struct hlist_head *head;
91	const void *h_op = key->dk_op.dy_hop;
92
93	found = NULL;
94	head = &sphl->head;
95	spin_lock(&sphl->spin);
96	hlist_for_each_entry(tmp, head, dk_hnode)
97	if (tmp->dk_op.dy_hop == h_op) {
98	kref_get(&tmp->dk_kref);
99	found = tmp;
100	break;
101	}
102	if (!found)
103	hlist_add_head_rcu(&key->dk_hnode, head);
104	spin_unlock(&sphl->spin);
105
106	if (!found)
107	DyPrSym(key);
108	return found;
109	}
110
111	static void dy_free_rcu(struct rcu_head *rcu)
112	{
113	struct au_dykey *key;
114
115	key = container_of(rcu, struct au_dykey, dk_rcu);
116	DyPrSym(key);
117	kfree(key); /* not delayed */
118	}
119
120	static void dy_free(struct kref *kref)
121	{
122	struct au_dykey *key;
123	struct au_sphlhead *sphl;
124
125	key = container_of(kref, struct au_dykey, dk_kref);
126	sphl = dynop + key->dk_op.dy_type;
127	au_sphl_del_rcu(&key->dk_hnode, sphl);
128	call_rcu(&key->dk_rcu, dy_free_rcu);
129	}
130
131	void au_dy_put(struct au_dykey *key)
132	{
133	kref_put(&key->dk_kref, dy_free);
134	}
135
136	/* ---------------------------------------------------------------------- */
137
138	#define DyDbgSize(cnt, op) AuDebugOn(cnt != sizeof(op)/sizeof(void *))
139
140	#ifdef CONFIG_AUFS_DEBUG
141	#define DyDbgDeclare(cnt) unsigned int cnt = 0
142	#define DyDbgInc(cnt) do { cnt++; } while (0)
143	#else
144	#define DyDbgDeclare(cnt) do {} while (0)
145	#define DyDbgInc(cnt) do {} while (0)
146	#endif
147
148	#define DySet(func, dst, src, h_op, h_sb) do { \
149	DyDbgInc(cnt); \
150	if (h_op->func) { \
151	if (src.func) \
152	dst.func = src.func; \
153	else \
154	AuDbg("%s %s\n", au_sbtype(h_sb), #func); \
155	} \
156	} while (0)
157
158	#define DySetForce(func, dst, src) do { \
159	AuDebugOn(!src.func); \
160	DyDbgInc(cnt); \
161	dst.func = src.func; \
162	} while (0)
163
164	#define DySetAop(func) \
165	DySet(func, dyaop->da_op, aufs_aop, h_aop, h_sb)
166	#define DySetAopForce(func) \
167	DySetForce(func, dyaop->da_op, aufs_aop)
168
169	static void dy_aop(struct au_dykey key, const void h_op,
170	struct super_block *h_sb __maybe_unused)
171	{
172	struct au_dyaop dyaop = (void )key;
173	const struct address_space_operations *h_aop = h_op;
174	DyDbgDeclare(cnt);
175
176	AuDbg("%s\n", au_sbtype(h_sb));
177
178	DySetAop(writepage);
179	DySetAopForce(readpage); /* force */
180	DySetAop(writepages);
181	DySetAop(set_page_dirty);
182	DySetAop(readpages);
183	DySetAop(write_begin);
184	DySetAop(write_end);
185	DySetAop(bmap);
186	DySetAop(invalidatepage);
187	DySetAop(releasepage);
188	DySetAop(freepage);
189	/* this one will be changed according to an aufs mount option */
190	DySetAop(direct_IO);
191	DySetAop(migratepage);
192	DySetAop(isolate_page);
193	DySetAop(putback_page);
194	DySetAop(launder_page);
195	DySetAop(is_partially_uptodate);
196	DySetAop(is_dirty_writeback);
197	DySetAop(error_remove_page);
198	DySetAop(swap_activate);
199	DySetAop(swap_deactivate);
200
201	DyDbgSize(cnt, *h_aop);
202	}
203
204	/* ---------------------------------------------------------------------- */
205
206	static void dy_bug(struct kref *kref)
207	{
208	BUG();
209	}
210
211	static struct au_dykey dy_get(struct au_dynop op, struct au_branch *br)
212	{
213	struct au_dykey key, old;
214	struct au_sphlhead *sphl;
215	struct op {
216	unsigned int sz;
217	void (set)(struct au_dykey key, const void *h_op,
218	struct super_block *h_sb __maybe_unused);
219	};
220	static const struct op a[] = {
221	[AuDy_AOP] = {
222	.sz = sizeof(struct au_dyaop),
223	.set = dy_aop
224	}
225	};
226	const struct op *p;
227
228	sphl = dynop + op->dy_type;
229	key = dy_gfind_get(sphl, op->dy_hop);
230	if (key)
231	goto out_add; /* success */
232
233	p = a + op->dy_type;
234	key = kzalloc(p->sz, GFP_NOFS);
235	if (unlikely(!key)) {
236	key = ERR_PTR(-ENOMEM);
237	goto out;
238	}
239
240	key->dk_op.dy_hop = op->dy_hop;
241	kref_init(&key->dk_kref);
242	p->set(key, op->dy_hop, au_br_sb(br));
243	old = dy_gadd(sphl, key);
244	if (old) {
245	au_delayed_kfree(key);
246	key = old;
247	}
248
249	out_add:
250	old = dy_bradd(br, key);
251	if (old)
252	/* its ref-count should never be zero here */
253	kref_put(&key->dk_kref, dy_bug);
254	out:
255	return key;
256	}
257
258	/* ---------------------------------------------------------------------- */
259	/*
260	* Aufs prohibits O_DIRECT by defaut even if the branch supports it.
261	* This behaviour is necessary to return an error from open(O_DIRECT) instead
262	* of the succeeding I/O. The dio mount option enables O_DIRECT and makes
263	* open(O_DIRECT) always succeed, but the succeeding I/O may return an error.
264	* See the aufs manual in detail.
265	*/
266	static void dy_adx(struct au_dyaop *dyaop, int do_dx)
267	{
268	if (!do_dx)
269	dyaop->da_op.direct_IO = NULL;
270	else
271	dyaop->da_op.direct_IO = aufs_aop.direct_IO;
272	}
273
274	static struct au_dyaop dy_aget(struct au_branch br,
275	const struct address_space_operations *h_aop,
276	int do_dx)
277	{
278	struct au_dyaop *dyaop;
279	struct au_dynop op;
280
281	op.dy_type = AuDy_AOP;
282	op.dy_haop = h_aop;
283	dyaop = (void *)dy_get(&op, br);
284	if (IS_ERR(dyaop))
285	goto out;
286	dy_adx(dyaop, do_dx);
287
288	out:
289	return dyaop;
290	}
291
292	int au_dy_iaop(struct inode *inode, aufs_bindex_t bindex,
293	struct inode *h_inode)
294	{
295	int err, do_dx;
296	struct super_block *sb;
297	struct au_branch *br;
298	struct au_dyaop *dyaop;
299
300	AuDebugOn(!S_ISREG(h_inode->i_mode));
301	IiMustWriteLock(inode);
302
303	sb = inode->i_sb;
304	br = au_sbr(sb, bindex);
305	do_dx = !!au_opt_test(au_mntflags(sb), DIO);
306	dyaop = dy_aget(br, h_inode->i_mapping->a_ops, do_dx);
307	err = PTR_ERR(dyaop);
308	if (IS_ERR(dyaop))
309	/* unnecessary to call dy_fput() */
310	goto out;
311
312	err = 0;
313	inode->i_mapping->a_ops = &dyaop->da_op;
314
315	out:
316	return err;
317	}
318
319	/*
320	* Is it safe to replace a_ops during the inode/file is in operation?
321	* Yes, I hope so.
322	*/
323	int au_dy_irefresh(struct inode *inode)
324	{
325	int err;
326	aufs_bindex_t btop;
327	struct inode *h_inode;
328
329	err = 0;
330	if (S_ISREG(inode->i_mode)) {
331	btop = au_ibtop(inode);
332	h_inode = au_h_iptr(inode, btop);
333	err = au_dy_iaop(inode, btop, h_inode);
334	}
335	return err;
336	}
337
338	void au_dy_arefresh(int do_dx)
339	{
340	struct au_sphlhead *sphl;
341	struct hlist_head *head;
342	struct au_dykey *key;
343
344	sphl = dynop + AuDy_AOP;
345	head = &sphl->head;
346	spin_lock(&sphl->spin);
347	hlist_for_each_entry(key, head, dk_hnode)
348	dy_adx((void *)key, do_dx);
349	spin_unlock(&sphl->spin);
350	}
351
352	/* ---------------------------------------------------------------------- */
353
354	void __init au_dy_init(void)
355	{
356	int i;
357
358	/* make sure that 'struct au_dykey ' can be any type /
359	BUILD_BUG_ON(offsetof(struct au_dyaop, da_key));
360
361	for (i = 0; i < AuDyLast; i++)
362	au_sphl_init(dynop + i);
363	}
364
365	void au_dy_fin(void)
366	{
367	int i;
368
369	for (i = 0; i < AuDyLast; i++)
370	WARN_ON(!hlist_empty(&dynop[i].head));
371	}