quota: Remove uppercase aliases for quota functions.
[linux-2.6.git] / include / linux / quotaops.h
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
13 static 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  */
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);
27 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
28 void dqput(struct dquot *dquot);
29 int dquot_scan_active(struct super_block *sb,
30                       int (*fn)(struct dquot *dquot, unsigned long priv),
31                       unsigned long priv);
32 struct dquot *dquot_alloc(struct super_block *sb, int type);
33 void dquot_destroy(struct dquot *dquot);
34
35 int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
36 int dquot_alloc_inode(const struct inode *inode, qsize_t number);
37
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
43 int dquot_free_space(struct inode *inode, qsize_t number);
44 int dquot_free_inode(const struct inode *inode, qsize_t number);
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);
55 int vfs_quota_enable(struct inode *inode, int type, int format_id,
56         unsigned int flags);
57 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
58         struct path *path);
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);
62 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
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);
72
73 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
74 {
75         return sb_dqopt(sb)->info + type;
76 }
77
78 /*
79  * Functions for checking status of quota
80  */
81
82 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
83 {
84         return sb_dqopt(sb)->flags &
85                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
86 }
87
88 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
89 {
90         return sb_dqopt(sb)->flags &
91                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
92 }
93
94 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
95 {
96         return sb_dqopt(sb)->flags &
97                                 dquot_state_flag(DQUOT_SUSPENDED, type);
98 }
99
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 }
105
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
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. */
142 static inline void vfs_dq_init(struct inode *inode)
143 {
144         BUG_ON(!inode->i_sb);
145         if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
146                 inode->i_sb->dq_op->initialize(inode, -1);
147 }
148
149 /* The following allocation/freeing/transfer functions *must* be called inside
150  * a transaction (deadlocks possible otherwise) */
151 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
152 {
153         if (sb_any_quota_active(inode->i_sb)) {
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
163 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
164 {
165         int ret;
166         if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
167                 mark_inode_dirty(inode);
168         return ret;
169 }
170
171 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
172 {
173         if (sb_any_quota_active(inode->i_sb)) {
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
183 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
184 {
185         int ret;
186         if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
187                 mark_inode_dirty(inode);
188         return ret;
189 }
190
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
201 static inline int vfs_dq_alloc_inode(struct inode *inode)
202 {
203         if (sb_any_quota_active(inode->i_sb)) {
204                 vfs_dq_init(inode);
205                 if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
206                         return 1;
207         }
208         return 0;
209 }
210
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
236 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
237 {
238         if (sb_any_quota_active(inode->i_sb))
239                 inode->i_sb->dq_op->free_space(inode, nr);
240         else
241                 inode_sub_bytes(inode, nr);
242 }
243
244 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
245 {
246         vfs_dq_free_space_nodirty(inode, nr);
247         mark_inode_dirty(inode);
248 }
249
250 static inline void vfs_dq_free_inode(struct inode *inode)
251 {
252         if (sb_any_quota_active(inode->i_sb))
253                 inode->i_sb->dq_op->free_inode(inode, 1);
254 }
255
256 /* The following two functions cannot be called inside a transaction */
257 static inline void vfs_dq_sync(struct super_block *sb)
258 {
259         sync_dquots(sb, -1);
260 }
261
262 static inline int vfs_dq_off(struct super_block *sb, int remount)
263 {
264         int ret = -ENOSYS;
265
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
271 #else
272
273 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
274 {
275         return 0;
276 }
277
278 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
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 }
292
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
314 /*
315  * NO-OP when quota not configured.
316  */
317 #define sb_dquot_ops                            (NULL)
318 #define sb_quotactl_ops                         (NULL)
319
320 static inline void vfs_dq_init(struct inode *inode)
321 {
322 }
323
324 static inline void vfs_dq_drop(struct inode *inode)
325 {
326 }
327
328 static inline int vfs_dq_alloc_inode(struct inode *inode)
329 {
330         return 0;
331 }
332
333 static inline void vfs_dq_free_inode(struct inode *inode)
334 {
335 }
336
337 static inline void vfs_dq_sync(struct super_block *sb)
338 {
339 }
340
341 static inline int vfs_dq_off(struct super_block *sb, int remount)
342 {
343         return 0;
344 }
345
346 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
347 {
348         return 0;
349 }
350
351 static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
352 {
353         return 0;
354 }
355
356 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
357 {
358         inode_add_bytes(inode, nr);
359         return 0;
360 }
361
362 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
363 {
364         vfs_dq_prealloc_space_nodirty(inode, nr);
365         mark_inode_dirty(inode);
366         return 0;
367 }
368
369 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
370 {
371         inode_add_bytes(inode, nr);
372         return 0;
373 }
374
375 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
376 {
377         vfs_dq_alloc_space_nodirty(inode, nr);
378         mark_inode_dirty(inode);
379         return 0;
380 }
381
382 static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
383 {
384         return 0;
385 }
386
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
398 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
399 {
400         inode_sub_bytes(inode, nr);
401 }
402
403 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
404 {
405         vfs_dq_free_space_nodirty(inode, nr);
406         mark_inode_dirty(inode);
407 }       
408
409 #endif /* CONFIG_QUOTA */
410
411 static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
412 {
413         return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
414 }
415
416 static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
417 {
418         return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
419 }
420
421 static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
422 {
423         return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
424 }
425
426 static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
427 {
428         return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
429 }
430
431 static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
432 {
433         return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
434 }
435
436 static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
437 {
438         return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
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
447 static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
448 {
449         vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
450 }
451
452 static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
453 {
454         vfs_dq_free_space(inode, nr << inode->i_blkbits);
455 }
456
457 #endif /* _LINUX_QUOTAOPS_ */