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 : : static inline struct quota_info *sb_dqopt(struct super_block *sb)
18 : : {
19 : : return &sb->s_dquot;
20 : : }
21 : :
22 : : /* i_mutex must being held */
23 : 4189 : static inline bool is_quota_modification(struct inode *inode, struct iattr *ia)
24 : : {
25 [ + + ]: 11833 : return (ia->ia_valid & ATTR_SIZE) ||
26 [ + + + - : 8531 : (ia->ia_valid & ATTR_UID && !uid_eq(ia->ia_uid, inode->i_uid)) ||
+ + ]
27 [ + + ]: 4342 : (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 : : 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 : : 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 : : 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_enable(struct inode *inode, int type, int format_id,
101 : : unsigned int flags);
102 : : int dquot_quota_on(struct super_block *sb, int type, int format_id,
103 : : const struct path *path);
104 : : int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
105 : : int format_id, int type);
106 : : int dquot_quota_off(struct super_block *sb, int type);
107 : : int dquot_writeback_dquots(struct super_block *sb, int type);
108 : : int dquot_quota_sync(struct super_block *sb, int type);
109 : : int dquot_get_state(struct super_block *sb, struct qc_state *state);
110 : : int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
111 : : int dquot_get_dqblk(struct super_block *sb, struct kqid id,
112 : : struct qc_dqblk *di);
113 : : int dquot_get_next_dqblk(struct super_block *sb, struct kqid *id,
114 : : struct qc_dqblk *di);
115 : : int dquot_set_dqblk(struct super_block *sb, struct kqid id,
116 : : struct qc_dqblk *di);
117 : :
118 : : int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
119 : : int dquot_transfer(struct inode *inode, struct iattr *iattr);
120 : :
121 : : static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
122 : : {
123 : : return sb_dqopt(sb)->info + type;
124 : : }
125 : :
126 : : /*
127 : : * Functions for checking status of quota
128 : : */
129 : :
130 : : static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
131 : : {
132 : 4968 : return sb_dqopt(sb)->flags &
133 : : dquot_state_flag(DQUOT_USAGE_ENABLED, type);
134 : : }
135 : :
136 : : static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
137 : : {
138 : 0 : return sb_dqopt(sb)->flags &
139 : : dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
140 : : }
141 : :
142 : : static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
143 : : {
144 : 0 : return sb_dqopt(sb)->flags &
145 : : dquot_state_flag(DQUOT_SUSPENDED, type);
146 : : }
147 : :
148 : : static inline unsigned sb_any_quota_suspended(struct super_block *sb)
149 : : {
150 : 207 : return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
151 : : }
152 : :
153 : : /* Does kernel know about any quota information for given sb + type? */
154 : : static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
155 : : {
156 : : /* Currently if anything is on, then quota usage is on as well */
157 : : return sb_has_quota_usage_enabled(sb, type);
158 : : }
159 : :
160 : : static inline unsigned sb_any_quota_loaded(struct super_block *sb)
161 : : {
162 : 713996 : return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
163 : : }
164 : :
165 : : static inline bool sb_has_quota_active(struct super_block *sb, int type)
166 : : {
167 [ # # # # : 2484 : return sb_has_quota_loaded(sb, type) &&
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
# # # # #
- + # # -
+ # # ]
168 : : !sb_has_quota_suspended(sb, type);
169 : : }
170 : :
171 : : /*
172 : : * Operations supported for diskquotas.
173 : : */
174 : : extern const struct dquot_operations dquot_operations;
175 : : extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
176 : :
177 : : #else
178 : :
179 : : static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
180 : : {
181 : : return 0;
182 : : }
183 : :
184 : : static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
185 : : {
186 : : return 0;
187 : : }
188 : :
189 : : static inline int sb_has_quota_suspended(struct super_block *sb, int type)
190 : : {
191 : : return 0;
192 : : }
193 : :
194 : : static inline int sb_any_quota_suspended(struct super_block *sb)
195 : : {
196 : : return 0;
197 : : }
198 : :
199 : : /* Does kernel know about any quota information for given sb + type? */
200 : : static inline int sb_has_quota_loaded(struct super_block *sb, int type)
201 : : {
202 : : return 0;
203 : : }
204 : :
205 : : static inline int sb_any_quota_loaded(struct super_block *sb)
206 : : {
207 : : return 0;
208 : : }
209 : :
210 : : static inline int sb_has_quota_active(struct super_block *sb, int type)
211 : : {
212 : : return 0;
213 : : }
214 : :
215 : : static inline int dquot_initialize(struct inode *inode)
216 : : {
217 : : return 0;
218 : : }
219 : :
220 : : static inline bool dquot_initialize_needed(struct inode *inode)
221 : : {
222 : : return false;
223 : : }
224 : :
225 : : static inline void dquot_drop(struct inode *inode)
226 : : {
227 : : }
228 : :
229 : : static inline int dquot_alloc_inode(struct inode *inode)
230 : : {
231 : : return 0;
232 : : }
233 : :
234 : : static inline void dquot_free_inode(struct inode *inode)
235 : : {
236 : : }
237 : :
238 : : static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
239 : : {
240 : : return 0;
241 : : }
242 : :
243 : : static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
244 : : int flags)
245 : : {
246 : : if (!(flags & DQUOT_SPACE_RESERVE))
247 : : inode_add_bytes(inode, number);
248 : : return 0;
249 : : }
250 : :
251 : : static inline void __dquot_free_space(struct inode *inode, qsize_t number,
252 : : int flags)
253 : : {
254 : : if (!(flags & DQUOT_SPACE_RESERVE))
255 : : inode_sub_bytes(inode, number);
256 : : }
257 : :
258 : : static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
259 : : {
260 : : inode_add_bytes(inode, number);
261 : : return 0;
262 : : }
263 : :
264 : : static inline int dquot_reclaim_space_nodirty(struct inode *inode,
265 : : qsize_t number)
266 : : {
267 : : inode_sub_bytes(inode, number);
268 : : return 0;
269 : : }
270 : :
271 : : static inline int dquot_disable(struct super_block *sb, int type,
272 : : unsigned int flags)
273 : : {
274 : : return 0;
275 : : }
276 : :
277 : : static inline int dquot_suspend(struct super_block *sb, int type)
278 : : {
279 : : return 0;
280 : : }
281 : :
282 : : static inline int dquot_resume(struct super_block *sb, int type)
283 : : {
284 : : return 0;
285 : : }
286 : :
287 : : #define dquot_file_open generic_file_open
288 : :
289 : : static inline int dquot_writeback_dquots(struct super_block *sb, int type)
290 : : {
291 : : return 0;
292 : : }
293 : :
294 : : #endif /* CONFIG_QUOTA */
295 : :
296 : : static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
297 : : {
298 : 45790 : return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
299 : : }
300 : :
301 : 7 : static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
302 : : {
303 : 7 : __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
304 : : mark_inode_dirty_sync(inode);
305 : 7 : }
306 : :
307 : 45790 : static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
308 : : {
309 : : int ret;
310 : :
311 : : ret = dquot_alloc_space_nodirty(inode, nr);
312 [ + - ]: 45790 : if (!ret) {
313 : : /*
314 : : * Mark inode fully dirty. Since we are allocating blocks, inode
315 : : * would become fully dirty soon anyway and it reportedly
316 : : * reduces lock contention.
317 : : */
318 : : mark_inode_dirty(inode);
319 : : }
320 : 45790 : return ret;
321 : : }
322 : :
323 : : static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
324 : : {
325 : : return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
326 : : }
327 : :
328 : : static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
329 : : {
330 : 7 : dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
331 : : }
332 : :
333 : : static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
334 : : {
335 : 45790 : return dquot_alloc_space(inode, nr << inode->i_blkbits);
336 : : }
337 : :
338 : : static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
339 : : {
340 : : return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
341 : : }
342 : :
343 : : static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
344 : : {
345 : : int ret;
346 : :
347 : : ret = dquot_prealloc_block_nodirty(inode, nr);
348 : : if (!ret)
349 : : mark_inode_dirty_sync(inode);
350 : : return ret;
351 : : }
352 : :
353 : : static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
354 : : {
355 : 173878 : return __dquot_alloc_space(inode, nr << inode->i_blkbits,
356 : : DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
357 : : }
358 : :
359 : 13636 : static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
360 : : {
361 : : int ret;
362 : :
363 : 13636 : ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
364 [ + - ]: 13636 : if (!ret)
365 : : mark_inode_dirty_sync(inode);
366 : 13636 : return ret;
367 : : }
368 : :
369 : 0 : static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
370 : : {
371 : 0 : dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
372 : : mark_inode_dirty_sync(inode);
373 : 0 : }
374 : :
375 : : static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
376 : : {
377 : 3796 : __dquot_free_space(inode, nr, 0);
378 : : }
379 : :
380 : 3796 : static inline void dquot_free_space(struct inode *inode, qsize_t nr)
381 : : {
382 : : dquot_free_space_nodirty(inode, nr);
383 : : mark_inode_dirty_sync(inode);
384 : 3796 : }
385 : :
386 : : static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
387 : : {
388 : : dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
389 : : }
390 : :
391 : : static inline void dquot_free_block(struct inode *inode, qsize_t nr)
392 : : {
393 : 3794 : dquot_free_space(inode, nr << inode->i_blkbits);
394 : : }
395 : :
396 : : static inline void dquot_release_reservation_block(struct inode *inode,
397 : : qsize_t nr)
398 : : {
399 : 474 : __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
400 : : }
401 : :
402 : : unsigned int qtype_enforce_flag(int type);
403 : :
404 : : #endif /* _LINUX_QUOTAOPS_ */
|
