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