[GitHub/mt8127/android_kernel_alcatel_ttab.git] / include / linux / quotaops.h

/*
 * Definitions for diskquota-operations. When diskquota is configured these
 * macros expand to the right source-code.
 *
 * Author:  Marco van Wieringen <mvw@planets.elm.net>
 */
#ifndef _LINUX_QUOTAOPS_
#define _LINUX_QUOTAOPS_

#include <linux/smp_lock.h>
#include <linux/fs.h>

static inline struct quota_info *sb_dqopt(struct super_block *sb)
{
	return &sb->s_dquot;
}

#if defined(CONFIG_QUOTA)

/*
 * declaration of quota_function calls in kernel.
 */
void sync_dquots(struct super_block *sb, int type);

int dquot_initialize(struct inode *inode, int type);
int dquot_drop(struct inode *inode);

int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
int dquot_alloc_inode(const struct inode *inode, unsigned long number);

int dquot_free_space(struct inode *inode, qsize_t number);
int dquot_free_inode(const struct inode *inode, unsigned long number);

int dquot_transfer(struct inode *inode, struct iattr *iattr);
int dquot_commit(struct dquot *dquot);
int dquot_acquire(struct dquot *dquot);
int dquot_release(struct dquot *dquot);
int dquot_commit_info(struct super_block *sb, int type);
int dquot_mark_dquot_dirty(struct dquot *dquot);

int vfs_quota_on(struct super_block *sb, int type, int format_id,
 	char *path, int remount);
int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
 	struct path *path);
int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
 	int format_id, int type);
int vfs_quota_off(struct super_block *sb, int type, int remount);
int vfs_quota_sync(struct super_block *sb, int type);
int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);

void vfs_dq_drop(struct inode *inode);
int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
int vfs_dq_quota_on_remount(struct super_block *sb);

static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
{
	return sb_dqopt(sb)->info + type;
}

/*
 * Functions for checking status of quota
 */

static inline int sb_has_quota_enabled(struct super_block *sb, int type)
{
	if (type == USRQUOTA)
		return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
	return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
}

static inline int sb_any_quota_enabled(struct super_block *sb)
{
	return sb_has_quota_enabled(sb, USRQUOTA) ||
		sb_has_quota_enabled(sb, GRPQUOTA);
}

static inline int sb_has_quota_suspended(struct super_block *sb, int type)
{
	if (type == USRQUOTA)
		return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
	return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
}

static inline int sb_any_quota_suspended(struct super_block *sb)
{
	return sb_has_quota_suspended(sb, USRQUOTA) ||
		sb_has_quota_suspended(sb, GRPQUOTA);
}

/*
 * Operations supported for diskquotas.
 */
extern struct dquot_operations dquot_operations;
extern struct quotactl_ops vfs_quotactl_ops;

#define sb_dquot_ops (&dquot_operations)
#define sb_quotactl_ops (&vfs_quotactl_ops)

/* It is better to call this function outside of any transaction as it might
 * need a lot of space in journal for dquot structure allocation. */
static inline void vfs_dq_init(struct inode *inode)
{
	BUG_ON(!inode->i_sb);
	if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
		inode->i_sb->dq_op->initialize(inode, -1);
}

/* The following allocation/freeing/transfer functions *must* be called inside
 * a transaction (deadlocks possible otherwise) */
static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
{
	if (sb_any_quota_enabled(inode->i_sb)) {
		/* Used space is updated in alloc_space() */
		if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
			return 1;
	}
	else
		inode_add_bytes(inode, nr);
	return 0;
}

static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
{
	int ret;
        if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
		mark_inode_dirty(inode);
	return ret;
}

static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
{
	if (sb_any_quota_enabled(inode->i_sb)) {
		/* Used space is updated in alloc_space() */
		if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
			return 1;
	}
	else
		inode_add_bytes(inode, nr);
	return 0;
}

static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
{
	int ret;
	if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
		mark_inode_dirty(inode);
	return ret;
}

static inline int vfs_dq_alloc_inode(struct inode *inode)
{
	if (sb_any_quota_enabled(inode->i_sb)) {
		vfs_dq_init(inode);
		if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
			return 1;
	}
	return 0;
}

static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
{
	if (sb_any_quota_enabled(inode->i_sb))
		inode->i_sb->dq_op->free_space(inode, nr);
	else
		inode_sub_bytes(inode, nr);
}

