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