Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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/smp_lock.h>
11#include <linux/fs.h>
12
13static inline struct quota_info *sb_dqopt(struct super_block *sb)
14{
15 return &sb->s_dquot;
16}
17
18#if defined(CONFIG_QUOTA)
19
20/*
21 * declaration of quota_function calls in kernel.
22 */
23void sync_dquots(struct super_block *sb, int type);
24
25int dquot_initialize(struct inode *inode, int type);
26int dquot_drop(struct inode *inode);
27struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
28void dqput(struct dquot *dquot);
29int dquot_scan_active(struct super_block *sb,
30 int (*fn)(struct dquot *dquot, unsigned long priv),
31 unsigned long priv);
32struct dquot *dquot_alloc(struct super_block *sb, int type);
33void dquot_destroy(struct dquot *dquot);
34
35int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
36int dquot_alloc_inode(const struct inode *inode, qsize_t number);
37
38int dquot_free_space(struct inode *inode, qsize_t number);
39int dquot_free_inode(const struct inode *inode, qsize_t number);
40
41int dquot_transfer(struct inode *inode, struct iattr *iattr);
42int dquot_commit(struct dquot *dquot);
43int dquot_acquire(struct dquot *dquot);
44int dquot_release(struct dquot *dquot);
45int dquot_commit_info(struct super_block *sb, int type);
46int dquot_mark_dquot_dirty(struct dquot *dquot);
47
48int vfs_quota_on(struct super_block *sb, int type, int format_id,
49 char *path, int remount);
50int vfs_quota_enable(struct inode *inode, int type, int format_id,
51 unsigned int flags);
52int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
53 struct path *path);
54int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
55 int format_id, int type);
56int vfs_quota_off(struct super_block *sb, int type, int remount);
57int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
58int vfs_quota_sync(struct super_block *sb, int type);
59int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
60int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
61int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
62int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
63
64void vfs_dq_drop(struct inode *inode);
65int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
66int vfs_dq_quota_on_remount(struct super_block *sb);
67
68static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
69{
70 return sb_dqopt(sb)->info + type;
71}
72
73/*
74 * Functions for checking status of quota
75 */
76
77static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
78{
79 return sb_dqopt(sb)->flags &
80 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
81}
82
83static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
84{
85 return sb_dqopt(sb)->flags &
86 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
87}
88
89static inline int sb_has_quota_suspended(struct super_block *sb, int type)
90{
91 return sb_dqopt(sb)->flags &
92 dquot_state_flag(DQUOT_SUSPENDED, type);
93}
94
95static inline int sb_any_quota_suspended(struct super_block *sb)
96{
97 return sb_has_quota_suspended(sb, USRQUOTA) ||
98 sb_has_quota_suspended(sb, GRPQUOTA);
99}
100
101/* Does kernel know about any quota information for given sb + type? */
102static inline int sb_has_quota_loaded(struct super_block *sb, int type)
103{
104 /* Currently if anything is on, then quota usage is on as well */
105 return sb_has_quota_usage_enabled(sb, type);
106}
107
108static inline int sb_any_quota_loaded(struct super_block *sb)
109{
110 return sb_has_quota_loaded(sb, USRQUOTA) ||
111 sb_has_quota_loaded(sb, GRPQUOTA);
112}
113
114static inline int sb_has_quota_active(struct super_block *sb, int type)
115{
116 return sb_has_quota_loaded(sb, type) &&
117 !sb_has_quota_suspended(sb, type);
118}
119
120static inline int sb_any_quota_active(struct super_block *sb)
121{
122 return sb_has_quota_active(sb, USRQUOTA) ||
123 sb_has_quota_active(sb, GRPQUOTA);
124}
125
126/*
127 * Operations supported for diskquotas.
128 */
129extern struct dquot_operations dquot_operations;
130extern struct quotactl_ops vfs_quotactl_ops;
131
132#define sb_dquot_ops (&dquot_operations)
133#define sb_quotactl_ops (&vfs_quotactl_ops)
134
135/* It is better to call this function outside of any transaction as it might
136 * need a lot of space in journal for dquot structure allocation. */
137static inline void vfs_dq_init(struct inode *inode)
138{
139 BUG_ON(!inode->i_sb);
140 if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
141 inode->i_sb->dq_op->initialize(inode, -1);
142}
143
144/* The following allocation/freeing/transfer functions *must* be called inside
145 * a transaction (deadlocks possible otherwise) */
146static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
147{
148 if (sb_any_quota_active(inode->i_sb)) {
149 /* Used space is updated in alloc_space() */
150 if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
151 return 1;
152 }
153 else
154 inode_add_bytes(inode, nr);
155 return 0;
156}
157
158static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
159{
160 int ret;
161 if (!(ret = vfs_dq_prealloc_space_nodirty(inode, nr)))
162 mark_inode_dirty(inode);
163 return ret;
164}
165
166static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
167{
168 if (sb_any_quota_active(inode->i_sb)) {
169 /* Used space is updated in alloc_space() */
170 if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
171 return 1;
172 }
173 else
174 inode_add_bytes(inode, nr);
175 return 0;
176}
177
178static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
179{
180 int ret;
181 if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
182 mark_inode_dirty(inode);
183 return ret;
184}
185
186static inline int vfs_dq_alloc_inode(struct inode *inode)
187{
188 if (sb_any_quota_active(inode->i_sb)) {
189 vfs_dq_init(inode);
190 if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
191 return 1;
192 }
193 return 0;
194}
195
196static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
197{
198 if (sb_any_quota_active(inode->i_sb))
199 inode->i_sb->dq_op->free_space(inode, nr);
200 else
201 inode_sub_bytes(inode, nr);
202}
203
204static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
205{
206 vfs_dq_free_space_nodirty(inode, nr);
207 mark_inode_dirty(inode);
208}
209
210static inline void vfs_dq_free_inode(struct inode *inode)
211{
212 if (sb_any_quota_active(inode->i_sb))
213 inode->i_sb->dq_op->free_inode(inode, 1);
214}
215
216/* The following two functions cannot be called inside a transaction */
217static inline void vfs_dq_sync(struct super_block *sb)
218{
219 sync_dquots(sb, -1);
220}
221
222static inline int vfs_dq_off(struct super_block *sb, int remount)
223{
224 int ret = -ENOSYS;
225
226 if (sb->s_qcop && sb->s_qcop->quota_off)
227 ret = sb->s_qcop->quota_off(sb, -1, remount);
228 return ret;
229}
230
231#else
232
233static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
234{
235 return 0;
236}
237
238static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
239{
240 return 0;
241}
242
243static inline int sb_has_quota_suspended(struct super_block *sb, int type)
244{
245 return 0;
246}
247
248static inline int sb_any_quota_suspended(struct super_block *sb)
249{
250 return 0;
251}
252
253/* Does kernel know about any quota information for given sb + type? */
254static inline int sb_has_quota_loaded(struct super_block *sb, int type)
255{
256 return 0;
257}
258
259static inline int sb_any_quota_loaded(struct super_block *sb)
260{
261 return 0;
262}
263
264static inline int sb_has_quota_active(struct super_block *sb, int type)
265{
266 return 0;
267}
268
269static inline int sb_any_quota_active(struct super_block *sb)
270{
271 return 0;
272}
273
274/*
275 * NO-OP when quota not configured.
276 */
277#define sb_dquot_ops (NULL)
278#define sb_quotactl_ops (NULL)
279
280static inline void vfs_dq_init(struct inode *inode)
281{
282}
283
284static inline void vfs_dq_drop(struct inode *inode)
285{
286}
287
288static inline int vfs_dq_alloc_inode(struct inode *inode)
289{
290 return 0;
291}
292
293static inline void vfs_dq_free_inode(struct inode *inode)
294{
295}
296
297static inline void vfs_dq_sync(struct super_block *sb)
298{
299}
300
301static inline int vfs_dq_off(struct super_block *sb, int remount)
302{
303 return 0;
304}
305
306static inline int vfs_dq_quota_on_remount(struct super_block *sb)
307{
308 return 0;
309}
310
311static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
312{
313 return 0;
314}
315
316static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
317{
318 inode_add_bytes(inode, nr);
319 return 0;
320}
321
322static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
323{
324 vfs_dq_prealloc_space_nodirty(inode, nr);
325 mark_inode_dirty(inode);
326 return 0;
327}
328
329static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
330{
331 inode_add_bytes(inode, nr);
332 return 0;
333}
334
335static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
336{
337 vfs_dq_alloc_space_nodirty(inode, nr);
338 mark_inode_dirty(inode);
339 return 0;
340}
341
342static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
343{
344 inode_sub_bytes(inode, nr);
345}
346
347static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
348{
349 vfs_dq_free_space_nodirty(inode, nr);
350 mark_inode_dirty(inode);
351}
352
353#endif /* CONFIG_QUOTA */
354
355static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
356{
357 return vfs_dq_prealloc_space_nodirty(inode,
358 nr << inode->i_sb->s_blocksize_bits);
359}
360
361static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
362{
363 return vfs_dq_prealloc_space(inode,
364 nr << inode->i_sb->s_blocksize_bits);
365}
366
367static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
368{
369 return vfs_dq_alloc_space_nodirty(inode,
370 nr << inode->i_sb->s_blocksize_bits);
371}
372
373static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
374{
375 return vfs_dq_alloc_space(inode,
376 nr << inode->i_sb->s_blocksize_bits);
377}
378
379static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
380{
381 vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
382}
383
384static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
385{
386 vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
387}
388
389/*
390 * Define uppercase equivalents for compatibility with old function names
391 * Can go away when we think all users have been converted (15/04/2008)
392 */
393#define DQUOT_INIT(inode) vfs_dq_init(inode)
394#define DQUOT_DROP(inode) vfs_dq_drop(inode)
395#define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
396 vfs_dq_prealloc_space_nodirty(inode, nr)
397#define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
398#define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
399 vfs_dq_alloc_space_nodirty(inode, nr)
400#define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
401#define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
402 vfs_dq_prealloc_block_nodirty(inode, nr)
403#define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
404#define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
405 vfs_dq_alloc_block_nodirty(inode, nr)
406#define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
407#define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
408#define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
409 vfs_dq_free_space_nodirty(inode, nr)
410#define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
411#define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
412 vfs_dq_free_block_nodirty(inode, nr)
413#define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
414#define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
415#define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
416#define DQUOT_SYNC(sb) vfs_dq_sync(sb)
417#define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
418#define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
419
420#endif /* _LINUX_QUOTAOPS_ */