quota: unify ->get_dqblk
[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/fs.h>
11
12 static inline struct quota_info *sb_dqopt(struct super_block *sb)
13 {
14         return &sb->s_dquot;
15 }
16
17 #if defined(CONFIG_QUOTA)
18
19 /*
20  * declaration of quota_function calls in kernel.
21  */
22 void inode_add_rsv_space(struct inode *inode, qsize_t number);
23 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
24 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
25
26 void dquot_initialize(struct inode *inode);
27 void dquot_drop(struct inode *inode);
28 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
29 void dqput(struct dquot *dquot);
30 int dquot_scan_active(struct super_block *sb,
31                       int (*fn)(struct dquot *dquot, unsigned long priv),
32                       unsigned long priv);
33 struct dquot *dquot_alloc(struct super_block *sb, int type);
34 void dquot_destroy(struct dquot *dquot);
35
36 int __dquot_alloc_space(struct inode *inode, qsize_t number,
37                 int warn, int reserve);
38 void __dquot_free_space(struct inode *inode, qsize_t number, int reserve);
39
40 int dquot_alloc_inode(const struct inode *inode);
41
42 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
43 void dquot_free_inode(const struct inode *inode);
44
45 int dquot_commit(struct dquot *dquot);
46 int dquot_acquire(struct dquot *dquot);
47 int dquot_release(struct dquot *dquot);
48 int dquot_commit_info(struct super_block *sb, int type);
49 int dquot_mark_dquot_dirty(struct dquot *dquot);
50
51 int dquot_file_open(struct inode *inode, struct file *file);
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, int wait);
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,
67                 struct fs_disk_quota *di);
68 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
69
70 int dquot_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 bool 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 bool 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 bool 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 unsigned sb_any_quota_suspended(struct super_block *sb)
101 {
102         unsigned type, tmsk = 0;
103         for (type = 0; type < MAXQUOTAS; type++)
104                 tmsk |= sb_has_quota_suspended(sb, type) << type;
105         return tmsk;
106 }
107
108 /* Does kernel know about any quota information for given sb + type? */
109 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
110 {
111         /* Currently if anything is on, then quota usage is on as well */
112         return sb_has_quota_usage_enabled(sb, type);
113 }
114
115 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
116 {
117         unsigned type, tmsk = 0;
118         for (type = 0; type < MAXQUOTAS; type++)
119                 tmsk |= sb_has_quota_loaded(sb, type) << type;
120         return  tmsk;
121 }
122
123 static inline bool sb_has_quota_active(struct super_block *sb, int type)
124 {
125         return sb_has_quota_loaded(sb, type) &&
126                !sb_has_quota_suspended(sb, type);
127 }
128
129 static inline unsigned sb_any_quota_active(struct super_block *sb)
130 {
131         return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
132 }
133
134 /*
135  * Operations supported for diskquotas.
136  */
137 extern const struct dquot_operations dquot_operations;
138 extern const struct quotactl_ops vfs_quotactl_ops;
139
140 #define sb_dquot_ops (&dquot_operations)
141 #define sb_quotactl_ops (&vfs_quotactl_ops)
142
143 /* Cannot be called inside a transaction */
144 static inline int vfs_dq_off(struct super_block *sb, int remount)
145 {
146         int ret = -ENOSYS;
147
148         if (sb->s_qcop && sb->s_qcop->quota_off)
149                 ret = sb->s_qcop->quota_off(sb, -1, remount);
150         return ret;
151 }
152
153 #else
154
155 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
156 {
157         return 0;
158 }
159
160 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
161 {
162         return 0;
163 }
164
165 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
166 {
167         return 0;
168 }
169
170 static inline int sb_any_quota_suspended(struct super_block *sb)
171 {
172         return 0;
173 }
174
175 /* Does kernel know about any quota information for given sb + type? */
176 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
177 {
178         return 0;
179 }
180
181 static inline int sb_any_quota_loaded(struct super_block *sb)
182 {
183         return 0;
184 }
185
186 static inline int sb_has_quota_active(struct super_block *sb, int type)
187 {
188         return 0;
189 }
190
191 static inline int sb_any_quota_active(struct super_block *sb)
192 {
193         return 0;
194 }
195
196 /*
197  * NO-OP when quota not configured.
198  */
199 #define sb_dquot_ops                            (NULL)
200 #define sb_quotactl_ops                         (NULL)
201
202 static inline void dquot_initialize(struct inode *inode)
203 {
204 }
205
206 static inline void dquot_drop(struct inode *inode)
207 {
208 }
209
210 static inline int dquot_alloc_inode(const struct inode *inode)
211 {
212         return 0;
213 }
214
215 static inline void dquot_free_inode(const struct inode *inode)
216 {
217 }
218
219 static inline int vfs_dq_off(struct super_block *sb, int remount)
220 {
221         return 0;
222 }
223
224 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
225 {
226         return 0;
227 }
228
229 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
230 {
231         return 0;
232 }
233
234 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
235                 int warn, int reserve)
236 {
237         if (!reserve)
238                 inode_add_bytes(inode, number);
239         return 0;
240 }
241
242 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
243                 int reserve)
244 {
245         if (!reserve)
246                 inode_sub_bytes(inode, number);
247 }
248
249 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
250 {
251         inode_add_bytes(inode, number);
252         return 0;
253 }
254
255 #define dquot_file_open         generic_file_open
256
257 #endif /* CONFIG_QUOTA */
258
259 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
260 {
261         return __dquot_alloc_space(inode, nr, 1, 0);
262 }
263
264 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
265 {
266         int ret;
267
268         ret = dquot_alloc_space_nodirty(inode, nr);
269         if (!ret)
270                 mark_inode_dirty(inode);
271         return ret;
272 }
273
274 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
275 {
276         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
277 }
278
279 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
280 {
281         return dquot_alloc_space(inode, nr << inode->i_blkbits);
282 }
283
284 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
285 {
286         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
287 }
288
289 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
290 {
291         int ret;
292
293         ret = dquot_prealloc_block_nodirty(inode, nr);
294         if (!ret)
295                 mark_inode_dirty(inode);
296         return ret;
297 }
298
299 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
300 {
301         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
302 }
303
304 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
305 {
306         int ret;
307
308         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
309         if (!ret)
310                 mark_inode_dirty(inode);
311         return ret;
312 }
313
314 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
315 {
316         __dquot_free_space(inode, nr, 0);
317 }
318
319 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
320 {
321         dquot_free_space_nodirty(inode, nr);
322         mark_inode_dirty(inode);
323 }
324
325 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
326 {
327         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
328 }
329
330 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
331 {
332         dquot_free_space(inode, nr << inode->i_blkbits);
333 }
334
335 static inline void dquot_release_reservation_block(struct inode *inode,
336                 qsize_t nr)
337 {
338         __dquot_free_space(inode, nr << inode->i_blkbits, 1);
339 }
340
341 #endif /* _LINUX_QUOTAOPS_ */