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