Branch data Line data Source code
1 : : /* SPDX-License-Identifier: GPL-2.0 */
2 : : /*
3 : : * Definitions for diskquota-operations. When diskquota is configured these
4 : : * macros expand to the right source-code.
5 : : *
6 : : * Author: Marco van Wieringen <mvw@planets.elm.net>
7 : : */
8 : : #ifndef _LINUX_QUOTAOPS_
9 : : #define _LINUX_QUOTAOPS_
10 : :
11 : : #include <linux/fs.h>
12 : :
13 : : #define DQUOT_SPACE_WARN 0x1
14 : : #define DQUOT_SPACE_RESERVE 0x2
15 : : #define DQUOT_SPACE_NOFAIL 0x4
16 : :
17 : 42140 : static inline struct quota_info *sb_dqopt(struct super_block *sb)
18 : : {
19 [ # # # # : 0 : return &sb->s_dquot;
# # # # #
# # # # #
# # # # #
# # # #
# ]
20 : : }
21 : :
22 : : /* i_mutex must being held */
23 : 481 : static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
24 : : {
25 : 962 : return (ia->ia_valid & ATTR_SIZE) ||
26 [ + - + + : 949 : (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
+ + + + ]
27 [ + + + + ]: 468 : (ia->ia_valid & ATTR_GID && !gid_eq(ia->ia_gid, inode->i_gid));
28 : : }
29 : :
30 : : int kernel_quotactl(unsigned int cmd, const char __user *special,
31 : : qid_t id, void __user *addr);
32 : :
33 : : #if defined(CONFIG_QUOTA)
34 : :
35 : : #define quota_error(sb, fmt, args...) \
36 : : __quota_error((sb), __func__, fmt , ## args)
37 : :
38 : : extern __printf(3, 4)
39 : : void __quota_error(struct super_block *sb, const char *func,
40 : : const char *fmt, ...);
41 : :
42 : : /*
43 : : * declaration of quota_function calls in kernel.
44 : : */
45 : : int dquot_initialize(struct inode *inode);
46 : : bool dquot_initialize_needed(struct inode *inode);
47 : : void dquot_drop(struct inode *inode);
48 : : struct dquot *dqget(struct super_block *sb, struct kqid qid);
49 : 0 : static inline struct dquot *dqgrab(struct dquot *dquot)
50 : : {
51 : : /* Make sure someone else has active reference to dquot */
52 [ # # ]: 0 : WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
53 [ # # ]: 0 : WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
54 : 0 : atomic_inc(&dquot->dq_count);
55 : 0 : return dquot;
56 : : }
57 : :
58 : 0 : static inline bool dquot_is_busy(struct dquot *dquot)
59 : : {
60 [ # # ]: 0 : if (test_bit(DQ_MOD_B, &dquot->dq_flags))
61 : : return true;
62 [ # # ]: 0 : if (atomic_read(&dquot->dq_count) > 1)
63 : 0 : return true;
64 : : return false;
65 : : }
66 : :
67 : : void dqput(struct dquot *dquot);
68 : : int dquot_scan_active(struct super_block *sb,
69 : : int (*fn)(struct dquot *dquot, unsigned long priv),
70 : : unsigned long priv);
71 : : struct dquot *dquot_alloc(struct super_block *sb, int type);
72 : : void dquot_destroy(struct dquot *dquot);
73 : :
74 : : int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
75 : : void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
76 : :
77 : : int dquot_alloc_inode(struct inode *inode);
78 : :
79 : : int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
80 : : void dquot_free_inode(struct inode *inode);
81 : : void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
82 : :
83 : : int dquot_disable(struct super_block *sb, int type, unsigned int flags);
84 : : /* Suspend quotas on remount RO */
85 : 0 : static inline int dquot_suspend(struct super_block *sb, int type)
86 : : {
87 : 0 : return dquot_disable(sb, type, DQUOT_SUSPENDED);
88 : : }
89 : : int dquot_resume(struct super_block *sb, int type);
90 : :
91 : : int dquot_commit(struct dquot *dquot);
92 : : int dquot_acquire(struct dquot *dquot);
93 : : int dquot_release(struct dquot *dquot);
94 : : int dquot_commit_info(struct super_block *sb, int type);
95 : : int dquot_get_next_id(struct super_block *sb, struct kqid *qid);
96 : : int dquot_mark_dquot_dirty(struct dquot *dquot);
97 : :
98 : : int dquot_file_open(struct inode *inode, struct file *file);
99 : :
100 : : int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
101 : : unsigned int flags);
102 : : int dquot_load_quota_inode(struct inode *inode, int type, int format_id,
103 : : unsigned int flags);
104 : : int dquot_quota_on(struct super_block *sb, int type, int format_id,
105 : : const struct path *path);
106 : : int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
107 : : int format_id, int type);
108 : : int dquot_quota_off(struct super_block *sb, int type);
109 : : int dquot_writeback_dquots(struct super_block *sb, int type);
110 : : int dquot_quota_sync(struct super_block *sb, int type);
111 : : int dquot_get_state(struct super_block *sb, struct qc_state *state);
112 : : int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
113 : : int dquot_get_dqblk(struct super_block *sb, struct kqid id,
114 : : struct qc_dqblk *di);
115 : : int dquot_get_next_dqblk(struct super_block *sb, struct kqid *id,
116 : : struct qc_dqblk *di);
117 : : int dquot_set_dqblk(struct super_block *sb, struct kqid id,
118 : : struct qc_dqblk *di);
119 : :
120 : : int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
121 : : int dquot_transfer(struct inode *inode, struct iattr *iattr);
122 : :
123 : 0 : static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
124 : : {
125 : 0 : return sb_dqopt(sb)->info + type;
126 : : }
127 : :
128 : : /*
129 : : * Functions for checking status of quota
130 : : */
131 : :
132 : 0 : static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
133 : : {
134 [ # # ]: 0 : return sb_dqopt(sb)->flags &
135 : : dquot_state_flag(DQUOT_USAGE_ENABLED, type);
136 : : }
137 : :
138 : 0 : static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
139 : : {
140 [ # # # # : 0 : return sb_dqopt(sb)->flags &
# # # # #
# # # ]
141 : : dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
142 : : }
143 : :
144 : 0 : static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
145 : : {
146 [ # # # # : 0 : return sb_dqopt(sb)->flags &
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# ]
147 : : dquot_state_flag(DQUOT_SUSPENDED, type);
148 : : }
149 : :
150 : 42140 : static inline unsigned sb_any_quota_suspended(struct super_block *sb)
151 : : {
152 [ - + + - : 42140 : return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
+ - - - +
- - + + -
- - - + ]
153 : : }
154 : :
155 : : /* Does kernel know about any quota information for given sb + type? */
156 : 0 : static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
157 : : {
158 : : /* Currently if anything is on, then quota usage is on as well */
159 [ # # # # : 0 : return sb_has_quota_usage_enabled(sb, type);
# # # # #
# # # #
# ]
160 : : }
161 : :
162 : 42127 : static inline unsigned sb_any_quota_loaded(struct super_block *sb)
163 : : {
164 [ - - - + : 42127 : return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
+ - + - -
- + - - +
+ - - - -
+ ]
165 : : }
166 : :
167 : 0 : static inline bool sb_has_quota_active(struct super_block *sb, int type)
168 : : {
169 [ # # # # : 0 : return sb_has_quota_loaded(sb, type) &&
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # ]
170 : : !sb_has_quota_suspended(sb, type);
171 : : }
172 : :
173 : : /*
174 : : * Operations supported for diskquotas.
175 : : */
176 : : extern const struct dquot_operations dquot_operations;
177 : : extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
178 : :
179 : : #else
180 : :
181 : : static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
182 : : {
183 : : return 0;
184 : : }
185 : :
186 : : static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
187 : : {
188 : : return 0;
189 : : }
190 : :
191 : : static inline int sb_has_quota_suspended(struct super_block *sb, int type)
192 : : {
193 : : return 0;
194 : : }
195 : :
196 : : static inline int sb_any_quota_suspended(struct super_block *sb)
197 : : {
198 : : return 0;
199 : : }
200 : :
201 : : /* Does kernel know about any quota information for given sb + type? */
202 : : static inline int sb_has_quota_loaded(struct super_block *sb, int type)
203 : : {
204 : : return 0;
205 : : }
206 : :
207 : : static inline int sb_any_quota_loaded(struct super_block *sb)
208 : : {
209 : : return 0;
210 : : }
211 : :
212 : : static inline int sb_has_quota_active(struct super_block *sb, int type)
213 : : {
214 : : return 0;
215 : : }
216 : :
217 : : static inline int dquot_initialize(struct inode *inode)
218 : : {
219 : : return 0;
220 : : }
221 : :
222 : : static inline bool dquot_initialize_needed(struct inode *inode)
223 : : {
224 : : return false;
225 : : }
226 : :
227 : : static inline void dquot_drop(struct inode *inode)
228 : : {
229 : : }
230 : :
231 : : static inline int dquot_alloc_inode(struct inode *inode)
232 : : {
233 : : return 0;
234 : : }
235 : :
236 : : static inline void dquot_free_inode(struct inode *inode)
237 : : {
238 : : }
239 : :
240 : : static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
241 : : {
242 : : return 0;
243 : : }
244 : :
245 : : static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
246 : : int flags)
247 : : {
248 : : if (!(flags & DQUOT_SPACE_RESERVE))
249 : : inode_add_bytes(inode, number);
250 : : return 0;
251 : : }
252 : :
253 : : static inline void __dquot_free_space(struct inode *inode, qsize_t number,
254 : : int flags)
255 : : {
256 : : if (!(flags & DQUOT_SPACE_RESERVE))
257 : : inode_sub_bytes(inode, number);
258 : : }
259 : :
260 : : static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
261 : : {
262 : : inode_add_bytes(inode, number);
263 : : return 0;
264 : : }
265 : :
266 : : static inline int dquot_reclaim_space_nodirty(struct inode *inode,
267 : : qsize_t number)
268 : : {
269 : : inode_sub_bytes(inode, number);
270 : : return 0;
271 : : }
272 : :
273 : : static inline int dquot_disable(struct super_block *sb, int type,
274 : : unsigned int flags)
275 : : {
276 : : return 0;
277 : : }
278 : :
279 : : static inline int dquot_suspend(struct super_block *sb, int type)
280 : : {
281 : : return 0;
282 : : }
283 : :
284 : : static inline int dquot_resume(struct super_block *sb, int type)
285 : : {
286 : : return 0;
287 : : }
288 : :
289 : : #define dquot_file_open generic_file_open
290 : :
291 : : static inline int dquot_writeback_dquots(struct super_block *sb, int type)
292 : : {
293 : : return 0;
294 : : }
295 : :
296 : : #endif /* CONFIG_QUOTA */
297 : :
298 : 3250 : static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
299 : : {
300 : 3250 : return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
301 : : }
302 : :
303 : 0 : static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
304 : : {
305 : 0 : __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
306 : 0 : mark_inode_dirty_sync(inode);
307 : : }
308 : :
309 : 3250 : static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
310 : : {
311 : 3250 : int ret;
312 : :
313 : 3250 : ret = dquot_alloc_space_nodirty(inode, nr);
314 [ + - ]: 3250 : if (!ret) {
315 : : /*
316 : : * Mark inode fully dirty. Since we are allocating blocks, inode
317 : : * would become fully dirty soon anyway and it reportedly
318 : : * reduces lock contention.
319 : : */
320 : 3250 : mark_inode_dirty(inode);
321 : : }
322 : 3250 : return ret;
323 : : }
324 : :
325 : : static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
326 : : {
327 : : return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
328 : : }
329 : :
330 : 0 : static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
331 : : {
332 : 0 : dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
333 : 0 : }
334 : :
335 : 3250 : static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
336 : : {
337 : 3250 : return dquot_alloc_space(inode, nr << inode->i_blkbits);
338 : : }
339 : :
340 : : static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
341 : : {
342 : : return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
343 : : }
344 : :
345 : : static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
346 : : {
347 : : int ret;
348 : :
349 : : ret = dquot_prealloc_block_nodirty(inode, nr);
350 : : if (!ret)
351 : : mark_inode_dirty_sync(inode);
352 : : return ret;
353 : : }
354 : :
355 : 9419 : static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
356 : : {
357 : 9419 : return __dquot_alloc_space(inode, nr << inode->i_blkbits,
358 : : DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
359 : : }
360 : :
361 : 104 : static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
362 : : {
363 : 104 : int ret;
364 : :
365 : 104 : ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
366 [ + - ]: 104 : if (!ret)
367 : 104 : mark_inode_dirty_sync(inode);
368 : 104 : return ret;
369 : : }
370 : :
371 : 0 : static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
372 : : {
373 : 0 : dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
374 : 0 : mark_inode_dirty_sync(inode);
375 : 0 : }
376 : :
377 : 130 : static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
378 : : {
379 : 130 : __dquot_free_space(inode, nr, 0);
380 : : }
381 : :
382 : 130 : static inline void dquot_free_space(struct inode *inode, qsize_t nr)
383 : : {
384 : 130 : dquot_free_space_nodirty(inode, nr);
385 : 130 : mark_inode_dirty_sync(inode);
386 : 0 : }
387 : :
388 : : static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
389 : : {
390 : : dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
391 : : }
392 : :
393 : 130 : static inline void dquot_free_block(struct inode *inode, qsize_t nr)
394 : : {
395 : 130 : dquot_free_space(inode, nr << inode->i_blkbits);
396 : 130 : }
397 : :
398 : 0 : static inline void dquot_release_reservation_block(struct inode *inode,
399 : : qsize_t nr)
400 : : {
401 : 0 : __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
402 : 0 : }
403 : :
404 : : unsigned int qtype_enforce_flag(int type);
405 : :
406 : : #endif /* _LINUX_QUOTAOPS_ */
|
