811529241e33a6c4194144a9f1d10d1abbcaa858
[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 /* i_mutex must being held */
18 static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
19 {
20         return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
21                 (ia->ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
22                 (ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
23 }
24
25 #if defined(CONFIG_QUOTA)
26
27 /*
28  * declaration of quota_function calls in kernel.
29  */
30 void inode_add_rsv_space(struct inode *inode, qsize_t number);
31 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
32 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
33
34 void dquot_initialize(struct inode *inode);
35 void dquot_drop(struct inode *inode);
36 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
37 void dqput(struct dquot *dquot);
38 int dquot_scan_active(struct super_block *sb,
39                       int (*fn)(struct dquot *dquot, unsigned long priv),
40                       unsigned long priv);
41 struct dquot *dquot_alloc(struct super_block *sb, int type);
42 void dquot_destroy(struct dquot *dquot);
43
44 int __dquot_alloc_space(struct inode *inode, qsize_t number,
45                 int warn, int reserve);
46 void __dquot_free_space(struct inode *inode, qsize_t number, int reserve);
47
48 int dquot_alloc_inode(const struct inode *inode);
49
50 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
51 void dquot_free_inode(const struct inode *inode);
52
53 int dquot_disable(struct super_block *sb, int type, unsigned int flags);
54 /* Suspend quotas on remount RO */
55 static inline int dquot_suspend(struct super_block *sb, int type)
56 {
57         return dquot_disable(sb, type, DQUOT_SUSPENDED);
58 }
59 int dquot_resume(struct super_block *sb, int type);
60
61 int dquot_commit(struct dquot *dquot);
62 int dquot_acquire(struct dquot *dquot);
63 int dquot_release(struct dquot *dquot);
64 int dquot_commit_info(struct super_block *sb, int type);
65 int dquot_mark_dquot_dirty(struct dquot *dquot);
66
67 int dquot_file_open(struct inode *inode, struct file *file);
68
69 int vfs_quota_on(struct super_block *sb, int type, int format_id,
70         char *path, int remount);
71 int vfs_quota_enable(struct inode *inode, int type, int format_id,
72         unsigned int flags);
73 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
74         struct path *path);
75 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
76         int format_id, int type);
77 int vfs_quota_off(struct super_block *sb, int type, int remount);
78 int vfs_quota_sync(struct super_block *sb, int type, int wait);
79 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
80 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
81 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id,
82                 struct fs_disk_quota *di);
83 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id,
84                 struct fs_disk_quota *di);
85
86 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
87 int dquot_transfer(struct inode *inode, struct iattr *iattr);
88
89 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
90 {
91         return sb_dqopt(sb)->info + type;
92 }
93
94 /*
95  * Functions for checking status of quota
96  */
97
98 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
99 {
100         return sb_dqopt(sb)->flags &
101                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
102 }
103
104 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
105 {
106         return sb_dqopt(sb)->flags &
107                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
108 }
109
110 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
111 {
112         return sb_dqopt(sb)->flags &
113                                 dquot_state_flag(DQUOT_SUSPENDED, type);
114 }
115
116 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
117 {
118         unsigned type, tmsk = 0;
119         for (type = 0; type < MAXQUOTAS; type++)
120                 tmsk |= sb_has_quota_suspended(sb, type) << type;
121         return tmsk;
122 }
123
124 /* Does kernel know about any quota information for given sb + type? */
125 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
126 {
127         /* Currently if anything is on, then quota usage is on as well */
128         return sb_has_quota_usage_enabled(sb, type);
129 }
130
131 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
132 {
133         unsigned type, tmsk = 0;
134         for (type = 0; type < MAXQUOTAS; type++)
135                 tmsk |= sb_has_quota_loaded(sb, type) << type;
136         return  tmsk;
137 }
138
139 static inline bool sb_has_quota_active(struct super_block *sb, int type)
140 {
141         return sb_has_quota_loaded(sb, type) &&
142                !sb_has_quota_suspended(sb, type);
143 }
144
145 static inline unsigned sb_any_quota_active(struct super_block *sb)
146 {
147         return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
148 }
149
150 /*
151  * Operations supported for diskquotas.
152  */
153 extern const struct dquot_operations dquot_operations;
154 extern const struct quotactl_ops vfs_quotactl_ops;
155
156 #define sb_dquot_ops (&dquot_operations)
157 #define sb_quotactl_ops (&vfs_quotactl_ops)
158
159 /* Cannot be called inside a transaction */
160 static inline int vfs_dq_off(struct super_block *sb, int remount)
161 {
162         int ret = -ENOSYS;
163
164         if (sb->s_qcop && sb->s_qcop->quota_off)
165                 ret = sb->s_qcop->quota_off(sb, -1, remount);
166         return ret;
167 }
168
169 #else
170
171 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
172 {
173         return 0;
174 }
175
176 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
177 {
178         return 0;
179 }
180
181 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
182 {
183         return 0;
184 }
185
186 static inline int sb_any_quota_suspended(struct super_block *sb)
187 {
188         return 0;
189 }
190
191 /* Does kernel know about any quota information for given sb + type? */
192 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
193 {
194         return 0;
195 }
196
197 static inline int sb_any_quota_loaded(struct super_block *sb)
198 {
199         return 0;
200 }
201
202 static inline int sb_has_quota_active(struct super_block *sb, int type)
203 {
204         return 0;
205 }
206
207 static inline int sb_any_quota_active(struct super_block *sb)
208 {
209         return 0;
210 }
211
212 /*
213  * NO-OP when quota not configured.
214  */
215 #define sb_dquot_ops                            (NULL)
216 #define sb_quotactl_ops                         (NULL)
217
218 static inline void dquot_initialize(struct inode *inode)
219 {
220 }
221
222 static inline void dquot_drop(struct inode *inode)
223 {
224 }
225
226 static inline int dquot_alloc_inode(const struct inode *inode)
227 {
228         return 0;
229 }
230
231 static inline void dquot_free_inode(const struct inode *inode)
232 {
233 }
234
235 static inline int vfs_dq_off(struct super_block *sb, int remount)
236 {
237         return 0;
238 }
239
240 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
241 {
242         return 0;
243 }
244
245 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
246                 int warn, int reserve)
247 {
248         if (!reserve)
249                 inode_add_bytes(inode, number);
250         return 0;
251 }
252
253 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
254                 int reserve)
255 {
256         if (!reserve)
257                 inode_sub_bytes(inode, number);
258 }
259
260 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
261 {
262         inode_add_bytes(inode, number);
263         return 0;
264 }
265
266 static inline int dquot_disable(struct super_block *sb, int type,
267                 unsigned int flags)
268 {
269         return 0;
270 }
271
272 static inline int dquot_suspend(struct super_block *sb, int type)
273 {
274         return 0;
275 }
276
277 static inline int dquot_resume(struct super_block *sb, int type)
278 {
279         return 0;
280 }
281
282 #define dquot_file_open         generic_file_open
283
284 #endif /* CONFIG_QUOTA */
285
286 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
287 {
288         return __dquot_alloc_space(inode, nr, 1, 0);
289 }
290
291 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
292 {
293         int ret;
294
295         ret = dquot_alloc_space_nodirty(inode, nr);
296         if (!ret)
297                 mark_inode_dirty(inode);
298         return ret;
299 }
300
301 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
302 {
303         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
304 }
305
306 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
307 {
308         return dquot_alloc_space(inode, nr << inode->i_blkbits);
309 }
310
311 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
312 {
313         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
314 }
315
316 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
317 {
318         int ret;
319
320         ret = dquot_prealloc_block_nodirty(inode, nr);
321         if (!ret)
322                 mark_inode_dirty(inode);
323         return ret;
324 }
325
326 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
327 {
328         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
329 }
330
331 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
332 {
333         int ret;
334
335         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
336         if (!ret)
337                 mark_inode_dirty(inode);
338         return ret;
339 }
340
341 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
342 {
343         __dquot_free_space(inode, nr, 0);
344 }
345
346 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
347 {
348         dquot_free_space_nodirty(inode, nr);
349         mark_inode_dirty(inode);
350 }
351
352 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
353 {
354         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
355 }
356
357 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
358 {
359         dquot_free_space(inode, nr << inode->i_blkbits);
360 }
361
362 static inline void dquot_release_reservation_block(struct inode *inode,
363                 qsize_t nr)
364 {
365         __dquot_free_space(inode, nr << inode->i_blkbits, 1);
366 }
367
368 #endif /* _LINUX_QUOTAOPS_ */