static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
{
	vfs_dq_free_space_nodirty(inode, nr);
	mark_inode_dirty(inode);
}

static inline void vfs_dq_free_inode(struct inode *inode)
{
	if (sb_any_quota_enabled(inode->i_sb))
		inode->i_sb->dq_op->free_inode(inode, 1);
}

/* The following two functions cannot be called inside a transaction */
static inline void vfs_dq_sync(struct super_block *sb)
{
	sync_dquots(sb, -1);
}

static inline int vfs_dq_off(struct super_block *sb, int remount)
{
	int ret = -ENOSYS;

	if (sb->s_qcop && sb->s_qcop->quota_off)
		ret = sb->s_qcop->quota_off(sb, -1, remount);
	return ret;
}

#else

static inline int sb_has_quota_enabled(struct super_block *sb, int type)
{
	return 0;
}

static inline int sb_any_quota_enabled(struct super_block *sb)
{
	return 0;
}

static inline int sb_has_quota_suspended(struct super_block *sb, int type)
{
	return 0;
}

static inline int sb_any_quota_suspended(struct super_block *sb)
{
	return 0;
}

/*
 * NO-OP when quota not configured.
 */
#define sb_dquot_ops				(NULL)
#define sb_quotactl_ops				(NULL)

static inline void vfs_dq_init(struct inode *inode)
{
}

static inline void vfs_dq_drop(struct inode *inode)
{
}

static inline int vfs_dq_alloc_inode(struct inode *inode)
{
	return 0;
}

static inline void vfs_dq_free_inode(struct inode *inode)
{
}

static inline void vfs_dq_sync(struct super_block *sb)
{
}

static inline int vfs_dq_off(struct super_block *sb, int remount)
{
	return 0;
}

static inline int vfs_dq_quota_on_remount(struct super_block *sb)
{
	return 0;
}

static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
{
	return 0;
}

static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
{
	inode_add_bytes(inode, nr);
	return 0;
}

static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
{
	vfs_dq_prealloc_space_nodirty(inode, nr);
	mark_inode_dirty(inode);
	return 0;
}

static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
{
	inode_add_bytes(inode, nr);
	return 0;
}

static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
{
	vfs_dq_alloc_space_nodirty(inode, nr);
	mark_inode_dirty(inode);
	return 0;
}

static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
{
	inode_sub_bytes(inode, nr);
}

static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
{
	vfs_dq_free_space_nodirty(inode, nr);
	mark_inode_dirty(inode);
}	

#endif /* CONFIG_QUOTA */

static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
{
	return vfs_dq_prealloc_space_nodirty(inode,
			nr << inode->i_sb->s_blocksize_bits);
}

static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
{
	return vfs_dq_prealloc_space(inode,
			nr << inode->i_sb->s_blocksize_bits);
}

static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
{
 	return vfs_dq_alloc_space_nodirty(inode,
			nr << inode->i_sb->s_blocksize_bits);
}

static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
{
	return vfs_dq_alloc_space(inode,
			nr << inode->i_sb->s_blocksize_bits);
}

static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
{
	vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
}

static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
{
	vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
}

/*
 * Define uppercase equivalents for compatibility with old function names
 * Can go away when we think all users have been converted (15/04/2008)
 */
#define DQUOT_INIT(inode) vfs_dq_init(inode)
#define DQUOT_DROP(inode) vfs_dq_drop(inode)
#define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
				vfs_dq_prealloc_space_nodirty(inode, nr)
#define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
#define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
				vfs_dq_alloc_space_nodirty(inode, nr)
#define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
#define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
				vfs_dq_prealloc_block_nodirty(inode, nr)
#define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
#define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
				vfs_dq_alloc_block_nodirty(inode, nr)
#define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
#define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
#define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
				vfs_dq_free_space_nodirty(inode, nr)
#define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
#define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
				vfs_dq_free_block_nodirty(inode, nr)
#define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
#define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
#define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
#define DQUOT_SYNC(sb) vfs_dq_sync(sb)
#define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
#define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)

#endif /* _LINUX_QUOTAOPS_ */
Commit	Line	Data
1da177e4 LT	1	/*
	2	* Definitions for diskquota-operations. When diskquota is configured these
	3	* macros expand to the right source-code.
	4	*
	5	* Author: Marco van Wieringen <mvw@planets.elm.net>
1da177e4 LT	6	*/
	7	#ifndef _LINUX_QUOTAOPS_
	8	#define _LINUX_QUOTAOPS_
	9
