kbuild: add headerdep used to detect inclusion cycles in header files
[GitHub/mt8127/android_kernel_alcatel_ttab.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/smp_lock.h>
11 #include <linux/fs.h>
12
13 static inline struct quota_info *sb_dqopt(struct super_block *sb)
14 {
15 return &sb->s_dquot;
16 }
17
18 #if defined(CONFIG_QUOTA)
19
20 /*
21 * declaration of quota_function calls in kernel.
22 */
23 void sync_dquots(struct super_block *sb, int type);
24
25 int dquot_initialize(struct inode *inode, int type);
26 int dquot_drop(struct inode *inode);
27
28 int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
29 int dquot_alloc_inode(const struct inode *inode, unsigned long number);
30
31 int dquot_free_space(struct inode *inode, qsize_t number);
32 int dquot_free_inode(const struct inode *inode, unsigned long number);
33
34 int dquot_transfer(struct inode *inode, struct iattr *iattr);
35 int dquot_commit(struct dquot *dquot);
36 int dquot_acquire(struct dquot *dquot);
37 int dquot_release(struct dquot *dquot);
38 int dquot_commit_info(struct super_block *sb, int type);
39 int dquot_mark_dquot_dirty(struct dquot *dquot);
40
41 int vfs_quota_on(struct super_block *sb, int type, int format_id,
42 char *path, int remount);
43 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
44 struct path *path);
45 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
46 int format_id, int type);
47 int vfs_quota_off(struct super_block *sb, int type, int remount);
48 int vfs_quota_sync(struct super_block *sb, int type);
49 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
50 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
51 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
52 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
53
54 void vfs_dq_drop(struct inode *inode);
55 int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
56 int vfs_dq_quota_on_remount(struct super_block *sb);
57
58 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
59 {
60 return sb_dqopt(sb)->info + type;
61 }
62
63 /*
64 * Functions for checking status of quota
65 */
66
67 static inline int sb_has_quota_enabled(struct super_block *sb, int type)
68 {
69 if (type == USRQUOTA)
70 return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
71 return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
72 }
73
74 static inline int sb_any_quota_enabled(struct super_block *sb)
75 {
76 return sb_has_quota_enabled(sb, USRQUOTA) ||
77 sb_has_quota_enabled(sb, GRPQUOTA);
78 }
79
80 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
81 {
82 if (type == USRQUOTA)
83 return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
84 return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
85 }
86
87 static inline int sb_any_quota_suspended(struct super_block *sb)
88 {
89 return sb_has_quota_suspended(sb, USRQUOTA) ||
90 sb_has_quota_suspended(sb, GRPQUOTA);
91 }
92
93 /*
94 * Operations supported for diskquotas.
95 */
96 extern struct dquot_operations dquot_operations;
97 extern struct quotactl_ops vfs_quotactl_ops;
98
99 #define sb_dquot_ops (&dquot_operations)
100 #define sb_quotactl_ops (&vfs_quotactl_ops)
101
102 /* It is better to call this function outside of any transaction as it might
103 * need a lot of space in journal for dquot structure allocation. */
104 static inline void vfs_dq_init(struct inode *inode)
105 {
106 BUG_ON(!inode->i_sb);
107 if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
108 inode->i_sb->dq_op->initialize(inode, -1);
109 }
110
111 /* The following allocation/freeing/transfer functions *must* be called inside
112 * a transaction (deadlocks possible otherwise) */
113 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
114 {
115 if (sb_any_quota_enabled(inode->i_sb)) {
116 /* Used space is updated in alloc_space() */
117 if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
118 return 1;
119 }
120 else
121 inode_add_bytes(inode, nr);
122 return 0;
123 }
124
125 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
126 {
127 int ret;
128 if (!(ret = vfs_dq_prealloc_space_nodirty(inode, nr)))
129 mark_inode_dirty(inode);
130 return ret;
131 }
132
133 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
134 {
135 if (sb_any_quota_enabled(inode->i_sb)) {
136 /* Used space is updated in alloc_space() */
137 if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
138 return 1;
139 }
140 else
141 inode_add_bytes(inode, nr);
142 return 0;
143 }
144
145 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
146 {
147 int ret;
148 if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
149 mark_inode_dirty(inode);
150 return ret;
151 }
152
153 static inline int vfs_dq_alloc_inode(struct inode *inode)
154 {
155 if (sb_any_quota_enabled(inode->i_sb)) {
156 vfs_dq_init(inode);
157 if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
158 return 1;
159 }
160 return 0;
161 }
162
163 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
164 {
165 if (sb_any_quota_enabled(inode->i_sb))
166 inode->i_sb->dq_op->free_space(inode, nr);
167 else
168 inode_sub_bytes(inode, nr);
169 }
170
171 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
172 {
173 vfs_dq_free_space_nodirty(inode, nr);
174 mark_inode_dirty(inode);
175 }
176
177 static inline void vfs_dq_free_inode(struct inode *inode)
178 {
179 if (sb_any_quota_enabled(inode->i_sb))
180 inode->i_sb->dq_op->free_inode(inode, 1);
181 }
182
183 /* The following two functions cannot be called inside a transaction */
184 static inline void vfs_dq_sync(struct super_block *sb)
185 {
186 sync_dquots(sb, -1);
187 }
188
189 static inline int vfs_dq_off(struct super_block *sb, int remount)
190 {
191 int ret = -ENOSYS;
192
193 if (sb->s_qcop && sb->s_qcop->quota_off)
194 ret = sb->s_qcop->quota_off(sb, -1, remount);
195 return ret;
196 }
197
198 #else
199
200 static inline int sb_has_quota_enabled(struct super_block *sb, int type)
201 {
202 return 0;
203 }
204
205 static inline int sb_any_quota_enabled(struct super_block *sb)
206 {
207 return 0;
208 }
209
210 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
211 {
212 return 0;
213 }
214
215 static inline int sb_any_quota_suspended(struct super_block *sb)
216 {
217 return 0;
218 }
219
220 /*
221 * NO-OP when quota not configured.
222 */
223 #define sb_dquot_ops (NULL)
224 #define sb_quotactl_ops (NULL)
225
226 static inline void vfs_dq_init(struct inode *inode)
227 {
228 }
229
230 static inline void vfs_dq_drop(struct inode *inode)
231 {
232 }
233
234 static inline int vfs_dq_alloc_inode(struct inode *inode)
235 {
236 return 0;
237 }
238
239 static inline void vfs_dq_free_inode(struct inode *inode)
240 {
241 }
242
243 static inline void vfs_dq_sync(struct super_block *sb)
244 {
245 }
246
247 static inline int vfs_dq_off(struct super_block *sb, int remount)
248 {
249 return 0;
250 }
251
252 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
253 {
254 return 0;
255 }
256
257 static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
258 {
259 return 0;
260 }
261
262 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
263 {
264 inode_add_bytes(inode, nr);
265 return 0;
266 }
267
268 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
269 {
270 vfs_dq_prealloc_space_nodirty(inode, nr);
271 mark_inode_dirty(inode);
272 return 0;
273 }
274
275 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
276 {
277 inode_add_bytes(inode, nr);
278 return 0;
279 }
280
281 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
282 {
283 vfs_dq_alloc_space_nodirty(inode, nr);
284 mark_inode_dirty(inode);
285 return 0;
286 }
287
288 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
289 {
290 inode_sub_bytes(inode, nr);
291 }
292
293 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
294 {
295 vfs_dq_free_space_nodirty(inode, nr);
296 mark_inode_dirty(inode);
297 }
298
299 #endif /* CONFIG_QUOTA */
300
301 static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
302 {
303 return vfs_dq_prealloc_space_nodirty(inode,
304 nr << inode->i_sb->s_blocksize_bits);
305 }
306
307 static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
308 {
309 return vfs_dq_prealloc_space(inode,
310 nr << inode->i_sb->s_blocksize_bits);
311 }
312
313 static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
314 {
315 return vfs_dq_alloc_space_nodirty(inode,
316 nr << inode->i_sb->s_blocksize_bits);
317 }
318
319 static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
320 {
321 return vfs_dq_alloc_space(inode,
322 nr << inode->i_sb->s_blocksize_bits);
323 }
324
325 static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
326 {
327 vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
328 }
329
330 static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
331 {
332 vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
333 }
334
335 /*
336 * Define uppercase equivalents for compatibility with old function names
337 * Can go away when we think all users have been converted (15/04/2008)
338 */
339 #define DQUOT_INIT(inode) vfs_dq_init(inode)
340 #define DQUOT_DROP(inode) vfs_dq_drop(inode)
341 #define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
342 vfs_dq_prealloc_space_nodirty(inode, nr)
343 #define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
344 #define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
345 vfs_dq_alloc_space_nodirty(inode, nr)
346 #define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
347 #define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
348 vfs_dq_prealloc_block_nodirty(inode, nr)
349 #define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
350 #define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
351 vfs_dq_alloc_block_nodirty(inode, nr)
352 #define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
353 #define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
354 #define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
355 vfs_dq_free_space_nodirty(inode, nr)
356 #define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
357 #define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
358 vfs_dq_free_block_nodirty(inode, nr)
359 #define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
360 #define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
361 #define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
362 #define DQUOT_SYNC(sb) vfs_dq_sync(sb)
363 #define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
364 #define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
365
366 #endif /* _LINUX_QUOTAOPS_ */