Branch data Line data Source code
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 [ + + ][ + + ]: 43837 : return (ia->ia_valid & ATTR_SIZE && ia->ia_size != inode->i_size) ||
25 [ + + ][ + + ]: 50695 : (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
[ + + ]
26 [ + + ]: 1308 : (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 : : void inode_reclaim_rsv_space(struct inode *inode, qsize_t number);
45 : :
46 : : void dquot_initialize(struct inode *inode);
47 : : void dquot_drop(struct inode *inode);
48 : : struct dquot *dqget(struct super_block *sb, struct kqid qid);
49 : : void dqput(struct dquot *dquot);
50 : : int dquot_scan_active(struct super_block *sb,
51 : : int (*fn)(struct dquot *dquot, unsigned long priv),
52 : : unsigned long priv);
53 : : struct dquot *dquot_alloc(struct super_block *sb, int type);
54 : : void dquot_destroy(struct dquot *dquot);
55 : :
56 : : int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
57 : : void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
58 : :
59 : : int dquot_alloc_inode(const struct inode *inode);
60 : :
61 : : int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
62 : : void dquot_free_inode(const struct inode *inode);
63 : : void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
64 : :
65 : : int dquot_disable(struct super_block *sb, int type, unsigned int flags);
66 : : /* Suspend quotas on remount RO */
67 : : static inline int dquot_suspend(struct super_block *sb, int type)
68 : : {
69 : 2 : return dquot_disable(sb, type, DQUOT_SUSPENDED);
70 : : }
71 : : int dquot_resume(struct super_block *sb, int type);
72 : :
73 : : int dquot_commit(struct dquot *dquot);
74 : : int dquot_acquire(struct dquot *dquot);
75 : : int dquot_release(struct dquot *dquot);
76 : : int dquot_commit_info(struct super_block *sb, int type);
77 : : int dquot_mark_dquot_dirty(struct dquot *dquot);
78 : :
79 : : int dquot_file_open(struct inode *inode, struct file *file);
80 : :
81 : : int dquot_enable(struct inode *inode, int type, int format_id,
82 : : unsigned int flags);
83 : : int dquot_quota_on(struct super_block *sb, int type, int format_id,
84 : : struct path *path);
85 : : int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
86 : : int format_id, int type);
87 : : int dquot_quota_off(struct super_block *sb, int type);
88 : : int dquot_writeback_dquots(struct super_block *sb, int type);
89 : : int dquot_quota_sync(struct super_block *sb, int type);
90 : : int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
91 : : int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
92 : : int dquot_get_dqblk(struct super_block *sb, struct kqid id,
93 : : struct fs_disk_quota *di);
94 : : int dquot_set_dqblk(struct super_block *sb, struct kqid id,
95 : : struct fs_disk_quota *di);
96 : :
97 : : int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
98 : : int dquot_transfer(struct inode *inode, struct iattr *iattr);
99 : :
100 : : static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
101 : : {
102 : 0 : return sb_dqopt(sb)->info + type;
103 : : }
104 : :
105 : : /*
106 : : * Functions for checking status of quota
107 : : */
108 : :
109 : : static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
110 : : {
111 : 28309268 : return sb_dqopt(sb)->flags &
112 : : dquot_state_flag(DQUOT_USAGE_ENABLED, type);
113 : : }
114 : :
115 : : static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
116 : : {
117 : 0 : return sb_dqopt(sb)->flags &
118 : : dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
119 : : }
120 : :
121 : : static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
122 : : {
123 : 28272424 : return sb_dqopt(sb)->flags &
124 : : dquot_state_flag(DQUOT_SUSPENDED, type);
125 : : }
126 : :
127 : : static inline unsigned sb_any_quota_suspended(struct super_block *sb)
128 : : {
129 : : unsigned type, tmsk = 0;
130 [ + + ]: 21204331 : for (type = 0; type < MAXQUOTAS; type++)
131 : 28272420 : tmsk |= sb_has_quota_suspended(sb, type) << type;
132 : : return tmsk;
133 : : }
134 : :
135 : : /* Does kernel know about any quota information for given sb + type? */
136 : : static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
137 : : {
138 : : /* Currently if anything is on, then quota usage is on as well */
139 : : return sb_has_quota_usage_enabled(sb, type);
140 : : }
141 : :
142 : : static inline unsigned sb_any_quota_loaded(struct super_block *sb)
143 : : {
144 : : unsigned type, tmsk = 0;
145 [ + + ][ # # ]: 28265306 : for (type = 0; type < MAXQUOTAS; type++)
[ # # ][ # # ]
[ + + ]
146 : 28261148 : tmsk |= sb_has_quota_loaded(sb, type) << type;
147 : : return tmsk;
148 : : }
149 : :
150 : : static inline bool sb_has_quota_active(struct super_block *sb, int type)
151 : : {
152 [ # # ][ # # ]: 24060 : return sb_has_quota_loaded(sb, type) &&
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ - + ][ # # ]
[ - + ][ # # ]
153 : : !sb_has_quota_suspended(sb, type);
154 : : }
155 : :
156 : : /*
157 : : * Operations supported for diskquotas.
158 : : */
159 : : extern const struct dquot_operations dquot_operations;
160 : : extern const struct quotactl_ops dquot_quotactl_ops;
161 : :
162 : : #else
163 : :
164 : : static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
165 : : {
166 : : return 0;
167 : : }
168 : :
169 : : static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
170 : : {
171 : : return 0;
172 : : }
173 : :
174 : : static inline int sb_has_quota_suspended(struct super_block *sb, int type)
175 : : {
176 : : return 0;
177 : : }
178 : :
179 : : static inline int sb_any_quota_suspended(struct super_block *sb)
180 : : {
181 : : return 0;
182 : : }
183 : :
184 : : /* Does kernel know about any quota information for given sb + type? */
185 : : static inline int sb_has_quota_loaded(struct super_block *sb, int type)
186 : : {
187 : : return 0;
188 : : }
189 : :
190 : : static inline int sb_any_quota_loaded(struct super_block *sb)
191 : : {
192 : : return 0;
193 : : }
194 : :
195 : : static inline int sb_has_quota_active(struct super_block *sb, int type)
196 : : {
197 : : return 0;
198 : : }
199 : :
200 : : static inline void dquot_initialize(struct inode *inode)
201 : : {
202 : : }
203 : :
204 : : static inline void dquot_drop(struct inode *inode)
205 : : {
206 : : }
207 : :
208 : : static inline int dquot_alloc_inode(const struct inode *inode)
209 : : {
210 : : return 0;
211 : : }
212 : :
213 : : static inline void dquot_free_inode(const struct inode *inode)
214 : : {
215 : : }
216 : :
217 : : static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
218 : : {
219 : : return 0;
220 : : }
221 : :
222 : : static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
223 : : int flags)
224 : : {
225 : : if (!(flags & DQUOT_SPACE_RESERVE))
226 : : inode_add_bytes(inode, number);
227 : : return 0;
228 : : }
229 : :
230 : : static inline void __dquot_free_space(struct inode *inode, qsize_t number,
231 : : int flags)
232 : : {
233 : : if (!(flags & DQUOT_SPACE_RESERVE))
234 : : inode_sub_bytes(inode, number);
235 : : }
236 : :
237 : : static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
238 : : {
239 : : inode_add_bytes(inode, number);
240 : : return 0;
241 : : }
242 : :
243 : : static inline int dquot_reclaim_space_nodirty(struct inode *inode,
244 : : qsize_t number)
245 : : {
246 : : inode_sub_bytes(inode, number);
247 : : return 0;
248 : : }
249 : :
250 : : static inline int dquot_disable(struct super_block *sb, int type,
251 : : unsigned int flags)
252 : : {
253 : : return 0;
254 : : }
255 : :
256 : : static inline int dquot_suspend(struct super_block *sb, int type)
257 : : {
258 : : return 0;
259 : : }
260 : :
261 : : static inline int dquot_resume(struct super_block *sb, int type)
262 : : {
263 : : return 0;
264 : : }
265 : :
266 : : #define dquot_file_open generic_file_open
267 : :
268 : : static inline int dquot_writeback_dquots(struct super_block *sb, int type)
269 : : {
270 : : return 0;
271 : : }
272 : :
273 : : #endif /* CONFIG_QUOTA */
274 : :
275 : : static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
276 : : {
277 : 108035 : return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
278 : : }
279 : :
280 : : static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
281 : : {
282 : 459 : __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
283 : : mark_inode_dirty_sync(inode);
284 : : }
285 : :
286 : : static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
287 : : {
288 : : int ret;
289 : :
290 : : ret = dquot_alloc_space_nodirty(inode, nr);
291 [ + + ]: 108080 : if (!ret) {
292 : : /*
293 : : * Mark inode fully dirty. Since we are allocating blocks, inode
294 : : * would become fully dirty soon anyway and it reportedly
295 : : * reduces lock contention.
296 : : */
297 : : mark_inode_dirty(inode);
298 : : }
299 : : return ret;
300 : : }
301 : :
302 : : static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
303 : : {
304 : : return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
305 : : }
306 : :
307 : : static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
308 : : {
309 : 459 : dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
310 : : }
311 : :
312 : : static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
313 : : {
314 : 108035 : return dquot_alloc_space(inode, nr << inode->i_blkbits);
315 : : }
316 : :
317 : : static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
318 : : {
319 : : return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
320 : : }
321 : :
322 : : static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
323 : : {
324 : : int ret;
325 : :
326 : : ret = dquot_prealloc_block_nodirty(inode, nr);
327 : : if (!ret)
328 : : mark_inode_dirty_sync(inode);
329 : : return ret;
330 : : }
331 : :
332 : : static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
333 : : {
334 : 1760018 : return __dquot_alloc_space(inode, nr << inode->i_blkbits,
335 : : DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
336 : : }
337 : :
338 : : static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
339 : : {
340 : : int ret;
341 : :
342 : 86050 : ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
343 [ + ]: 86029 : if (!ret)
344 : : mark_inode_dirty_sync(inode);
345 : : return ret;
346 : : }
347 : :
348 : : static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
349 : : {
350 : 191 : dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
351 : : mark_inode_dirty_sync(inode);
352 : : }
353 : :
354 : : static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
355 : : {
356 : 109881 : __dquot_free_space(inode, nr, 0);
357 : : }
358 : :
359 : : static inline void dquot_free_space(struct inode *inode, qsize_t nr)
360 : : {
361 : : dquot_free_space_nodirty(inode, nr);
362 : : mark_inode_dirty_sync(inode);
363 : : }
364 : :
365 : : static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
366 : : {
367 : 0 : dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
368 : : }
369 : :
370 : : static inline void dquot_free_block(struct inode *inode, qsize_t nr)
371 : : {
372 : 109881 : dquot_free_space(inode, nr << inode->i_blkbits);
373 : : }
374 : :
375 : : static inline void dquot_release_reservation_block(struct inode *inode,
376 : : qsize_t nr)
377 : : {
378 : 1147491 : __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
379 : : }
380 : :
381 : : #endif /* _LINUX_QUOTAOPS_ */
|
