[linux-2.6-block.git] / include / linux / quotaops.h

/* SPDX-License-Identifier: GPL-2.0 */
/*
 * 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/fs.h>

#define DQUOT_SPACE_WARN	0x1
#define DQUOT_SPACE_RESERVE	0x2
#define DQUOT_SPACE_NOFAIL	0x4

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

/* i_mutex must being held */
static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
{
	return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
		(ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
		(ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
}

int kernel_quotactl(unsigned int cmd, const char __user *special,
		    qid_t id, void __user *addr);

#if defined(CONFIG_QUOTA)

#define quota_error(sb, fmt, args...) \
	__quota_error((sb), __func__, fmt , ## args)

extern __printf(3, 4)
void __quota_error(struct super_block *sb, const char *func,
		   const char *fmt, ...);

/*
 * declaration of quota_function calls in kernel.
 */
int dquot_initialize(struct inode *inode);
bool dquot_initialize_needed(struct inode *inode);
void dquot_drop(struct inode *inode);
struct dquot *dqget(struct super_block *sb, struct kqid qid);
static inline struct dquot *dqgrab(struct dquot *dquot)
{
	/* Make sure someone else has active reference to dquot */
	WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
	WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
	atomic_inc(&dquot->dq_count);
	return dquot;
}
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 flags);
void __dquot_free_space(struct inode *inode, qsize_t number, int flags);

int dquot_alloc_inode(struct inode *inode);

int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
void dquot_free_inode(struct inode *inode);
void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);

int dquot_disable(struct super_block *sb, int type, unsigned int flags);
/* Suspend quotas on remount RO */
static inline int dquot_suspend(struct super_block *sb, int type)
{
	return dquot_disable(sb, type, DQUOT_SUSPENDED);
}
int dquot_resume(struct super_block *sb, int type);

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_get_next_id(struct super_block *sb, struct kqid *qid);
int dquot_mark_dquot_dirty(struct dquot *dquot);

int dquot_file_open(struct inode *inode, struct file *file);

int dquot_enable(struct inode *inode, int type, int format_id,
	unsigned int flags);
int dquot_quota_on(struct super_block *sb, int type, int format_id,
	const struct path *path);
int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
 	int format_id, int type);
int dquot_quota_off(struct super_block *sb, int type);
int dquot_writeback_dquots(struct super_block *sb, int type);
int dquot_quota_sync(struct super_block *sb, int type);
int dquot_get_state(struct super_block *sb, struct qc_state *state);
int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
int dquot_get_dqblk(struct super_block *sb, struct kqid id,
		struct qc_dqblk *di);
int dquot_get_next_dqblk(struct super_block *sb, struct kqid *id,
		struct qc_dqblk *di);
int dquot_set_dqblk(struct super_block *sb, struct kqid id,
		struct qc_dqblk *di);

int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
int dquot_transfer(struct inode *inode, struct iattr *iattr);

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 bool 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 bool 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 bool sb_has_quota_suspended(struct super_block *sb, int type)
{
	return sb_dqopt(sb)->flags &
				dquot_state_flag(DQUOT_SUSPENDED, type);
}

static inline unsigned sb_any_quota_suspended(struct super_block *sb)
{
	return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
}

/* Does kernel know about any quota information for given sb + type? */
static inline bool 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 unsigned sb_any_quota_loaded(struct super_block *sb)
{
	return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
}

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

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

#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 dquot_initialize(struct inode *inode)
{
	return 0;
}

static inline bool dquot_initialize_needed(struct inode *inode)
{
	return false;
}

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

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

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

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

static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
		int flags)
{
	if (!(flags & DQUOT_SPACE_RESERVE))
		inode_add_bytes(inode, number);
	return 0;
}

static inline void __dquot_free_space(struct inode *inode, qsize_t number,
		int flags)
{
	if (!(flags & DQUOT_SPACE_RESERVE))
		inode_sub_bytes(inode, number);
}

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

static inline int dquot_reclaim_space_nodirty(struct inode *inode,
					      qsize_t number)
{
	inode_sub_bytes(inode, number);
	return 0;
}

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

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

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

#define dquot_file_open		generic_file_open

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

#endif /* CONFIG_QUOTA */

static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
{
	return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
}

static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
{
	__dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
	mark_inode_dirty_sync(inode);
}

