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