e6fa7acce2900a5bd6862a4bf9703a87cd30a0bd
[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, struct if_dqblk *di);
67 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
68
69 int dquot_transfer(struct inode *inode, struct iattr *iattr);
70 int vfs_dq_quota_on_remount(struct super_block *sb);
71
72 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
73 {
74         return sb_dqopt(sb)->info + type;
75 }
76
77 /*
78  * Functions for checking status of quota
79  */
80
81 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
82 {
83         return sb_dqopt(sb)->flags &
84                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
85 }
86
87 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
88 {
89         return sb_dqopt(sb)->flags &
90                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
91 }
92
93 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
94 {
95         return sb_dqopt(sb)->flags &
96                                 dquot_state_flag(DQUOT_SUSPENDED, type);
97 }
98
99 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
100 {
101         unsigned type, tmsk = 0;
102         for (type = 0; type < MAXQUOTAS; type++)
103                 tmsk |= sb_has_quota_suspended(sb, type) << type;
104         return tmsk;
105 }
106
107 /* Does kernel know about any quota information for given sb + type? */
108 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
109 {
110         /* Currently if anything is on, then quota usage is on as well */
111         return sb_has_quota_usage_enabled(sb, type);
112 }
113
114 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
115 {
116         unsigned type, tmsk = 0;
117         for (type = 0; type < MAXQUOTAS; type++)
118                 tmsk |= sb_has_quota_loaded(sb, type) << type;
119         return  tmsk;
120 }
121
122 static inline bool sb_has_quota_active(struct super_block *sb, int type)
123 {
124         return sb_has_quota_loaded(sb, type) &&
125                !sb_has_quota_suspended(sb, type);
126 }
127
128 static inline unsigned sb_any_quota_active(struct super_block *sb)
129 {
130         return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
131 }
132
133 /*
134  * Operations supported for diskquotas.
135  */
136 extern const struct dquot_operations dquot_operations;
137 extern const struct quotactl_ops vfs_quotactl_ops;
138
139 #define sb_dquot_ops (&dquot_operations)
140 #define sb_quotactl_ops (&vfs_quotactl_ops)
141
142 /* Cannot be called inside a transaction */
143 static inline int vfs_dq_off(struct super_block *sb, int remount)
144 {
145         int ret = -ENOSYS;
146
147         if (sb->s_qcop && sb->s_qcop->quota_off)
148                 ret = sb->s_qcop->quota_off(sb, -1, remount);
149         return ret;
150 }
151
152 #else
153
154 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
155 {
156         return 0;
157 }
158
159 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
160 {
161         return 0;
162 }
163
164 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
165 {
166         return 0;
167 }
168
169 static inline int sb_any_quota_suspended(struct super_block *sb)
170 {
171         return 0;
172 }
173
174 /* Does kernel know about any quota information for given sb + type? */
175 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
176 {
177         return 0;
178 }
179
180 static inline int sb_any_quota_loaded(struct super_block *sb)
181 {
182         return 0;
183 }
184
185 static inline int sb_has_quota_active(struct super_block *sb, int type)
186 {
187         return 0;
188 }
189
190 static inline int sb_any_quota_active(struct super_block *sb)
191 {
192         return 0;
193 }
194
195 /*
196  * NO-OP when quota not configured.
197  */
198 #define sb_dquot_ops                            (NULL)
199 #define sb_quotactl_ops                         (NULL)
200
201 static inline void dquot_initialize(struct inode *inode)
202 {
203 }
204
205 static inline void dquot_drop(struct inode *inode)
206 {
207 }
208
209 static inline int dquot_alloc_inode(const struct inode *inode)
210 {
211         return 0;
212 }
213
214 static inline void dquot_free_inode(const struct inode *inode)
215 {
216 }
217
218 static inline int vfs_dq_off(struct super_block *sb, int remount)
219 {
220         return 0;
221 }
222
223 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
224 {
225         return 0;
226 }
227
228 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
229 {
230         return 0;
231 }
232
233 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
234                 int warn, int reserve)
235 {
236         if (!reserve)
237                 inode_add_bytes(inode, number);
238         return 0;
239 }
240
241 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
242                 int reserve)
243 {
244         if (!reserve)
245                 inode_sub_bytes(inode, number);
246 }
247
248 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
249 {
250         inode_add_bytes(inode, number);
251         return 0;
252 }
253
254 #define dquot_file_open         generic_file_open
255
256 #endif /* CONFIG_QUOTA */
257
258 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
259 {
260         return __dquot_alloc_space(inode, nr, 1, 0);
261 }
262
263 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
264 {
265         int ret;
266
267         ret = dquot_alloc_space_nodirty(inode, nr);
268         if (!ret)
269                 mark_inode_dirty(inode);
270         return ret;
271 }
272
273 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
274 {
275         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
276 }
277
278 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
279 {
280         return dquot_alloc_space(inode, nr << inode->i_blkbits);
281 }
282
283 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
284 {
285         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
286 }
287
288 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
289 {
290         int ret;
291
292         ret = dquot_prealloc_block_nodirty(inode, nr);
293         if (!ret)
294                 mark_inode_dirty(inode);
295         return ret;
296 }
297
298 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
299 {
300         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
301 }
302
303 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
304 {
305         int ret;
306
307         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
308         if (!ret)
309                 mark_inode_dirty(inode);
310         return ret;
311 }
312
313 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
314 {
315         __dquot_free_space(inode, nr, 0);
316 }
317
318 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
319 {
320         dquot_free_space_nodirty(inode, nr);
321         mark_inode_dirty(inode);
322 }
323
324 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
325 {
326         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
327 }
328
329 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
330 {
331         dquot_free_space(inode, nr << inode->i_blkbits);
332 }
333
334 static inline void dquot_release_reservation_block(struct inode *inode,
335                 qsize_t nr)
336 {
337         __dquot_free_space(inode, nr << inode->i_blkbits, 1);
338 }
339
340 #endif /* _LINUX_QUOTAOPS_ */