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