xref: /linux-6.15/include/linux/quotaops.h (revision ee665ecc) 
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/smp_lock.h>
11 #include <linux/fs.h>
12 
13 static inline struct quota_info *sb_dqopt(struct super_block *sb)
14 {
15 	return &sb->s_dquot;
16 }
17 
18 #if defined(CONFIG_QUOTA)
19 
20 /*
21  * declaration of quota_function calls in kernel.
22  */
23 void sync_dquots(struct super_block *sb, int type);
24 
25 int dquot_initialize(struct inode *inode, int type);
26 int dquot_drop(struct inode *inode);
27 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
28 void dqput(struct dquot *dquot);
29 int dquot_scan_active(struct super_block *sb,
30 		      int (*fn)(struct dquot *dquot, unsigned long priv),
31 		      unsigned long priv);
32 struct dquot *dquot_alloc(struct super_block *sb, int type);
33 void dquot_destroy(struct dquot *dquot);
34 
35 int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
36 int dquot_alloc_inode(const struct inode *inode, qsize_t number);
37 
38 int dquot_reserve_space(struct inode *inode, qsize_t number, int prealloc);
39 int dquot_claim_space(struct inode *inode, qsize_t number);
40 void dquot_release_reserved_space(struct inode *inode, qsize_t number);
41 qsize_t dquot_get_reserved_space(struct inode *inode);
42 
43 int dquot_free_space(struct inode *inode, qsize_t number);
44 int dquot_free_inode(const struct inode *inode, qsize_t number);
45 
46 int dquot_transfer(struct inode *inode, struct iattr *iattr);
47 int dquot_commit(struct dquot *dquot);
48 int dquot_acquire(struct dquot *dquot);
49 int dquot_release(struct dquot *dquot);
50 int dquot_commit_info(struct super_block *sb, int type);
51 int dquot_mark_dquot_dirty(struct dquot *dquot);
52 
53 int vfs_quota_on(struct super_block *sb, int type, int format_id,
54  	char *path, int remount);
55 int vfs_quota_enable(struct inode *inode, int type, int format_id,
56 	unsigned int flags);
57 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
58  	struct path *path);
59 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
60  	int format_id, int type);
61 int vfs_quota_off(struct super_block *sb, int type, int remount);
62 int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags);
63 int vfs_quota_sync(struct super_block *sb, int type);
64 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
65 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
66 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
67 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
68 
69 void vfs_dq_drop(struct inode *inode);
70 int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
71 int vfs_dq_quota_on_remount(struct super_block *sb);
72 
73 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
74 {
75 	return sb_dqopt(sb)->info + type;
76 }
77 
78 /*
79  * Functions for checking status of quota
80  */
81 
82 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
83 {
84 	return sb_dqopt(sb)->flags &
85 				dquot_state_flag(DQUOT_USAGE_ENABLED, type);
86 }
87 
88 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
89 {
90 	return sb_dqopt(sb)->flags &
91 				dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
92 }
93 
94 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
95 {
96 	return sb_dqopt(sb)->flags &
97 				dquot_state_flag(DQUOT_SUSPENDED, type);
98 }
99 
100 static inline int sb_any_quota_suspended(struct super_block *sb)
101 {
102 	return sb_has_quota_suspended(sb, USRQUOTA) ||
103 		sb_has_quota_suspended(sb, GRPQUOTA);
104 }
105 
106 /* Does kernel know about any quota information for given sb + type? */
107 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
108 {
109 	/* Currently if anything is on, then quota usage is on as well */
110 	return sb_has_quota_usage_enabled(sb, type);
111 }
112 
113 static inline int sb_any_quota_loaded(struct super_block *sb)
114 {
115 	return sb_has_quota_loaded(sb, USRQUOTA) ||
116 		sb_has_quota_loaded(sb, GRPQUOTA);
117 }
118 
119 static inline int sb_has_quota_active(struct super_block *sb, int type)
120 {
121 	return sb_has_quota_loaded(sb, type) &&
122 	       !sb_has_quota_suspended(sb, type);
123 }
124 
125 static inline int sb_any_quota_active(struct super_block *sb)
126 {
127 	return sb_has_quota_active(sb, USRQUOTA) ||
128 	       sb_has_quota_active(sb, GRPQUOTA);
129 }
130 
131 /*
132  * Operations supported for diskquotas.
133  */
134 extern struct dquot_operations dquot_operations;
135 extern struct quotactl_ops vfs_quotactl_ops;
136 
137 #define sb_dquot_ops (&dquot_operations)
138 #define sb_quotactl_ops (&vfs_quotactl_ops)
139 
140 /* It is better to call this function outside of any transaction as it might
141  * need a lot of space in journal for dquot structure allocation. */
142 static inline void vfs_dq_init(struct inode *inode)
143 {
144 	BUG_ON(!inode->i_sb);
145 	if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode))
146 		inode->i_sb->dq_op->initialize(inode, -1);
147 }
148 
149 /* The following allocation/freeing/transfer functions *must* be called inside
150  * a transaction (deadlocks possible otherwise) */
151 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
152 {
153 	if (sb_any_quota_active(inode->i_sb)) {
154 		/* Used space is updated in alloc_space() */
155 		if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
156 			return 1;
157 	}
158 	else
159 		inode_add_bytes(inode, nr);
160 	return 0;
161 }
162 
163 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
164 {
165 	int ret;
166         if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
167 		mark_inode_dirty(inode);
168 	return ret;
169 }
170 
171 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
172 {
173 	if (sb_any_quota_active(inode->i_sb)) {
174 		/* Used space is updated in alloc_space() */
175 		if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
176 			return 1;
177 	}
178 	else
179 		inode_add_bytes(inode, nr);
180 	return 0;
181 }
182 
183 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
184 {
185 	int ret;
186 	if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
187 		mark_inode_dirty(inode);
188 	return ret;
189 }
190 
191 static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
192 {
193 	if (sb_any_quota_active(inode->i_sb)) {
194 		/* Used space is updated in alloc_space() */
195 		if (inode->i_sb->dq_op->reserve_space(inode, nr, 0) == NO_QUOTA)
196 			return 1;
197 	}
198 	return 0;
199 }
200 
201 static inline int vfs_dq_alloc_inode(struct inode *inode)
202 {
203 	if (sb_any_quota_active(inode->i_sb)) {
204 		vfs_dq_init(inode);
205 		if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
206 			return 1;
207 	}
208 	return 0;
209 }
210 
211 /*
212  * Convert in-memory reserved quotas to real consumed quotas
213  */
214 static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
215 {
216 	if (sb_any_quota_active(inode->i_sb)) {
217 		if (inode->i_sb->dq_op->claim_space(inode, nr) == NO_QUOTA)
218 			return 1;
219 	} else
220 		inode_add_bytes(inode, nr);
221 
222 	mark_inode_dirty(inode);
223 	return 0;
224 }
225 
226 /*
227  * Release reserved (in-memory) quotas
228  */
229 static inline
230 void vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
231 {
232 	if (sb_any_quota_active(inode->i_sb))
233 		inode->i_sb->dq_op->release_rsv(inode, nr);
234 }
235 
236 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
237 {
238 	if (sb_any_quota_active(inode->i_sb))
239 		inode->i_sb->dq_op->free_space(inode, nr);
240 	else
241 		inode_sub_bytes(inode, nr);
242 }
243 
244 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
245 {
246 	vfs_dq_free_space_nodirty(inode, nr);
247 	mark_inode_dirty(inode);
248 }
249 
250 static inline void vfs_dq_free_inode(struct inode *inode)
251 {
252 	if (sb_any_quota_active(inode->i_sb))
253 		inode->i_sb->dq_op->free_inode(inode, 1);
254 }
255 
256 /* The following two functions cannot be called inside a transaction */
257 static inline void vfs_dq_sync(struct super_block *sb)
258 {
259 	sync_dquots(sb, -1);
260 }
261 
262 static inline int vfs_dq_off(struct super_block *sb, int remount)
263 {
264 	int ret = -ENOSYS;
265 
266 	if (sb->s_qcop && sb->s_qcop->quota_off)
267 		ret = sb->s_qcop->quota_off(sb, -1, remount);
268 	return ret;
269 }
270 
271 #else
272 
273 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
274 {
275 	return 0;
276 }
277 
278 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
279 {
280 	return 0;
281 }
282 
283 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
284 {
285 	return 0;
286 }
287 
288 static inline int sb_any_quota_suspended(struct super_block *sb)
289 {
290 	return 0;
291 }
292 
293 /* Does kernel know about any quota information for given sb + type? */
294 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
295 {
296 	return 0;
297 }
298 
299 static inline int sb_any_quota_loaded(struct super_block *sb)
300 {
301 	return 0;
302 }
303 
304 static inline int sb_has_quota_active(struct super_block *sb, int type)
305 {
306 	return 0;
307 }
308 
309 static inline int sb_any_quota_active(struct super_block *sb)
310 {
311 	return 0;
312 }
313 
314 /*
315  * NO-OP when quota not configured.
316  */
317 #define sb_dquot_ops				(NULL)
318 #define sb_quotactl_ops				(NULL)
319 
320 static inline void vfs_dq_init(struct inode *inode)
321 {
322 }
323 
324 static inline void vfs_dq_drop(struct inode *inode)
325 {
326 }
327 
328 static inline int vfs_dq_alloc_inode(struct inode *inode)
329 {
330 	return 0;
331 }
332 
333 static inline void vfs_dq_free_inode(struct inode *inode)
334 {
335 }
336 
337 static inline void vfs_dq_sync(struct super_block *sb)
338 {
339 }
340 
341 static inline int vfs_dq_off(struct super_block *sb, int remount)
342 {
343 	return 0;
344 }
345 
346 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
347 {
348 	return 0;
349 }
350 
351 static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
352 {
353 	return 0;
354 }
355 
356 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
357 {
358 	inode_add_bytes(inode, nr);
359 	return 0;
360 }
361 
362 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
363 {
364 	vfs_dq_prealloc_space_nodirty(inode, nr);
365 	mark_inode_dirty(inode);
366 	return 0;
367 }
368 
369 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
370 {
371 	inode_add_bytes(inode, nr);
372 	return 0;
373 }
374 
375 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
376 {
377 	vfs_dq_alloc_space_nodirty(inode, nr);
378 	mark_inode_dirty(inode);
379 	return 0;
380 }
381 
382 static inline int vfs_dq_reserve_space(struct inode *inode, qsize_t nr)
383 {
384 	return 0;
385 }
386 
387 static inline int vfs_dq_claim_space(struct inode *inode, qsize_t nr)
388 {
389 	return vfs_dq_alloc_space(inode, nr);
390 }
391 
392 static inline
393 int vfs_dq_release_reservation_space(struct inode *inode, qsize_t nr)
394 {
395 	return 0;
396 }
397 
398 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
399 {
400 	inode_sub_bytes(inode, nr);
401 }
402 
403 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
404 {
405 	vfs_dq_free_space_nodirty(inode, nr);
406 	mark_inode_dirty(inode);
407 }
408 
409 #endif /* CONFIG_QUOTA */
410 
411 static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
412 {
413 	return vfs_dq_prealloc_space_nodirty(inode, nr << inode->i_blkbits);
414 }
415 
416 static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
417 {
418 	return vfs_dq_prealloc_space(inode, nr << inode->i_blkbits);
419 }
420 
421 static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
422 {
423 	return vfs_dq_alloc_space_nodirty(inode, nr << inode->i_blkbits);
424 }
425 
426 static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
427 {
428 	return vfs_dq_alloc_space(inode, nr << inode->i_blkbits);
429 }
430 
431 static inline int vfs_dq_reserve_block(struct inode *inode, qsize_t nr)
432 {
433 	return vfs_dq_reserve_space(inode, nr << inode->i_blkbits);
434 }
435 
436 static inline int vfs_dq_claim_block(struct inode *inode, qsize_t nr)
437 {
438 	return vfs_dq_claim_space(inode, nr << inode->i_blkbits);
439 }
440 
441 static inline
442 void vfs_dq_release_reservation_block(struct inode *inode, qsize_t nr)
443 {
444 	vfs_dq_release_reservation_space(inode, nr << inode->i_blkbits);
445 }
446 
447 static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
448 {
449 	vfs_dq_free_space_nodirty(inode, nr << inode->i_blkbits);
450 }
451 
452 static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
453 {
454 	vfs_dq_free_space(inode, nr << inode->i_blkbits);
455 }
456 
457 #endif /* _LINUX_QUOTAOPS_ */
458