]>
Commit | Line | Data |
---|---|---|
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 && !uid_eq(ia->ia_uid, inode->i_uid)) || | |
26 | (ia->ia_valid & ATTR_GID && !gid_eq(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 __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_writeback_dquots(struct super_block *sb, int type); | |
87 | int dquot_quota_sync(struct super_block *sb, int type); | |
88 | int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii); | |
89 | int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii); | |
90 | int dquot_get_dqblk(struct super_block *sb, int type, qid_t id, | |
91 | struct fs_disk_quota *di); | |
92 | int dquot_set_dqblk(struct super_block *sb, int type, qid_t id, | |
93 | struct fs_disk_quota *di); | |
94 | ||
95 | int __dquot_transfer(struct inode *inode, struct dquot **transfer_to); | |
96 | int dquot_transfer(struct inode *inode, struct iattr *iattr); | |
97 | ||
98 | static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type) | |
99 | { | |
100 | return sb_dqopt(sb)->info + type; | |
101 | } | |
102 | ||
103 | /* | |
104 | * Functions for checking status of quota | |
105 | */ | |
106 | ||
107 | static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type) | |
108 | { | |
109 | return sb_dqopt(sb)->flags & | |
110 | dquot_state_flag(DQUOT_USAGE_ENABLED, type); | |
111 | } | |
112 | ||
113 | static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type) | |
114 | { | |
115 | return sb_dqopt(sb)->flags & | |
116 | dquot_state_flag(DQUOT_LIMITS_ENABLED, type); | |
117 | } | |
118 | ||
119 | static inline bool sb_has_quota_suspended(struct super_block *sb, int type) | |
120 | { | |
121 | return sb_dqopt(sb)->flags & | |
122 | dquot_state_flag(DQUOT_SUSPENDED, type); | |
123 | } | |
124 | ||
125 | static inline unsigned sb_any_quota_suspended(struct super_block *sb) | |
126 | { | |
127 | unsigned type, tmsk = 0; | |
128 | for (type = 0; type < MAXQUOTAS; type++) | |
129 | tmsk |= sb_has_quota_suspended(sb, type) << type; | |
130 | return tmsk; | |
131 | } | |
132 | ||
133 | /* Does kernel know about any quota information for given sb + type? */ | |
134 | static inline bool sb_has_quota_loaded(struct super_block *sb, int type) | |
135 | { | |
136 | /* Currently if anything is on, then quota usage is on as well */ | |
137 | return sb_has_quota_usage_enabled(sb, type); | |
138 | } | |
139 | ||
140 | static inline unsigned sb_any_quota_loaded(struct super_block *sb) | |
141 | { | |
142 | unsigned type, tmsk = 0; | |
143 | for (type = 0; type < MAXQUOTAS; type++) | |
144 | tmsk |= sb_has_quota_loaded(sb, type) << type; | |
145 | return tmsk; | |
146 | } | |
147 | ||
148 | static inline bool sb_has_quota_active(struct super_block *sb, int type) | |
149 | { | |
150 | return sb_has_quota_loaded(sb, type) && | |
151 | !sb_has_quota_suspended(sb, type); | |
152 | } | |
153 | ||
154 | /* | |
155 | * Operations supported for diskquotas. | |
156 | */ | |
157 | extern const struct dquot_operations dquot_operations; | |
158 | extern const struct quotactl_ops dquot_quotactl_ops; | |
159 | ||
160 | #else | |
161 | ||
162 | static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type) | |
163 | { | |
164 | return 0; | |
165 | } | |
166 | ||
167 | static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type) | |
168 | { | |
169 | return 0; | |
170 | } | |
171 | ||
172 | static inline int sb_has_quota_suspended(struct super_block *sb, int type) | |
173 | { | |
174 | return 0; | |
175 | } | |
176 | ||
177 | static inline int sb_any_quota_suspended(struct super_block *sb) | |
178 | { | |
179 | return 0; | |
180 | } | |
181 | ||
182 | /* Does kernel know about any quota information for given sb + type? */ | |
183 | static inline int sb_has_quota_loaded(struct super_block *sb, int type) | |
184 | { | |
185 | return 0; | |
186 | } | |
187 | ||
188 | static inline int sb_any_quota_loaded(struct super_block *sb) | |
189 | { | |
190 | return 0; | |
191 | } | |
192 | ||
193 | static inline int sb_has_quota_active(struct super_block *sb, int type) | |
194 | { | |
195 | return 0; | |
196 | } | |
197 | ||
198 | static inline void dquot_initialize(struct inode *inode) | |
199 | { | |
200 | } | |
201 | ||
202 | static inline void dquot_drop(struct inode *inode) | |
203 | { | |
204 | } | |
205 | ||
206 | static inline int dquot_alloc_inode(const struct inode *inode) | |
207 | { | |
208 | return 0; | |
209 | } | |
210 | ||
211 | static inline void dquot_free_inode(const struct inode *inode) | |
212 | { | |
213 | } | |
214 | ||
215 | static inline int dquot_transfer(struct inode *inode, struct iattr *iattr) | |
216 | { | |
217 | return 0; | |
218 | } | |
219 | ||
220 | static inline int __dquot_alloc_space(struct inode *inode, qsize_t number, | |
221 | int flags) | |
222 | { | |
223 | if (!(flags & DQUOT_SPACE_RESERVE)) | |
224 | inode_add_bytes(inode, number); | |
225 | return 0; | |
226 | } | |
227 | ||
228 | static inline void __dquot_free_space(struct inode *inode, qsize_t number, | |
229 | int flags) | |
230 | { | |
231 | if (!(flags & DQUOT_SPACE_RESERVE)) | |
232 | inode_sub_bytes(inode, number); | |
233 | } | |
234 | ||
235 | static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number) | |
236 | { | |
237 | inode_add_bytes(inode, number); | |
238 | return 0; | |
239 | } | |
240 | ||
241 | static inline int dquot_disable(struct super_block *sb, int type, | |
242 | unsigned int flags) | |
243 | { | |
244 | return 0; | |
245 | } | |
246 | ||
247 | static inline int dquot_suspend(struct super_block *sb, int type) | |
248 | { | |
249 | return 0; | |
250 | } | |
251 | ||
252 | static inline int dquot_resume(struct super_block *sb, int type) | |
253 | { | |
254 | return 0; | |
255 | } | |
256 | ||
257 | #define dquot_file_open generic_file_open | |
258 | ||
259 | static inline int dquot_writeback_dquots(struct super_block *sb, int type) | |
260 | { | |
261 | return 0; | |
262 | } | |
263 | ||
264 | #endif /* CONFIG_QUOTA */ | |
265 | ||
266 | static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr) | |
267 | { | |
268 | return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN); | |
269 | } | |
270 | ||
271 | static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr) | |
272 | { | |
273 | __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL); | |
274 | mark_inode_dirty_sync(inode); | |
275 | } | |
276 | ||
277 | static inline int dquot_alloc_space(struct inode *inode, qsize_t nr) | |
278 | { | |
279 | int ret; | |
280 | ||
281 | ret = dquot_alloc_space_nodirty(inode, nr); | |
282 | if (!ret) { | |
283 | /* | |
284 | * Mark inode fully dirty. Since we are allocating blocks, inode | |
285 | * would become fully dirty soon anyway and it reportedly | |
286 | * reduces lock contention. | |
287 | */ | |
288 | mark_inode_dirty(inode); | |
289 | } | |
290 | return ret; | |
291 | } | |
292 | ||
293 | static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr) | |
294 | { | |
295 | return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits); | |
296 | } | |
297 | ||
298 | static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr) | |
299 | { | |
300 | dquot_alloc_space_nofail(inode, nr << inode->i_blkbits); | |
301 | } | |
302 | ||
303 | static inline int dquot_alloc_block(struct inode *inode, qsize_t nr) | |
304 | { | |
305 | return dquot_alloc_space(inode, nr << inode->i_blkbits); | |
306 | } | |
307 | ||
308 | static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr) | |
309 | { | |
310 | return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0); | |
311 | } | |
312 | ||
313 | static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr) | |
314 | { | |
315 | int ret; | |
316 | ||
317 | ret = dquot_prealloc_block_nodirty(inode, nr); | |
318 | if (!ret) | |
319 | mark_inode_dirty_sync(inode); | |
320 | return ret; | |
321 | } | |
322 | ||
323 | static inline int dquot_reserve_block(struct inode *inode, qsize_t nr) | |
324 | { | |
325 | return __dquot_alloc_space(inode, nr << inode->i_blkbits, | |
326 | DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE); | |
327 | } | |
328 | ||
329 | static inline int dquot_claim_block(struct inode *inode, qsize_t nr) | |
330 | { | |
331 | int ret; | |
332 | ||
333 | ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits); | |
334 | if (!ret) | |
335 | mark_inode_dirty_sync(inode); | |
336 | return ret; | |
337 | } | |
338 | ||
339 | static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr) | |
340 | { | |
341 | __dquot_free_space(inode, nr, 0); | |
342 | } | |
343 | ||
344 | static inline void dquot_free_space(struct inode *inode, qsize_t nr) | |
345 | { | |
346 | dquot_free_space_nodirty(inode, nr); | |
347 | mark_inode_dirty_sync(inode); | |
348 | } | |
349 | ||
350 | static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr) | |
351 | { | |
352 | dquot_free_space_nodirty(inode, nr << inode->i_blkbits); | |
353 | } | |
354 | ||
355 | static inline void dquot_free_block(struct inode *inode, qsize_t nr) | |
356 | { | |
357 | dquot_free_space(inode, nr << inode->i_blkbits); | |
358 | } | |
359 | ||
360 | static inline void dquot_release_reservation_block(struct inode *inode, | |
361 | qsize_t nr) | |
362 | { | |
363 | __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE); | |
364 | } | |
365 | ||
366 | #endif /* _LINUX_QUOTAOPS_ */ |