1da177e4	10	#include <linux/smp_lock.h>
1da177e4 LT	11	#include <linux/fs.h>
1da177e4 LT	12
03b06343 JK	13	static inline struct quota_info sb_dqopt(struct super_block sb)
	14	{
	15	return &sb->s_dquot;
	16	}
74abb989	17
1da177e4 LT	18	#if defined(CONFIG_QUOTA)
	19
	20	/*
	21	* declaration of quota_function calls in kernel.
	22	*/
b85f4b87 JK	23	void sync_dquots(struct super_block *sb, int type);
	24
	25	int dquot_initialize(struct inode *inode, int type);
	26	int dquot_drop(struct inode *inode);
	27
	28	int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
	29	int dquot_alloc_inode(const struct inode *inode, unsigned long number);
	30
	31	int dquot_free_space(struct inode *inode, qsize_t number);
	32	int dquot_free_inode(const struct inode *inode, unsigned long number);
	33
	34	int dquot_transfer(struct inode inode, struct iattr iattr);
	35	int dquot_commit(struct dquot *dquot);
	36	int dquot_acquire(struct dquot *dquot);
	37	int dquot_release(struct dquot *dquot);
	38	int dquot_commit_info(struct super_block *sb, int type);
	39	int dquot_mark_dquot_dirty(struct dquot *dquot);
	40
	41	int vfs_quota_on(struct super_block *sb, int type, int format_id,
	42	char *path, int remount);
77e69dac AV	43	int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
77e69dac AV	44	struct path *path);
b85f4b87 JK	45	int vfs_quota_on_mount(struct super_block sb, char qf_name,
	46	int format_id, int type);
	47	int vfs_quota_off(struct super_block *sb, int type, int remount);
	48	int vfs_quota_sync(struct super_block *sb, int type);
	49	int vfs_get_dqinfo(struct super_block sb, int type, struct if_dqinfo ii);
	50	int vfs_set_dqinfo(struct super_block sb, int type, struct if_dqinfo ii);
	51	int vfs_get_dqblk(struct super_block sb, int type, qid_t id, struct if_dqblk di);
	52	int vfs_set_dqblk(struct super_block sb, int type, qid_t id, struct if_dqblk di);
	53
	54	void vfs_dq_drop(struct inode *inode);
	55	int vfs_dq_transfer(struct inode inode, struct iattr iattr);
	56	int vfs_dq_quota_on_remount(struct super_block *sb);
1da177e4	57
03b06343 JK	58	static inline struct mem_dqinfo sb_dqinfo(struct super_block sb, int type)
	59	{
	60	return sb_dqopt(sb)->info + type;
	61	}
74abb989 JK	62
	63	/*
	64	* Functions for checking status of quota
	65	*/
	66
03b06343 JK	67	static inline int sb_has_quota_enabled(struct super_block *sb, int type)
	68	{
	69	if (type == USRQUOTA)
	70	return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
	71	return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
	72	}
74abb989	73
03b06343 JK	74	static inline int sb_any_quota_enabled(struct super_block *sb)
	75	{
	76	return sb_has_quota_enabled(sb, USRQUOTA) \|\|
	77	sb_has_quota_enabled(sb, GRPQUOTA);
	78	}
74abb989	79
03b06343 JK	80	static inline int sb_has_quota_suspended(struct super_block *sb, int type)
	81	{
	82	if (type == USRQUOTA)
	83	return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
	84	return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
	85	}
74abb989	86
03b06343 JK	87	static inline int sb_any_quota_suspended(struct super_block *sb)
	88	{
	89	return sb_has_quota_suspended(sb, USRQUOTA) \|\|
	90	sb_has_quota_suspended(sb, GRPQUOTA);
	91	}
74abb989	92
1da177e4 LT	93	/*
	94	* Operations supported for diskquotas.
	95	*/
	96	extern struct dquot_operations dquot_operations;
	97	extern struct quotactl_ops vfs_quotactl_ops;
	98
	99	#define sb_dquot_ops (&dquot_operations)
	100	#define sb_quotactl_ops (&vfs_quotactl_ops)
	101
	102	/* It is better to call this function outside of any transaction as it might
	103	* need a lot of space in journal for dquot structure allocation. */
b85f4b87	104	static inline void vfs_dq_init(struct inode *inode)
1da177e4 LT	105	{
	106	BUG_ON(!inode->i_sb);
	107	if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
	108	inode->i_sb->dq_op->initialize(inode, -1);
	109	}
	110
