[linux-2.6-block.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);
struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
void dqput(struct dquot *dquot);
int dquot_scan_active(struct super_block *sb,
		      int (*fn)(struct dquot *dquot, unsigned long priv),
		      unsigned long priv);
struct dquot *dquot_alloc(struct super_block *sb, int type);
void dquot_destroy(struct dquot *dquot);

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

int dquot_reserve_space(struct inode *inode, qsize_t number, int prealloc);
int dquot_claim_space(struct inode *inode, qsize_t number);
void dquot_release_reserved_space(struct inode *inode, qsize_t number);
qsize_t dquot_get_reserved_space(struct inode *inode);

int dquot_free_space(struct inode *inode, qsize_t number);
int dquot_free_inode(const struct inode *inode, qsize_t 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_enable(struct inode *inode, int type, int format_id,
	unsigned int flags);
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_disable(struct super_block *sb, int type, unsigned int flags);
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_usage_enabled(struct super_block *sb, int type)
{
	return sb_dqopt(sb)->flags &
				dquot_state_flag(DQUOT_USAGE_ENABLED, type);
}

static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
{
	return sb_dqopt(sb)->flags &
				dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
}

static inline int sb_has_quota_suspended(struct super_block *sb, int type)
{
	return sb_dqopt(sb)->flags &
				dquot_state_flag(DQUOT_SUSPENDED, type);
}

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

/* Does kernel know about any quota information for given sb + type? */
static inline int sb_has_quota_loaded(struct super_block *sb, int type)
{
	/* Currently if anything is on, then quota usage is on as well */
	return sb_has_quota_usage_enabled(sb, type);
}

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

static inline int sb_has_quota_active(struct super_block *sb, int type)
{
	return sb_has_quota_loaded(sb, type) &&
	       !sb_has_quota_suspended(sb, type);
}

static inline int sb_any_quota_active(struct super_block *sb)
{
	return sb_has_quota_active(sb, USRQUOTA) ||
	       sb_has_quota_active(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_active(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_active(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_active(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_reserve_space(struct inode *inode, qsize_t nr)
{
	if (sb_any_quota_active(inode->i_sb)) {
		/* Used space is updated in alloc_space() */
		if (inode->i_sb->dq_op->reserve_space(inode, nr, 0) == NO_QUOTA)
			return 1;
	}
	return 0;
}

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

/*
 * Convert in-memory reserved quotas to real consumed quotas
 */
static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
{
	if (sb_any_quota_active(inode->i_sb)) {
		if (inode->i_sb->dq_op->claim_space(inode, nr) == NO_QUOTA)
			return 1;
	} else
		inode_add_bytes(inode, nr);

	mark_inode_dirty(inode);
	return 0;
}

/*
 * Release reserved (in-memory) quotas
 */
static inline
void vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
{
	if (sb_any_quota_active(inode->i_sb))
		inode->i_sb->dq_op->release_rsv(inode, nr);
}

static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
{
	if (sb_any_quota_active(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_active(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_usage_enabled(struct super_block *sb, int type)
{
	return 0;
}

static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
{
	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;
}

/* Does kernel know about any quota information for given sb + type? */
static inline int sb_has_quota_loaded(struct super_block *sb, int type)
{
	return 0;
}

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

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

static inline int sb_any_quota_active(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 int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
{
	return 0;
}

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

static inline
int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
{
	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_blkbits);
}

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

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

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

static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
{
	return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
}

static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
{
	return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
}

static inline
void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
{
	vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
}

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

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

#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);
3d9ea253 JK	27	struct dquot dqget(struct super_block sb, unsigned int id, int type);
3d9ea253 JK	28	void dqput(struct dquot *dquot);
12c77527 JK	29	int dquot_scan_active(struct super_block *sb,
	30	int (fn)(struct dquot dquot, unsigned long priv),
	31	unsigned long priv);
7d9056ba JK	32	struct dquot dquot_alloc(struct super_block sb, int type);
7d9056ba JK	33	void dquot_destroy(struct dquot *dquot);
b85f4b87 JK	34
b85f4b87 JK	35	int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
12095460	36	int dquot_alloc_inode(const struct inode *inode, qsize_t number);
b85f4b87	37
740d9dcd MC	38	int dquot_reserve_space(struct inode *inode, qsize_t number, int prealloc);
	39	int dquot_claim_space(struct inode *inode, qsize_t number);
	40	void dquot_release_reserved_space(struct inode *inode, qsize_t number);
	41	qsize_t dquot_get_reserved_space(struct inode *inode);
	42
b85f4b87	43	int dquot_free_space(struct inode *inode, qsize_t number);
12095460	44	int dquot_free_inode(const struct inode *inode, qsize_t number);
b85f4b87 JK	45
	46	int dquot_transfer(struct inode inode, struct iattr iattr);
	47	int dquot_commit(struct dquot *dquot);
	48	int dquot_acquire(struct dquot *dquot);
	49	int dquot_release(struct dquot *dquot);
	50	int dquot_commit_info(struct super_block *sb, int type);
	51	int dquot_mark_dquot_dirty(struct dquot *dquot);
	52
	53	int vfs_quota_on(struct super_block *sb, int type, int format_id,
	54	char *path, int remount);
f55abc0f JK	55	int vfs_quota_enable(struct inode *inode, int type, int format_id,
f55abc0f JK	56	unsigned int flags);
77e69dac AV	57	int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
77e69dac AV	58	struct path *path);
b85f4b87 JK	59	int vfs_quota_on_mount(struct super_block sb, char qf_name,
	60	int format_id, int type);
	61	int vfs_quota_off(struct super_block *sb, int type, int remount);
f55abc0f	62	int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
b85f4b87 JK	63	int vfs_quota_sync(struct super_block *sb, int type);
	64	int vfs_get_dqinfo(struct super_block sb, int type, struct if_dqinfo ii);
	65	int vfs_set_dqinfo(struct super_block sb, int type, struct if_dqinfo ii);
	66	int vfs_get_dqblk(struct super_block sb, int type, qid_t id, struct if_dqblk di);
	67	int vfs_set_dqblk(struct super_block sb, int type, qid_t id, struct if_dqblk di);
	68
	69	void vfs_dq_drop(struct inode *inode);
	70	int vfs_dq_transfer(struct inode inode, struct iattr iattr);
	71	int vfs_dq_quota_on_remount(struct super_block *sb);
1da177e4	72
03b06343 JK	73	static inline struct mem_dqinfo sb_dqinfo(struct super_block sb, int type)
	74	{
	75	return sb_dqopt(sb)->info + type;
	76	}
74abb989 JK	77
	78	/*
	79	* Functions for checking status of quota
	80	*/
	81
f55abc0f	82	static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
03b06343	83	{
f55abc0f JK	84	return sb_dqopt(sb)->flags &
f55abc0f JK	85	dquot_state_flag(DQUOT_USAGE_ENABLED, type);
03b06343	86	}
74abb989	87
f55abc0f	88	static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
03b06343	89	{
f55abc0f JK	90	return sb_dqopt(sb)->flags &
f55abc0f JK	91	dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
03b06343	92	}
74abb989	93
03b06343 JK	94	static inline int sb_has_quota_suspended(struct super_block *sb, int type)
03b06343 JK	95	{
f55abc0f JK	96	return sb_dqopt(sb)->flags &
f55abc0f JK	97	dquot_state_flag(DQUOT_SUSPENDED, type);
03b06343	98	}
74abb989	99
03b06343 JK	100	static inline int sb_any_quota_suspended(struct super_block *sb)
	101	{
	102	return sb_has_quota_suspended(sb, USRQUOTA) \|\|
	103	sb_has_quota_suspended(sb, GRPQUOTA);
	104	}
74abb989	105
f55abc0f JK	106	/* Does kernel know about any quota information for given sb + type? */
	107	static inline int sb_has_quota_loaded(struct super_block *sb, int type)
	108	{
	109	/* Currently if anything is on, then quota usage is on as well */
	110	return sb_has_quota_usage_enabled(sb, type);
	111	}
	112
	113	static inline int sb_any_quota_loaded(struct super_block *sb)
	114	{
	115	return sb_has_quota_loaded(sb, USRQUOTA) \|\|
	116	sb_has_quota_loaded(sb, GRPQUOTA);
	117	}
	118
	119	static inline int sb_has_quota_active(struct super_block *sb, int type)
	120	{
	121	return sb_has_quota_loaded(sb, type) &&
	122	!sb_has_quota_suspended(sb, type);
	123	}
	124
	125	static inline int sb_any_quota_active(struct super_block *sb)
	126	{
	127	return sb_has_quota_active(sb, USRQUOTA) \|\|
	128	sb_has_quota_active(sb, GRPQUOTA);
	129	}
	130
1da177e4 LT	131	/*
	132	* Operations supported for diskquotas.
	133	*/
	134	extern struct dquot_operations dquot_operations;
	135	extern struct quotactl_ops vfs_quotactl_ops;
	136
	137	#define sb_dquot_ops (&dquot_operations)
	138	#define sb_quotactl_ops (&vfs_quotactl_ops)
	139
	140	/* It is better to call this function outside of any transaction as it might
	141	* need a lot of space in journal for dquot structure allocation. */
b85f4b87	142	static inline void vfs_dq_init(struct inode *inode)
1da177e4 LT	143	{
1da177e4 LT	144	BUG_ON(!inode->i_sb);
f55abc0f	145	if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
1da177e4 LT	146	inode->i_sb->dq_op->initialize(inode, -1);
	147	}
	148
1da177e4 LT	149	/* The following allocation/freeing/transfer functions must be called inside
1da177e4 LT	150	* a transaction (deadlocks possible otherwise) */
b85f4b87	151	static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4	152	{
f55abc0f	153	if (sb_any_quota_active(inode->i_sb)) {
1da177e4 LT	154	/* Used space is updated in alloc_space() */
	155	if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
	156	return 1;
	157	}
	158	else
	159	inode_add_bytes(inode, nr);
	160	return 0;
	161	}
	162
b85f4b87	163	static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
1da177e4 LT	164	{
1da177e4 LT	165	int ret;
b85f4b87	166	if (!(ret = vfs_dq_prealloc_space_nodirty(inode, nr)))
1da177e4 LT	167	mark_inode_dirty(inode);
	168	return ret;
	169	}
	170
b85f4b87	171	static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4	172	{
f55abc0f	173	if (sb_any_quota_active(inode->i_sb)) {
1da177e4 LT	174	/* Used space is updated in alloc_space() */
	175	if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
	176	return 1;
	177	}
	178	else
	179	inode_add_bytes(inode, nr);
	180	return 0;
	181	}
	182
b85f4b87	183	static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
1da177e4 LT	184	{
1da177e4 LT	185	int ret;
b85f4b87	186	if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
1da177e4 LT	187	mark_inode_dirty(inode);
	188	return ret;
	189	}
	190
f18df228 MC	191	static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
	192	{
	193	if (sb_any_quota_active(inode->i_sb)) {
	194	/* Used space is updated in alloc_space() */
	195	if (inode->i_sb->dq_op->reserve_space(inode, nr, 0) == NO_QUOTA)
	196	return 1;
	197	}
	198	return 0;
	199	}
	200
b85f4b87	201	static inline int vfs_dq_alloc_inode(struct inode *inode)
1da177e4	202	{
f55abc0f	203	if (sb_any_quota_active(inode->i_sb)) {
b85f4b87	204	vfs_dq_init(inode);
1da177e4 LT	205	if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
	206	return 1;
	207	}
	208	return 0;
	209	}
	210
740d9dcd MC	211	/*
	212	* Convert in-memory reserved quotas to real consumed quotas
	213	*/
	214	static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
	215	{
	216	if (sb_any_quota_active(inode->i_sb)) {
	217	if (inode->i_sb->dq_op->claim_space(inode, nr) == NO_QUOTA)
	218	return 1;
	219	} else
	220	inode_add_bytes(inode, nr);
	221
	222	mark_inode_dirty(inode);
	223	return 0;
	224	}
	225
	226	/*
	227	* Release reserved (in-memory) quotas
	228	*/
	229	static inline
	230	void vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
	231	{
	232	if (sb_any_quota_active(inode->i_sb))
	233	inode->i_sb->dq_op->release_rsv(inode, nr);
	234	}
	235
b85f4b87	236	static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4	237	{
f55abc0f	238	if (sb_any_quota_active(inode->i_sb))
1da177e4 LT	239	inode->i_sb->dq_op->free_space(inode, nr);
	240	else
	241	inode_sub_bytes(inode, nr);
	242	}
	243
b85f4b87	244	static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
1da177e4	245	{
b85f4b87	246	vfs_dq_free_space_nodirty(inode, nr);
1da177e4 LT	247	mark_inode_dirty(inode);
	248	}
	249
b85f4b87	250	static inline void vfs_dq_free_inode(struct inode *inode)
1da177e4	251	{
f55abc0f	252	if (sb_any_quota_active(inode->i_sb))
1da177e4 LT	253	inode->i_sb->dq_op->free_inode(inode, 1);
	254	}
	255
1da177e4	256	/* The following two functions cannot be called inside a transaction */
b85f4b87	257	static inline void vfs_dq_sync(struct super_block *sb)
03f6e92b JK	258	{
	259	sync_dquots(sb, -1);
	260	}
1da177e4	261
b85f4b87	262	static inline int vfs_dq_off(struct super_block *sb, int remount)
1da177e4 LT	263	{
	264	int ret = -ENOSYS;
	265
0ff5af83 JK	266	if (sb->s_qcop && sb->s_qcop->quota_off)
	267	ret = sb->s_qcop->quota_off(sb, -1, remount);
	268	return ret;
	269	}
	270
1da177e4 LT	271	#else
1da177e4 LT	272
f55abc0f	273	static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
03b06343 JK	274	{
	275	return 0;
	276	}
	277
f55abc0f	278	static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
03b06343 JK	279	{
	280	return 0;
	281	}
	282
	283	static inline int sb_has_quota_suspended(struct super_block *sb, int type)
	284	{
	285	return 0;
	286	}
	287
	288	static inline int sb_any_quota_suspended(struct super_block *sb)
	289	{
	290	return 0;
	291	}
74abb989	292
f55abc0f JK	293	/* Does kernel know about any quota information for given sb + type? */
	294	static inline int sb_has_quota_loaded(struct super_block *sb, int type)
	295	{
	296	return 0;
	297	}
	298
	299	static inline int sb_any_quota_loaded(struct super_block *sb)
	300	{
	301	return 0;
	302	}
	303
	304	static inline int sb_has_quota_active(struct super_block *sb, int type)
	305	{
	306	return 0;
	307	}
	308
	309	static inline int sb_any_quota_active(struct super_block *sb)
	310	{
	311	return 0;
	312	}
	313
1da177e4 LT	314	/*
	315	* NO-OP when quota not configured.
	316	*/
	317	#define sb_dquot_ops (NULL)
	318	#define sb_quotactl_ops (NULL)
50f8c370	319
b85f4b87	320	static inline void vfs_dq_init(struct inode *inode)
50f8c370 AM	321	{
	322	}
	323
b85f4b87	324	static inline void vfs_dq_drop(struct inode *inode)
50f8c370 AM	325	{
	326	}
	327
b85f4b87	328	static inline int vfs_dq_alloc_inode(struct inode *inode)
50f8c370 AM	329	{
	330	return 0;
	331	}
	332
b85f4b87	333	static inline void vfs_dq_free_inode(struct inode *inode)
50f8c370 AM	334	{
	335	}
	336
b85f4b87	337	static inline void vfs_dq_sync(struct super_block *sb)
50f8c370 AM	338	{
	339	}
	340
b85f4b87	341	static inline int vfs_dq_off(struct super_block *sb, int remount)
50f8c370 AM	342	{
	343	return 0;
	344	}
	345
b85f4b87	346	static inline int vfs_dq_quota_on_remount(struct super_block *sb)
50f8c370 AM	347	{
	348	return 0;
	349	}
	350
b85f4b87	351	static inline int vfs_dq_transfer(struct inode inode, struct iattr iattr)
50f8c370 AM	352	{
	353	return 0;
	354	}
	355
b85f4b87	356	static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	357	{
	358	inode_add_bytes(inode, nr);
	359	return 0;
	360	}
	361
b85f4b87	362	static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
1da177e4	363	{
b85f4b87	364	vfs_dq_prealloc_space_nodirty(inode, nr);
1da177e4 LT	365	mark_inode_dirty(inode);
	366	return 0;
	367	}
	368
b85f4b87	369	static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	370	{
	371	inode_add_bytes(inode, nr);
	372	return 0;
	373	}
	374
b85f4b87	375	static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
1da177e4	376	{
b85f4b87	377	vfs_dq_alloc_space_nodirty(inode, nr);
1da177e4 LT	378	mark_inode_dirty(inode);
	379	return 0;
	380	}
	381
f18df228 MC	382	static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
	383	{
	384	return 0;
	385	}
	386
740d9dcd MC	387	static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
	388	{
	389	return vfs_dq_alloc_space(inode, nr);
	390	}
	391
	392	static inline
	393	int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
	394	{
	395	return 0;
	396	}
	397
b85f4b87	398	static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
1da177e4 LT	399	{
	400	inode_sub_bytes(inode, nr);
	401	}
	402
b85f4b87	403	static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
1da177e4	404	{
b85f4b87	405	vfs_dq_free_space_nodirty(inode, nr);
1da177e4 LT	406	mark_inode_dirty(inode);
	407	}
	408
	409	#endif /* CONFIG_QUOTA */
	410
b85f4b87	411	static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
03f6e92b	412	{
9900ba34	413	return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
03f6e92b JK	414	}
03f6e92b JK	415
b85f4b87	416	static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
03f6e92b	417	{
9900ba34	418	return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
03f6e92b JK	419	}
03f6e92b JK	420
b85f4b87	421	static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
03f6e92b	422	{
9900ba34	423	return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
03f6e92b JK	424	}
03f6e92b JK	425
b85f4b87	426	static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
03f6e92b	427	{
9900ba34	428	return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
03f6e92b JK	429	}
03f6e92b JK	430
f18df228 MC	431	static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
f18df228 MC	432	{
9900ba34	433	return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
f18df228 MC	434	}
f18df228 MC	435
740d9dcd MC	436	static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
740d9dcd MC	437	{
9900ba34	438	return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
740d9dcd MC	439	}
	440
	441	static inline
	442	void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
	443	{
	444	vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
	445	}
	446
b85f4b87	447	static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
03f6e92b	448	{
9900ba34	449	vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
03f6e92b JK	450	}
03f6e92b JK	451
b85f4b87	452	static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
03f6e92b	453	{
9900ba34	454	vfs_dq_free_space(inode, nr << inode->i_blkbits);
03f6e92b	455	}
1da177e4 LT	456
1da177e4 LT	457	#endif /* _LINUX_QUOTAOPS_ */