blob: f4913948c3053104892c4592d68a27e3fd26d825 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7#ifndef _LINUX_QUOTAOPS_
8#define _LINUX_QUOTAOPS_
9
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <linux/smp_lock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070011#include <linux/fs.h>
12
Jan Kara03b06342008-07-25 01:46:52 -070013static inline struct quota_info *sb_dqopt(struct super_block *sb)
14{
15 return &sb->s_dquot;
16}
Jan Kara74abb982008-07-25 01:46:51 -070017
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#if defined(CONFIG_QUOTA)
19
20/*
21 * declaration of quota_function calls in kernel.
22 */
Jan Karab85f4b82008-07-25 01:46:50 -070023void sync_dquots(struct super_block *sb, int type);
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Jan Karab85f4b82008-07-25 01:46:50 -070025int dquot_initialize(struct inode *inode, int type);
26int dquot_drop(struct inode *inode);
Jan Kara3d9ea252008-10-10 16:12:23 +020027int 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);
Jan Kara12c77522008-10-20 17:05:00 +020031int dquot_scan_active(struct super_block *sb,
32 int (*fn)(struct dquot *dquot, unsigned long priv),
33 unsigned long priv);
Linus Torvalds1da177e2005-04-16 15:20:36 -070034
Jan Karab85f4b82008-07-25 01:46:50 -070035int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
Jan Kara12095462008-08-20 14:45:12 +020036int dquot_alloc_inode(const struct inode *inode, qsize_t number);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037
Jan Karab85f4b82008-07-25 01:46:50 -070038int dquot_free_space(struct inode *inode, qsize_t number);
Jan Kara12095462008-08-20 14:45:12 +020039int dquot_free_inode(const struct inode *inode, qsize_t number);
Linus Torvalds1da177e2005-04-16 15:20:36 -070040
Jan Karab85f4b82008-07-25 01:46:50 -070041int 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070047
Jan Karab85f4b82008-07-25 01:46:50 -070048int vfs_quota_on(struct super_block *sb, int type, int format_id,
49 char *path, int remount);
Jan Karaf55abc02008-08-20 17:50:32 +020050int vfs_quota_enable(struct inode *inode, int type, int format_id,
51 unsigned int flags);
Al Viro77e69da2008-08-01 04:29:18 -040052int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
53 struct path *path);
Jan Karab85f4b82008-07-25 01:46:50 -070054int 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);
Jan Karaf55abc02008-08-20 17:50:32 +020057int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
Jan Karab85f4b82008-07-25 01:46:50 -070058int 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -070067
Jan Kara03b06342008-07-25 01:46:52 -070068static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
69{
70 return sb_dqopt(sb)->info + type;
71}
Jan Kara74abb982008-07-25 01:46:51 -070072
73/*
74 * Functions for checking status of quota
75 */
76
Jan Karaf55abc02008-08-20 17:50:32 +020077static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -070078{
Jan Karaf55abc02008-08-20 17:50:32 +020079 return sb_dqopt(sb)->flags &
80 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -070081}
Jan Kara74abb982008-07-25 01:46:51 -070082
Jan Karaf55abc02008-08-20 17:50:32 +020083static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -070084{
Jan Karaf55abc02008-08-20 17:50:32 +020085 return sb_dqopt(sb)->flags &
86 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
Jan Kara03b06342008-07-25 01:46:52 -070087}
Jan Kara74abb982008-07-25 01:46:51 -070088
Jan Kara03b06342008-07-25 01:46:52 -070089static inline int sb_has_quota_suspended(struct super_block *sb, int type)
90{
Jan Karaf55abc02008-08-20 17:50:32 +020091 return sb_dqopt(sb)->flags &
92 dquot_state_flag(DQUOT_SUSPENDED, type);
Jan Kara03b06342008-07-25 01:46:52 -070093}
Jan Kara74abb982008-07-25 01:46:51 -070094
Jan Kara03b06342008-07-25 01:46:52 -070095static 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}
Jan Kara74abb982008-07-25 01:46:51 -0700100
Jan Karaf55abc02008-08-20 17:50:32 +0200101/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126/*
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. */
Jan Karab85f4b82008-07-25 01:46:50 -0700137static inline void vfs_dq_init(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700138{
139 BUG_ON(!inode->i_sb);
Jan Karaf55abc02008-08-20 17:50:32 +0200140 if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 inode->i_sb->dq_op->initialize(inode, -1);
142}
143
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144/* The following allocation/freeing/transfer functions *must* be called inside
145 * a transaction (deadlocks possible otherwise) */
Jan Karab85f4b82008-07-25 01:46:50 -0700146static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Jan Karaf55abc02008-08-20 17:50:32 +0200148 if (sb_any_quota_active(inode->i_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 /* 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
Jan Karab85f4b82008-07-25 01:46:50 -0700158static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159{
160 int ret;
Jan Karab85f4b82008-07-25 01:46:50 -0700161 if (!(ret = vfs_dq_prealloc_space_nodirty(inode, nr)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162 mark_inode_dirty(inode);
163 return ret;
164}
165
Jan Karab85f4b82008-07-25 01:46:50 -0700166static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Jan Karaf55abc02008-08-20 17:50:32 +0200168 if (sb_any_quota_active(inode->i_sb)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169 /* 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
Jan Karab85f4b82008-07-25 01:46:50 -0700178static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700179{
180 int ret;
Jan Karab85f4b82008-07-25 01:46:50 -0700181 if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 mark_inode_dirty(inode);
183 return ret;
184}
185
Jan Karab85f4b82008-07-25 01:46:50 -0700186static inline int vfs_dq_alloc_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187{
Jan Karaf55abc02008-08-20 17:50:32 +0200188 if (sb_any_quota_active(inode->i_sb)) {
Jan Karab85f4b82008-07-25 01:46:50 -0700189 vfs_dq_init(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
191 return 1;
192 }
193 return 0;
194}
195
Jan Karab85f4b82008-07-25 01:46:50 -0700196static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700197{
Jan Karaf55abc02008-08-20 17:50:32 +0200198 if (sb_any_quota_active(inode->i_sb))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 inode->i_sb->dq_op->free_space(inode, nr);
200 else
201 inode_sub_bytes(inode, nr);
202}
203
Jan Karab85f4b82008-07-25 01:46:50 -0700204static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205{
Jan Karab85f4b82008-07-25 01:46:50 -0700206 vfs_dq_free_space_nodirty(inode, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 mark_inode_dirty(inode);
208}
209
Jan Karab85f4b82008-07-25 01:46:50 -0700210static inline void vfs_dq_free_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211{
Jan Karaf55abc02008-08-20 17:50:32 +0200212 if (sb_any_quota_active(inode->i_sb))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 inode->i_sb->dq_op->free_inode(inode, 1);
214}
215
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216/* The following two functions cannot be called inside a transaction */
Jan Karab85f4b82008-07-25 01:46:50 -0700217static inline void vfs_dq_sync(struct super_block *sb)
Jan Kara03f6e922008-04-28 02:14:32 -0700218{
219 sync_dquots(sb, -1);
220}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
Jan Karab85f4b82008-07-25 01:46:50 -0700222static inline int vfs_dq_off(struct super_block *sb, int remount)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223{
224 int ret = -ENOSYS;
225
Jan Kara0ff5af82008-04-28 02:14:33 -0700226 if (sb->s_qcop && sb->s_qcop->quota_off)
227 ret = sb->s_qcop->quota_off(sb, -1, remount);
228 return ret;
229}
230
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231#else
232
Jan Karaf55abc02008-08-20 17:50:32 +0200233static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700234{
235 return 0;
236}
237
Jan Karaf55abc02008-08-20 17:50:32 +0200238static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
Jan Kara03b06342008-07-25 01:46:52 -0700239{
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}
Jan Kara74abb982008-07-25 01:46:51 -0700252
Jan Karaf55abc02008-08-20 17:50:32 +0200253/* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700274/*
275 * NO-OP when quota not configured.
276 */
277#define sb_dquot_ops (NULL)
278#define sb_quotactl_ops (NULL)
Andrew Morton50f8c372008-04-28 02:14:35 -0700279
Jan Karab85f4b82008-07-25 01:46:50 -0700280static inline void vfs_dq_init(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700281{
282}
283
Jan Karab85f4b82008-07-25 01:46:50 -0700284static inline void vfs_dq_drop(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700285{
286}
287
Jan Karab85f4b82008-07-25 01:46:50 -0700288static inline int vfs_dq_alloc_inode(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700289{
290 return 0;
291}
292
Jan Karab85f4b82008-07-25 01:46:50 -0700293static inline void vfs_dq_free_inode(struct inode *inode)
Andrew Morton50f8c372008-04-28 02:14:35 -0700294{
295}
296
Jan Karab85f4b82008-07-25 01:46:50 -0700297static inline void vfs_dq_sync(struct super_block *sb)
Andrew Morton50f8c372008-04-28 02:14:35 -0700298{
299}
300
Jan Karab85f4b82008-07-25 01:46:50 -0700301static inline int vfs_dq_off(struct super_block *sb, int remount)
Andrew Morton50f8c372008-04-28 02:14:35 -0700302{
303 return 0;
304}
305
Jan Karab85f4b82008-07-25 01:46:50 -0700306static inline int vfs_dq_quota_on_remount(struct super_block *sb)
Andrew Morton50f8c372008-04-28 02:14:35 -0700307{
308 return 0;
309}
310
Jan Karab85f4b82008-07-25 01:46:50 -0700311static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
Andrew Morton50f8c372008-04-28 02:14:35 -0700312{
313 return 0;
314}
315
Jan Karab85f4b82008-07-25 01:46:50 -0700316static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
318 inode_add_bytes(inode, nr);
319 return 0;
320}
321
Jan Karab85f4b82008-07-25 01:46:50 -0700322static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323{
Jan Karab85f4b82008-07-25 01:46:50 -0700324 vfs_dq_prealloc_space_nodirty(inode, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700325 mark_inode_dirty(inode);
326 return 0;
327}
328
Jan Karab85f4b82008-07-25 01:46:50 -0700329static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330{
331 inode_add_bytes(inode, nr);
332 return 0;
333}
334
Jan Karab85f4b82008-07-25 01:46:50 -0700335static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700336{
Jan Karab85f4b82008-07-25 01:46:50 -0700337 vfs_dq_alloc_space_nodirty(inode, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 mark_inode_dirty(inode);
339 return 0;
340}
341
Jan Karab85f4b82008-07-25 01:46:50 -0700342static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343{
344 inode_sub_bytes(inode, nr);
345}
346
Jan Karab85f4b82008-07-25 01:46:50 -0700347static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
Jan Karab85f4b82008-07-25 01:46:50 -0700349 vfs_dq_free_space_nodirty(inode, nr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 mark_inode_dirty(inode);
351}
352
353#endif /* CONFIG_QUOTA */
354
Jan Karab85f4b82008-07-25 01:46:50 -0700355static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700356{
Jan Karab85f4b82008-07-25 01:46:50 -0700357 return vfs_dq_prealloc_space_nodirty(inode,
Jan Kara03f6e922008-04-28 02:14:32 -0700358 nr << inode->i_sb->s_blocksize_bits);
359}
360
Jan Karab85f4b82008-07-25 01:46:50 -0700361static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700362{
Jan Karab85f4b82008-07-25 01:46:50 -0700363 return vfs_dq_prealloc_space(inode,
Jan Kara03f6e922008-04-28 02:14:32 -0700364 nr << inode->i_sb->s_blocksize_bits);
365}
366
Jan Karab85f4b82008-07-25 01:46:50 -0700367static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700368{
Jan Karab85f4b82008-07-25 01:46:50 -0700369 return vfs_dq_alloc_space_nodirty(inode,
Jan Kara03f6e922008-04-28 02:14:32 -0700370 nr << inode->i_sb->s_blocksize_bits);
371}
372
Jan Karab85f4b82008-07-25 01:46:50 -0700373static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700374{
Jan Karab85f4b82008-07-25 01:46:50 -0700375 return vfs_dq_alloc_space(inode,
Jan Kara03f6e922008-04-28 02:14:32 -0700376 nr << inode->i_sb->s_blocksize_bits);
377}
378
Jan Karab85f4b82008-07-25 01:46:50 -0700379static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700380{
Jan Karab85f4b82008-07-25 01:46:50 -0700381 vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
Jan Kara03f6e922008-04-28 02:14:32 -0700382}
383
Jan Karab85f4b82008-07-25 01:46:50 -0700384static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
Jan Kara03f6e922008-04-28 02:14:32 -0700385{
Jan Karab85f4b82008-07-25 01:46:50 -0700386 vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
Jan Kara03f6e922008-04-28 02:14:32 -0700387}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
Jan Karab85f4b82008-07-25 01:46:50 -0700389/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420#endif /* _LINUX_QUOTAOPS_ */