scheduler: compute time-average nr_running per run-queue
[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 #define DQUOT_SPACE_WARN        0x1
13 #define DQUOT_SPACE_RESERVE     0x2
14 #define DQUOT_SPACE_NOFAIL      0x4
15
16 static inline struct quota_info *sb_dqopt(struct super_block *sb)
17 {
18         return &sb->s_dquot;
19 }
20
21 /* i_mutex must being held */
22 static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
23 {
24         return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
25                 (ia->ia_valid & ATTR_UID && ia->ia_uid != inode->i_uid) ||
26                 (ia->ia_valid & ATTR_GID && ia->ia_gid != inode->i_gid);
27 }
28
29 #if defined(CONFIG_QUOTA)
30
31 #define quota_error(sb, fmt, args...) \
32         __quota_error((sb), __func__, fmt , ## args)
33
34 extern __attribute__((format (printf, 3, 4)))
35 void __quota_error(struct super_block *sb, const char *func,
36                    const char *fmt, ...);
37
38 /*
39  * declaration of quota_function calls in kernel.
40  */
41 void inode_add_rsv_space(struct inode *inode, qsize_t number);
42 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
43 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
44
45 void dquot_initialize(struct inode *inode);
46 void dquot_drop(struct inode *inode);
47 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
48 void dqput(struct dquot *dquot);
49 int dquot_scan_active(struct super_block *sb,
50                       int (*fn)(struct dquot *dquot, unsigned long priv),
51                       unsigned long priv);
52 struct dquot *dquot_alloc(struct super_block *sb, int type);
53 void dquot_destroy(struct dquot *dquot);
54
55 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
56 void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
57
58 int dquot_alloc_inode(const struct inode *inode);
59
60 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
61 void dquot_free_inode(const struct inode *inode);
62
63 int dquot_disable(struct super_block *sb, int type, unsigned int flags);
64 /* Suspend quotas on remount RO */
65 static inline int dquot_suspend(struct super_block *sb, int type)
66 {
67         return dquot_disable(sb, type, DQUOT_SUSPENDED);
68 }
69 int dquot_resume(struct super_block *sb, int type);
70
71 int dquot_commit(struct dquot *dquot);
72 int dquot_acquire(struct dquot *dquot);
73 int dquot_release(struct dquot *dquot);
74 int dquot_commit_info(struct super_block *sb, int type);
75 int dquot_mark_dquot_dirty(struct dquot *dquot);
76
77 int dquot_file_open(struct inode *inode, struct file *file);
78
79 int dquot_enable(struct inode *inode, int type, int format_id,
80         unsigned int flags);
81 int dquot_quota_on(struct super_block *sb, int type, int format_id,
82         struct path *path);
83 int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
84         int format_id, int type);
85 int dquot_quota_off(struct super_block *sb, int type);
86 int dquot_quota_sync(struct super_block *sb, int type, int wait);
87 int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
88 int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
89 int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
90                 struct fs_disk_quota *di);
91 int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
92                 struct fs_disk_quota *di);
93
94 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
95 int dquot_transfer(struct inode *inode, struct iattr *iattr);
96
97 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
98 {
99         return sb_dqopt(sb)->info + type;
100 }
101
102 /*
103  * Functions for checking status of quota
104  */
105
106 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
107 {
108         return sb_dqopt(sb)->flags &
109                                 dquot_state_flag(DQUOT_USAGE_ENABLED, type);
110 }
111
112 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
113 {
114         return sb_dqopt(sb)->flags &
115                                 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
116 }
117
118 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
119 {
120         return sb_dqopt(sb)->flags &
121                                 dquot_state_flag(DQUOT_SUSPENDED, type);
122 }
123
124 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
125 {
126         unsigned type, tmsk = 0;
127         for (type = 0; type < MAXQUOTAS; type++)
128                 tmsk |= sb_has_quota_suspended(sb, type) << type;
129         return tmsk;
130 }
131
132 /* Does kernel know about any quota information for given sb + type? */
133 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
134 {
135         /* Currently if anything is on, then quota usage is on as well */
136         return sb_has_quota_usage_enabled(sb, type);
137 }
138
139 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
140 {
141         unsigned type, tmsk = 0;
142         for (type = 0; type < MAXQUOTAS; type++)
143                 tmsk |= sb_has_quota_loaded(sb, type) << type;
144         return  tmsk;
145 }
146
147 static inline bool sb_has_quota_active(struct super_block *sb, int type)
148 {
149         return sb_has_quota_loaded(sb, type) &&
150                !sb_has_quota_suspended(sb, type);
151 }
152
153 /*
154  * Operations supported for diskquotas.
155  */
156 extern const struct dquot_operations dquot_operations;
157 extern const struct quotactl_ops dquot_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 void dquot_initialize(struct inode *inode)
198 {
199 }
200
201 static inline void dquot_drop(struct inode *inode)
202 {
203 }
204
205 static inline int dquot_alloc_inode(const struct inode *inode)
206 {
207         return 0;
208 }
209
210 static inline void dquot_free_inode(const struct inode *inode)
211 {
212 }
213
214 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
215 {
216         return 0;
217 }
218
219 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
220                 int flags)
221 {
222         if (!(flags & DQUOT_SPACE_RESERVE))
223                 inode_add_bytes(inode, number);
224         return 0;
225 }
226
227 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
228                 int flags)
229 {
230         if (!(flags & DQUOT_SPACE_RESERVE))
231                 inode_sub_bytes(inode, number);
232 }
233
234 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
235 {
236         inode_add_bytes(inode, number);
237         return 0;
238 }
239
240 static inline int dquot_disable(struct super_block *sb, int type,
241                 unsigned int flags)
242 {
243         return 0;
244 }
245
246 static inline int dquot_suspend(struct super_block *sb, int type)
247 {
248         return 0;
249 }
250
251 static inline int dquot_resume(struct super_block *sb, int type)
252 {
253         return 0;
254 }
255
256 #define dquot_file_open         generic_file_open
257
258 #endif /* CONFIG_QUOTA */
259
260 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
261 {
262         return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
263 }
264
265 static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
266 {
267         __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
268         mark_inode_dirty_sync(inode);
269 }
270
271 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
272 {
273         int ret;
274
275         ret = dquot_alloc_space_nodirty(inode, nr);
276         if (!ret) {
277                 /*
278                  * Mark inode fully dirty. Since we are allocating blocks, inode
279                  * would become fully dirty soon anyway and it reportedly
280                  * reduces lock contention.
281                  */
282                 mark_inode_dirty(inode);
283         }
284         return ret;
285 }
286
287 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
288 {
289         return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
290 }
291
292 static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
293 {
294         dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
295 }
296
297 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
298 {
299         return dquot_alloc_space(inode, nr << inode->i_blkbits);
300 }
301
302 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
303 {
304         return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
305 }
306
307 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
308 {
309         int ret;
310
311         ret = dquot_prealloc_block_nodirty(inode, nr);
312         if (!ret)
313                 mark_inode_dirty_sync(inode);
314         return ret;
315 }
316
317 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
318 {
319         return __dquot_alloc_space(inode, nr << inode->i_blkbits,
320                                 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
321 }
322
323 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
324 {
325         int ret;
326
327         ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
328         if (!ret)
329                 mark_inode_dirty_sync(inode);
330         return ret;
331 }
332
333 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
334 {
335         __dquot_free_space(inode, nr, 0);
336 }
337
338 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
339 {
340         dquot_free_space_nodirty(inode, nr);
341         mark_inode_dirty_sync(inode);
342 }
343
344 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
345 {
346         dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
347 }
348
349 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
350 {
351         dquot_free_space(inode, nr << inode->i_blkbits);
352 }
353
354 static inline void dquot_release_reservation_block(struct inode *inode,
355                 qsize_t nr)
356 {
357         __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
358 }
359
360 #endif /* _LINUX_QUOTAOPS_ */