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 0 : static inline bool is_quota_modification(struct mnt_idmap *idmap,
24 : struct inode *inode, struct iattr *ia)
25 : {
26 0 : return ((ia->ia_valid & ATTR_SIZE) ||
27 0 : i_uid_needs_update(idmap, ia, inode) ||
28 0 : i_gid_needs_update(idmap, ia, inode));
29 : }
30 :
31 : #if defined(CONFIG_QUOTA)
32 :
33 : #define quota_error(sb, fmt, args...) \
34 : __quota_error((sb), __func__, fmt , ## args)
35 :
36 : extern __printf(3, 4)
37 : void __quota_error(struct super_block *sb, const char *func,
38 : const char *fmt, ...);
39 :
40 : /*
41 : * declaration of quota_function calls in kernel.
42 : */
43 : int dquot_initialize(struct inode *inode);
44 : bool dquot_initialize_needed(struct inode *inode);
45 : void dquot_drop(struct inode *inode);
46 : struct dquot *dqget(struct super_block *sb, struct kqid qid);
47 : static inline struct dquot *dqgrab(struct dquot *dquot)
48 : {
49 : /* Make sure someone else has active reference to dquot */
50 : WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
51 : WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
52 : atomic_inc(&dquot->dq_count);
53 : return dquot;
54 : }
55 :
56 : static inline bool dquot_is_busy(struct dquot *dquot)
57 : {
58 : if (test_bit(DQ_MOD_B, &dquot->dq_flags))
59 : return true;
60 : if (atomic_read(&dquot->dq_count) > 1)
61 : return true;
62 : return false;
63 : }
64 :
65 : void dqput(struct dquot *dquot);
66 : int dquot_scan_active(struct super_block *sb,
67 : int (*fn)(struct dquot *dquot, unsigned long priv),
68 : unsigned long priv);
69 : struct dquot *dquot_alloc(struct super_block *sb, int type);
70 : void dquot_destroy(struct dquot *dquot);
71 :
72 : int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
73 : void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
74 :
75 : int dquot_alloc_inode(struct inode *inode);
76 :
77 : int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
78 : void dquot_free_inode(struct inode *inode);
79 : void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
80 :
81 : int dquot_disable(struct super_block *sb, int type, unsigned int flags);
82 : /* Suspend quotas on remount RO */
83 : static inline int dquot_suspend(struct super_block *sb, int type)
84 : {
85 0 : return dquot_disable(sb, type, DQUOT_SUSPENDED);
86 : }
87 : int dquot_resume(struct super_block *sb, int type);
88 :
89 : int dquot_commit(struct dquot *dquot);
90 : int dquot_acquire(struct dquot *dquot);
91 : int dquot_release(struct dquot *dquot);
92 : int dquot_commit_info(struct super_block *sb, int type);
93 : int dquot_get_next_id(struct super_block *sb, struct kqid *qid);
94 : int dquot_mark_dquot_dirty(struct dquot *dquot);
95 :
96 : int dquot_file_open(struct inode *inode, struct file *file);
97 :
98 : int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
99 : unsigned int flags);
100 : int dquot_load_quota_inode(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 mnt_idmap *idmap, struct inode *inode,
120 : struct iattr *iattr);
121 :
122 : static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
123 : {
124 : return sb_dqopt(sb)->info + type;
125 : }
126 :
127 : /*
128 : * Functions for checking status of quota
129 : */
130 :
131 : static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
132 : {
133 : return sb_dqopt(sb)->flags &
134 : dquot_state_flag(DQUOT_USAGE_ENABLED, type);
135 : }
136 :
137 : static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
138 : {
139 0 : return sb_dqopt(sb)->flags &
140 : dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
141 : }
142 :
143 : static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
144 : {
145 : return sb_dqopt(sb)->flags &
146 : dquot_state_flag(DQUOT_SUSPENDED, type);
147 : }
148 :
149 : static inline unsigned sb_any_quota_suspended(struct super_block *sb)
150 : {
151 0 : return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
152 : }
153 :
154 : /* Does kernel know about any quota information for given sb + type? */
155 : static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
156 : {
157 : /* Currently if anything is on, then quota usage is on as well */
158 : return sb_has_quota_usage_enabled(sb, type);
159 : }
160 :
161 : static inline unsigned sb_any_quota_loaded(struct super_block *sb)
162 : {
163 0 : return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
164 : }
165 :
166 : static inline bool sb_has_quota_active(struct super_block *sb, int type)
167 : {
168 : return sb_has_quota_loaded(sb, type) &&
169 : !sb_has_quota_suspended(sb, type);
170 : }
171 :
172 : /*
173 : * Operations supported for diskquotas.
174 : */
175 : extern const struct dquot_operations dquot_operations;
176 : extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
177 :
178 : #else
179 :
180 : static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
181 : {
182 : return 0;
183 : }
184 :
185 : static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
186 : {
187 : return 0;
188 : }
189 :
190 : static inline int sb_has_quota_suspended(struct super_block *sb, int type)
191 : {
192 : return 0;
193 : }
194 :
195 : static inline int sb_any_quota_suspended(struct super_block *sb)
196 : {
197 : return 0;
198 : }
199 :
200 : /* Does kernel know about any quota information for given sb + type? */
201 : static inline int sb_has_quota_loaded(struct super_block *sb, int type)
202 : {
203 : return 0;
204 : }
205 :
206 : static inline int sb_any_quota_loaded(struct super_block *sb)
207 : {
208 : return 0;
209 : }
210 :
211 : static inline int sb_has_quota_active(struct super_block *sb, int type)
212 : {
213 : return 0;
214 : }
215 :
216 : static inline int dquot_initialize(struct inode *inode)
217 : {
218 : return 0;
219 : }
220 :
221 : static inline bool dquot_initialize_needed(struct inode *inode)
222 : {
223 : return false;
224 : }
225 :
226 : static inline void dquot_drop(struct inode *inode)
227 : {
228 : }
229 :
230 : static inline int dquot_alloc_inode(struct inode *inode)
231 : {
232 : return 0;
233 : }
234 :
235 : static inline void dquot_free_inode(struct inode *inode)
236 : {
237 : }
238 :
239 : static inline int dquot_transfer(struct mnt_idmap *idmap,
240 : 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 : static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
299 : {
300 0 : 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 0 : }
308 :
309 0 : static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
310 : {
311 0 : int ret;
312 :
313 0 : ret = dquot_alloc_space_nodirty(inode, nr);
314 0 : 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 0 : mark_inode_dirty(inode);
321 : }
322 0 : 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 : 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 : static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
336 : {
337 0 : 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 : static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
356 : {
357 0 : return __dquot_alloc_space(inode, nr << inode->i_blkbits,
358 : DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
359 : }
360 :
361 0 : static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
362 : {
363 0 : int ret;
364 :
365 0 : ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
366 0 : if (!ret)
367 0 : mark_inode_dirty_sync(inode);
368 0 : 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 : static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
378 : {
379 0 : __dquot_free_space(inode, nr, 0);
380 : }
381 :
382 0 : static inline void dquot_free_space(struct inode *inode, qsize_t nr)
383 : {
384 0 : dquot_free_space_nodirty(inode, nr);
385 0 : 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 : static inline void dquot_free_block(struct inode *inode, qsize_t nr)
394 : {
395 0 : dquot_free_space(inode, nr << inode->i_blkbits);
396 0 : }
397 :
398 : 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_ */
|
