quota: move unmount handling into the filesystem
[linux-3.10.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 #else
160
161 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
162 {
163         return 0;
164 }
165
166 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
167 {
168         return 0;
169 }
170
171 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
172 {
173         return 0;
174 }
175
176 static inline int sb_any_quota_suspended(struct super_block *sb)
177 {
178         return 0;
179 }
180
181 /* Does kernel know about any quota information for given sb + type? */
182 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
183 {
184         return 0;
185 }
186
187 static inline int sb_any_quota_loaded(struct super_block *sb)
188 {
189         return 0;
190 }
191
192 static inline int sb_has_quota_active(struct super_block *sb, int type)
193 {
194         return 0;
195 }
196
197 static inline int sb_any_quota_active(struct super_block *sb)
198 {
199         return 0;
200 }
201
202 /*
203  * NO-OP when quota not configured.
204  */
205 #define sb_dquot_ops                            (NULL)
206 #define sb_quotactl_ops                         (NULL)
207
208 static inline void dquot_initialize(struct inode *inode)
209 {
210 }
211
212 static inline void dquot_drop(struct inode *inode)
213 {
214 }
215
216 static inline int dquot_alloc_inode(const struct inode *inode)
217 {
218         return 0;
219 }
220
221 static inline void dquot_free_inode(const struct inode *inode)
222 {
223 }
224
225 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
226 {
227         return 0;
228 }
229
230 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
231                 int warn, int reserve)
232 {
233         if (!reserve)
234                 inode_add_bytes(inode, number);
235         return 0;
236 }
237
238 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
239                 int reserve)
240 {
241         if (!reserve)
242                 inode_sub_bytes(inode, number);
243 }
244
245 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
246 {
247         inode_add_bytes(inode, number);
248         return 0;
249 }
250
251 static inline int dquot_disable(struct super_block *sb, int type,
252                 unsigned int flags)
253 {
254         return 0;
255 }
256
257 static inline int dquot_suspend(struct super_block *sb, int type)
258 {
259         return 0;
260 }
261
262 static inline int dquot_resume(struct super_block *sb, int type)
263 {
264         return 0;
265 }
266
267 #define dquot_file_open         generic_file_open
268
269 #endif /* CONFIG_QUOTA */
270
271 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
272 {
273         return __dquot_alloc_space(inode, nr, 1, 0);
274 }
275
276 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
277 {
278         int ret;
279
280         ret = dquot_alloc_space_nodirty(inode, nr);
281         if (!ret)
282                 mark_inode_dirty(inode);
283         return ret;
284 }
285
286 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
287 {
288         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
289 }
290
291 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
292 {
293         return dquot_alloc_space(inode, nr << inode->i_blkbits);
294 }
295
296 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
297 {
298         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
299 }
300
301 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
302 {
303         int ret;
304
305         ret = dquot_prealloc_block_nodirty(inode, nr);
306         if (!ret)
307                 mark_inode_dirty(inode);
308         return ret;
309 }
310
311 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
312 {
313         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
314 }
315
316 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
317 {
318         int ret;
319
320         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
321         if (!ret)
322                 mark_inode_dirty(inode);
323         return ret;
324 }
325
326 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
327 {
328         __dquot_free_space(inode, nr, 0);
329 }
330
331 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
332 {
333         dquot_free_space_nodirty(inode, nr);
334         mark_inode_dirty(inode);
335 }
336
337 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
338 {
339         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
340 }
341
342 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
343 {
344         dquot_free_space(inode, nr << inode->i_blkbits);
345 }
346
347 static inline void dquot_release_reservation_block(struct inode *inode,
348                 qsize_t nr)
349 {
350         __dquot_free_space(inode, nr << inode->i_blkbits, 1);
351 }
352
353 #endif /* _LINUX_QUOTAOPS_ */