1da177e4 LT	111	/* The following allocation/freeing/transfer functions must be called inside
1da177e4 LT	112	* a transaction (deadlocks possible otherwise) */
b85f4b87	113	static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	114	{
	115	if (sb_any_quota_enabled(inode->i_sb)) {
	116	/* Used space is updated in alloc_space() */
	117	if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
	118	return 1;
	119	}
	120	else
	121	inode_add_bytes(inode, nr);
	122	return 0;
	123	}
	124
b85f4b87	125	static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
1da177e4 LT	126	{
1da177e4 LT	127	int ret;
b85f4b87	128	if (!(ret = vfs_dq_prealloc_space_nodirty(inode, nr)))
1da177e4 LT	129	mark_inode_dirty(inode);
	130	return ret;
	131	}
	132
b85f4b87	133	static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	134	{
	135	if (sb_any_quota_enabled(inode->i_sb)) {
	136	/* Used space is updated in alloc_space() */
	137	if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
	138	return 1;
	139	}
	140	else
	141	inode_add_bytes(inode, nr);
	142	return 0;
	143	}
	144
b85f4b87	145	static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
1da177e4 LT	146	{
1da177e4 LT	147	int ret;
b85f4b87	148	if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
1da177e4 LT	149	mark_inode_dirty(inode);
	150	return ret;
	151	}
	152
b85f4b87	153	static inline int vfs_dq_alloc_inode(struct inode *inode)
1da177e4 LT	154	{
1da177e4 LT	155	if (sb_any_quota_enabled(inode->i_sb)) {
b85f4b87	156	vfs_dq_init(inode);
1da177e4 LT	157	if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
	158	return 1;
	159	}
	160	return 0;
	161	}
	162
b85f4b87	163	static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	164	{
	165	if (sb_any_quota_enabled(inode->i_sb))
	166	inode->i_sb->dq_op->free_space(inode, nr);
	167	else
	168	inode_sub_bytes(inode, nr);
	169	}
	170
b85f4b87	171	static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
1da177e4	172	{
b85f4b87	173	vfs_dq_free_space_nodirty(inode, nr);
1da177e4 LT	174	mark_inode_dirty(inode);
	175	}
	176
b85f4b87	177	static inline void vfs_dq_free_inode(struct inode *inode)
1da177e4 LT	178	{
	179	if (sb_any_quota_enabled(inode->i_sb))
	180	inode->i_sb->dq_op->free_inode(inode, 1);
	181	}
	182
1da177e4	183	/* The following two functions cannot be called inside a transaction */
b85f4b87	184	static inline void vfs_dq_sync(struct super_block *sb)
03f6e92b JK	185	{
	186	sync_dquots(sb, -1);
	187	}
1da177e4	188
b85f4b87	189	static inline int vfs_dq_off(struct super_block *sb, int remount)
1da177e4 LT	190	{
	191	int ret = -ENOSYS;
	192
0ff5af83 JK	193	if (sb->s_qcop && sb->s_qcop->quota_off)
	194	ret = sb->s_qcop->quota_off(sb, -1, remount);
	195	return ret;
	196	}
	197
1da177e4 LT	198	#else
1da177e4 LT	199
03b06343 JK	200	static inline int sb_has_quota_enabled(struct super_block *sb, int type)
	201	{
	202	return 0;
	203	}
	204
	205	static inline int sb_any_quota_enabled(struct super_block *sb)
	206	{
	207	return 0;
	208	}
	209
	210	static inline int sb_has_quota_suspended(struct super_block *sb, int type)
	211	{
	212	return 0;
	213	}
	214
	215	static inline int sb_any_quota_suspended(struct super_block *sb)
	216	{
	217	return 0;
	218	}
74abb989	219
1da177e4 LT	220	/*
	221	* NO-OP when quota not configured.
	222	*/
	223	#define sb_dquot_ops (NULL)
	224	#define sb_quotactl_ops (NULL)
50f8c370	225
b85f4b87	226	static inline void vfs_dq_init(struct inode *inode)
50f8c370 AM	227	{
	228	}
	229
b85f4b87	230	static inline void vfs_dq_drop(struct inode *inode)
50f8c370 AM	231	{
	232	}
	233
b85f4b87	234	static inline int vfs_dq_alloc_inode(struct inode *inode)
50f8c370 AM	235	{
	236	return 0;
	237	}
	238