static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
{
	int ret;

	ret = dquot_alloc_space_nodirty(inode, nr);
	if (!ret) {
		/*
		 * Mark inode fully dirty. Since we are allocating blocks, inode
		 * would become fully dirty soon anyway and it reportedly
		 * reduces lock contention.
		 */
		mark_inode_dirty(inode);
	}
	return ret;
}

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

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

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

static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
{
	return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
}

static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
{
	int ret;

	ret = dquot_prealloc_block_nodirty(inode, nr);
	if (!ret)
		mark_inode_dirty_sync(inode);
	return ret;
}

static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
{
	return __dquot_alloc_space(inode, nr << inode->i_blkbits,
				DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
}

static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
{
	int ret;

	ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
	if (!ret)
		mark_inode_dirty_sync(inode);
	return ret;
}

static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
{
	dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
	mark_inode_dirty_sync(inode);
}

static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
{
	__dquot_free_space(inode, nr, 0);
}

static inline void dquot_free_space(struct inode *inode, qsize_t nr)
{
	dquot_free_space_nodirty(inode, nr);
	mark_inode_dirty_sync(inode);
}

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

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

static inline void dquot_release_reservation_block(struct inode *inode,
		qsize_t nr)
{
	__dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
}

unsigned int qtype_enforce_flag(int type);

#endif /* _LINUX_QUOTAOPS_ */
Commit	Line	Data
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/*
	3	* Definitions for diskquota-operations. When diskquota is configured these
	4	* macros expand to the right source-code.
	5	*
	6	* Author: Marco van Wieringen <mvw@planets.elm.net>
	7	*/
	8	#ifndef _LINUX_QUOTAOPS_
	9	#define _LINUX_QUOTAOPS_
	10
	11	#include <linux/fs.h>
	12
	13	#define DQUOT_SPACE_WARN 0x1
	14	#define DQUOT_SPACE_RESERVE 0x2
	15	#define DQUOT_SPACE_NOFAIL 0x4
	16
	17	static inline struct quota_info sb_dqopt(struct super_block sb)
	18	{
	19	return &sb->s_dquot;
	20	}
	21
	22	/* i_mutex must being held */
	23	static inline bool is_quota_modification(struct inode inode, struct iattr ia)
	24	{
	25	return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) \|\|
	26	(ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) \|\|
	27	(ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
	28	}
	29
	30	int kernel_quotactl(unsigned int cmd, const char __user *special,
	31	qid_t id, void __user *addr);
	32
	33	#if defined(CONFIG_QUOTA)
	34
	35	#define quota_error(sb, fmt, args...) \
	36	__quota_error((sb), __func__, fmt , ## args)
	37
	38	extern __printf(3, 4)
	39	void __quota_error(struct super_block sb, const char func,
	40	const char *fmt, ...);
	41
	42	/*
	43	* declaration of quota_function calls in kernel.
	44	*/
	45	int dquot_initialize(struct inode *inode);
	46	bool dquot_initialize_needed(struct inode *inode);
	47	void dquot_drop(struct inode *inode);
	48	struct dquot dqget(struct super_block sb, struct kqid qid);
	49	static inline struct dquot dqgrab(struct dquot dquot)
	50	{
	51	/* Make sure someone else has active reference to dquot */
	52	WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
	53	WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
	54	atomic_inc(&dquot->dq_count);
	55	return dquot;
	56	}
	57	void dqput(struct dquot *dquot);
	58	int dquot_scan_active(struct super_block *sb,
	59	int (fn)(struct dquot dquot, unsigned long priv),
	60	unsigned long priv);
	61	struct dquot dquot_alloc(struct super_block sb, int type);
	62	void dquot_destroy(struct dquot *dquot);
	63
	64	int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
	65	void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
	66
	67	int dquot_alloc_inode(struct inode *inode);
	68
	69	int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
	70	void dquot_free_inode(struct inode *inode);
	71	void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
	72
	73	int dquot_disable(struct super_block *sb, int type, unsigned int flags);
	74	/* Suspend quotas on remount RO */
	75	static inline int dquot_suspend(struct super_block *sb, int type)
	76	{
	77	return dquot_disable(sb, type, DQUOT_SUSPENDED);
	78	}
	79	int dquot_resume(struct super_block *sb, int type);
	80
	81	int dquot_commit(struct dquot *dquot);
	82	int dquot_acquire(struct dquot *dquot);
	83	int dquot_release(struct dquot *dquot);
	84	int dquot_commit_info(struct super_block *sb, int type);
	85	int dquot_get_next_id(struct super_block sb, struct kqid qid);
	86	int dquot_mark_dquot_dirty(struct dquot *dquot);
	87
	88	int dquot_file_open(struct inode inode, struct file file);
	89
	90	int dquot_enable(struct inode *inode, int type, int format_id,
	91	unsigned int flags);
	92	int dquot_quota_on(struct super_block *sb, int type, int format_id,
	93	const struct path *path);
	94	int dquot_quota_on_mount(struct super_block sb, char qf_name,
	95	int format_id, int type);
	96	int dquot_quota_off(struct super_block *sb, int type);
	97	int dquot_writeback_dquots(struct super_block *sb, int type);
	98	int dquot_quota_sync(struct super_block *sb, int type);
	99	int dquot_get_state(struct super_block sb, struct qc_state state);
	100	int dquot_set_dqinfo(struct super_block sb, int type, struct qc_info ii);
	101	int dquot_get_dqblk(struct super_block *sb, struct kqid id,
	102	struct qc_dqblk *di);
	103	int dquot_get_next_dqblk(struct super_block sb, struct kqid id,
	104	struct qc_dqblk *di);
	105	int dquot_set_dqblk(struct super_block *sb, struct kqid id,
	106	struct qc_dqblk *di);
	107
	108	int __dquot_transfer(struct inode inode, struct dquot *transfer_to);
	109	int dquot_transfer(struct inode inode, struct iattr iattr);
	110
	111	static inline struct mem_dqinfo sb_dqinfo(struct super_block sb, int type)
	112	{
	113	return sb_dqopt(sb)->info + type;
	114	}
	115
	116	/*
	117	* Functions for checking status of quota
	118	*/
	119
	120	static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
	121	{
	122	return sb_dqopt(sb)->flags &
	123	dquot_state_flag(DQUOT_USAGE_ENABLED, type);
	124	}
	125
	126	static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
	127	{
	128	return sb_dqopt(sb)->flags &
	129	dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
	130	}
	131
	132	static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
	133	{
	134	return sb_dqopt(sb)->flags &
	135	dquot_state_flag(DQUOT_SUSPENDED, type);
	136	}
	137
	138	static inline unsigned sb_any_quota_suspended(struct super_block *sb)
	139	{
	140	return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
	141	}
	142
	143	/* Does kernel know about any quota information for given sb + type? */
	144	static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
	145	{
	146	/* Currently if anything is on, then quota usage is on as well */
	147	return sb_has_quota_usage_enabled(sb, type);
	148	}
	149
	150	static inline unsigned sb_any_quota_loaded(struct super_block *sb)
	151	{
	152	return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
	153	}
	154
	155	static inline bool sb_has_quota_active(struct super_block *sb, int type)
	156	{
	157	return sb_has_quota_loaded(sb, type) &&
	158	!sb_has_quota_suspended(sb, type);
	159	}
	160
	161	/*
	162	* Operations supported for diskquotas.
	163	*/
	164	extern const struct dquot_operations dquot_operations;
	165	extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
	166
	167	#else
	168
	169	static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
	170	{
	171	return 0;
	172	}
	173
	174	static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
	175	{
	176	return 0;
	177	}
	178
	179	static inline int sb_has_quota_suspended(struct super_block *sb, int type)
	180	{
	181	return 0;
	182	}
	183
	184	static inline int sb_any_quota_suspended(struct super_block *sb)
	185	{
	186	return 0;
	187	}
	188
	189	/* Does kernel know about any quota information for given sb + type? */
	190	static inline int sb_has_quota_loaded(struct super_block *sb, int type)
	191	{
	192	return 0;
	193	}
	194
	195	static inline int sb_any_quota_loaded(struct super_block *sb)
	196	{
	197	return 0;
	198	}
	199
	200	static inline int sb_has_quota_active(struct super_block *sb, int type)
	201	{
	202	return 0;
	203	}
	204
	205	static inline int dquot_initialize(struct inode *inode)
	206	{
	207	return 0;
	208	}
	209
	210	static inline bool dquot_initialize_needed(struct inode *inode)
	211	{
	212	return false;
	213	}
	214
	215	static inline void dquot_drop(struct inode *inode)
	216	{
	217	}
	218
	219	static inline int dquot_alloc_inode(struct inode *inode)
	220	{
	221	return 0;
	222	}
	223
	224	static inline void dquot_free_inode(struct inode *inode)
	225	{
	226	}
	227
	228	static inline int dquot_transfer(struct inode inode, struct iattr iattr)
	229	{
	230	return 0;
	231	}
	232
	233	static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
	234	int flags)
	235	{
	236	if (!(flags & DQUOT_SPACE_RESERVE))
	237	inode_add_bytes(inode, number);
	238	return 0;
	239	}
	240
	241	static inline void __dquot_free_space(struct inode *inode, qsize_t number,
	242	int flags)
	243	{
	244	if (!(flags & DQUOT_SPACE_RESERVE))
	245	inode_sub_bytes(inode, number);
	246	}
	247
	248	static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
	249	{
	250	inode_add_bytes(inode, number);
	251	return 0;
	252	}
	253
	254	static inline int dquot_reclaim_space_nodirty(struct inode *inode,
	255	qsize_t number)
	256	{
	257	inode_sub_bytes(inode, number);
	258	return 0;
	259	}
	260
	261	static inline int dquot_disable(struct super_block *sb, int type,
	262	unsigned int flags)
	263	{
	264	return 0;
	265	}
	266
	267	static inline int dquot_suspend(struct super_block *sb, int type)
	268	{
	269	return 0;
	270	}
	271
	272	static inline int dquot_resume(struct super_block *sb, int type)
	273	{
	274	return 0;
	275	}
	276
	277	#define dquot_file_open generic_file_open
	278
	279	static inline int dquot_writeback_dquots(struct super_block *sb, int type)
	280	{
	281	return 0;
	282	}
	283
	284	#endif /* CONFIG_QUOTA */
	285
	286	static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
	287	{
	288	return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
	289	}
	290
	291	static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
	292	{
	293	__dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN\|DQUOT_SPACE_NOFAIL);
	294	mark_inode_dirty_sync(inode);
	295	}
	296
	297	static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
	298	{
	299	int ret;
	300
	301	ret = dquot_alloc_space_nodirty(inode, nr);
	302	if (!ret) {
	303	/*
	304	* Mark inode fully dirty. Since we are allocating blocks, inode
	305	* would become fully dirty soon anyway and it reportedly
	306	* reduces lock contention.
	307	*/
	308	mark_inode_dirty(inode);
	309	}
	310	return ret;
	311	}
	312
	313	static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
	314	{
	315	return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
	316	}
	317
	318	static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
	319	{
	320	dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
	321	}
	322
	323	static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
	324	{
	325	return dquot_alloc_space(inode, nr << inode->i_blkbits);
	326	}
	327
	328	static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
	329	{
	330	return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
	331	}
	332
	333	static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
	334	{
	335	int ret;
	336
	337	ret = dquot_prealloc_block_nodirty(inode, nr);
	338	if (!ret)
	339	mark_inode_dirty_sync(inode);
	340	return ret;
	341	}
	342
	343	static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
	344	{
	345	return __dquot_alloc_space(inode, nr << inode->i_blkbits,
	346	DQUOT_SPACE_WARN\|DQUOT_SPACE_RESERVE);
	347	}
	348
	349	static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
	350	{
	351	int ret;
	352
	353	ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
	354	if (!ret)
	355	mark_inode_dirty_sync(inode);
	356	return ret;
	357	}
	358
	359	static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
	360	{
	361	dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
	362	mark_inode_dirty_sync(inode);
	363	}
	364
	365	static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
	366	{
	367	__dquot_free_space(inode, nr, 0);
	368	}
	369
	370	static inline void dquot_free_space(struct inode *inode, qsize_t nr)
	371	{
	372	dquot_free_space_nodirty(inode, nr);
	373	mark_inode_dirty_sync(inode);
	374	}
	375
	376	static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
	377	{
	378	dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
	379	}
	380
	381	static inline void dquot_free_block(struct inode *inode, qsize_t nr)
	382	{
	383	dquot_free_space(inode, nr << inode->i_blkbits);
	384	}
	385
	386	static inline void dquot_release_reservation_block(struct inode *inode,
	387	qsize_t nr)
	388	{
	389	__dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
	390	}
	391
	392	unsigned int qtype_enforce_flag(int type);
	393
	394	#endif /* _LINUX_QUOTAOPS_ */