]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - include/linux/quotaops.h
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/sparc-2.6
[mirror_ubuntu-artful-kernel.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_ */