b85f4b87	239	static inline void vfs_dq_free_inode(struct inode *inode)
50f8c370 AM	240	{
	241	}
	242
b85f4b87	243	static inline void vfs_dq_sync(struct super_block *sb)
50f8c370 AM	244	{
	245	}
	246
b85f4b87	247	static inline int vfs_dq_off(struct super_block *sb, int remount)
50f8c370 AM	248	{
	249	return 0;
	250	}
	251
b85f4b87	252	static inline int vfs_dq_quota_on_remount(struct super_block *sb)
50f8c370 AM	253	{
	254	return 0;
	255	}
	256
b85f4b87	257	static inline int vfs_dq_transfer(struct inode inode, struct iattr iattr)
50f8c370 AM	258	{
	259	return 0;
	260	}
	261
b85f4b87	262	static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	263	{
	264	inode_add_bytes(inode, nr);
	265	return 0;
	266	}
	267
b85f4b87	268	static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
1da177e4	269	{
b85f4b87	270	vfs_dq_prealloc_space_nodirty(inode, nr);
1da177e4 LT	271	mark_inode_dirty(inode);
	272	return 0;
	273	}
	274
b85f4b87	275	static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	276	{
	277	inode_add_bytes(inode, nr);
	278	return 0;
	279	}
	280
b85f4b87	281	static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
1da177e4	282	{
b85f4b87	283	vfs_dq_alloc_space_nodirty(inode, nr);
1da177e4 LT	284	mark_inode_dirty(inode);
	285	return 0;
	286	}
	287
b85f4b87	288	static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	289	{
	290	inode_sub_bytes(inode, nr);
	291	}
	292
b85f4b87	293	static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
1da177e4	294	{
b85f4b87	295	vfs_dq_free_space_nodirty(inode, nr);
1da177e4 LT	296	mark_inode_dirty(inode);
	297	}
	298
	299	#endif /* CONFIG_QUOTA */
	300
b85f4b87	301	static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
03f6e92b	302	{
b85f4b87	303	return vfs_dq_prealloc_space_nodirty(inode,
03f6e92b JK	304	nr << inode->i_sb->s_blocksize_bits);
	305	}
	306
b85f4b87	307	static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
03f6e92b	308	{
b85f4b87	309	return vfs_dq_prealloc_space(inode,
03f6e92b JK	310	nr << inode->i_sb->s_blocksize_bits);
	311	}
	312
b85f4b87	313	static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
03f6e92b	314	{
b85f4b87	315	return vfs_dq_alloc_space_nodirty(inode,
03f6e92b JK	316	nr << inode->i_sb->s_blocksize_bits);
	317	}
	318
b85f4b87	319	static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
03f6e92b	320	{
b85f4b87	321	return vfs_dq_alloc_space(inode,
03f6e92b JK	322	nr << inode->i_sb->s_blocksize_bits);
	323	}
	324
b85f4b87	325	static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
03f6e92b	326	{
b85f4b87	327	vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
03f6e92b JK	328	}
03f6e92b JK	329
b85f4b87	330	static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
03f6e92b	331	{
b85f4b87	332	vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
03f6e92b	333	}
1da177e4	334
b85f4b87 JK	335	/*
	336	* Define uppercase equivalents for compatibility with old function names
	337	* Can go away when we think all users have been converted (15/04/2008)
	338	*/
	339	#define DQUOT_INIT(inode) vfs_dq_init(inode)
	340	#define DQUOT_DROP(inode) vfs_dq_drop(inode)
	341	#define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
	342	vfs_dq_prealloc_space_nodirty(inode, nr)
	343	#define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
	344	#define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
	345	vfs_dq_alloc_space_nodirty(inode, nr)
	346	#define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
	347	#define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
	348	vfs_dq_prealloc_block_nodirty(inode, nr)
	349	#define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
	350	#define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
	351	vfs_dq_alloc_block_nodirty(inode, nr)
	352	#define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
	353	#define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
	354	#define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
	355	vfs_dq_free_space_nodirty(inode, nr)
	356	#define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
	357	#define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
	358	vfs_dq_free_block_nodirty(inode, nr)
	359	#define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
	360	#define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
	361	#define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
	362	#define DQUOT_SYNC(sb) vfs_dq_sync(sb)
	363	#define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
	364	#define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
	365
1da177e4	366	#endif /* _LINUX_QUOTAOPS_ */