xref: /linux-6.15/include/linux/quotaops.h (revision ca91ddef) 
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 <[email protected]>
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 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 static inline struct dquot *dqgrab(struct dquot *dquot)
50 {
51 	/* Make sure someone else has active reference to dquot */
52 	WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
53 	WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
54 	atomic_inc(&dquot->dq_count);
55 	return dquot;
56 }
57 
58 static inline bool dquot_is_busy(struct dquot *dquot)
59 {
60 	if (test_bit(DQ_MOD_B, &dquot->dq_flags))
61 		return true;
62 	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 	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 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
124 {
125 	return sb_dqopt(sb)->info + type;
126 }
127 
128 /*
129  * Functions for checking status of quota
130  */
131 
132 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
133 {
134 	return sb_dqopt(sb)->flags &
135 				dquot_state_flag(DQUOT_USAGE_ENABLED, type);
136 }
137 
138 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
139 {
140 	return sb_dqopt(sb)->flags &
141 				dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
142 }
143 
144 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
145 {
146 	return sb_dqopt(sb)->flags &
147 				dquot_state_flag(DQUOT_SUSPENDED, type);
148 }
149 
150 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
151 {
152 	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 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 	return sb_has_quota_usage_enabled(sb, type);
160 }
161 
162 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
163 {
164 	return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
165 }
166 
167 static inline bool sb_has_quota_active(struct super_block *sb, int type)
168 {
169 	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 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
299 {
300 	return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
301 }
302 
303 static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
304 {
305 	__dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
306 	mark_inode_dirty_sync(inode);
307 }
308 
309 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
310 {
311 	int ret;
312 
313 	ret = dquot_alloc_space_nodirty(inode, nr);
314 	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 		mark_inode_dirty(inode);
321 	}
322 	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 	dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
333 }
334 
335 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
336 {
337 	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 	return __dquot_alloc_space(inode, nr << inode->i_blkbits,
358 				DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
359 }
360 
361 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
362 {
363 	int ret;
364 
365 	ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
366 	if (!ret)
367 		mark_inode_dirty_sync(inode);
368 	return ret;
369 }
370 
371 static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
372 {
373 	dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
374 	mark_inode_dirty_sync(inode);
375 }
376 
377 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
378 {
379 	__dquot_free_space(inode, nr, 0);
380 }
381 
382 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
383 {
384 	dquot_free_space_nodirty(inode, nr);
385 	mark_inode_dirty_sync(inode);
386 }
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 	dquot_free_space(inode, nr << inode->i_blkbits);
396 }
397 
398 static inline void dquot_release_reservation_block(struct inode *inode,
399 		qsize_t nr)
400 {
401 	__dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
402 }
403 
404 unsigned int qtype_enforce_flag(int type);
405 
406 #endif /* _LINUX_QUOTAOPS_ */
407