xref: /linux-6.15/include/linux/quotaops.h (revision 3eeebf17) 
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 
28 int dquot_alloc_space(struct inode *inode, qsize_t number, int prealloc);
29 int dquot_alloc_inode(const struct inode *inode, unsigned long number);
30 
31 int dquot_free_space(struct inode *inode, qsize_t number);
32 int dquot_free_inode(const struct inode *inode, unsigned long number);
33 
34 int dquot_transfer(struct inode *inode, struct iattr *iattr);
35 int dquot_commit(struct dquot *dquot);
36 int dquot_acquire(struct dquot *dquot);
37 int dquot_release(struct dquot *dquot);
38 int dquot_commit_info(struct super_block *sb, int type);
39 int dquot_mark_dquot_dirty(struct dquot *dquot);
40 
41 int vfs_quota_on(struct super_block *sb, int type, int format_id,
42  	char *path, int remount);
43 int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
44  	struct path *path);
45 int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
46  	int format_id, int type);
47 int vfs_quota_off(struct super_block *sb, int type, int remount);
48 int vfs_quota_sync(struct super_block *sb, int type);
49 int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
50 int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii);
51 int vfs_get_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
52 int vfs_set_dqblk(struct super_block *sb, int type, qid_t id, struct if_dqblk *di);
53 
54 void vfs_dq_drop(struct inode *inode);
55 int vfs_dq_transfer(struct inode *inode, struct iattr *iattr);
56 int vfs_dq_quota_on_remount(struct super_block *sb);
57 
58 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
59 {
60 	return sb_dqopt(sb)->info + type;
61 }
62 
63 /*
64  * Functions for checking status of quota
65  */
66 
67 static inline int sb_has_quota_enabled(struct super_block *sb, int type)
68 {
69 	if (type == USRQUOTA)
70 		return sb_dqopt(sb)->flags & DQUOT_USR_ENABLED;
71 	return sb_dqopt(sb)->flags & DQUOT_GRP_ENABLED;
72 }
73 
74 static inline int sb_any_quota_enabled(struct super_block *sb)
75 {
76 	return sb_has_quota_enabled(sb, USRQUOTA) ||
77 		sb_has_quota_enabled(sb, GRPQUOTA);
78 }
79 
80 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
81 {
82 	if (type == USRQUOTA)
83 		return sb_dqopt(sb)->flags & DQUOT_USR_SUSPENDED;
84 	return sb_dqopt(sb)->flags & DQUOT_GRP_SUSPENDED;
85 }
86 
87 static inline int sb_any_quota_suspended(struct super_block *sb)
88 {
89 	return sb_has_quota_suspended(sb, USRQUOTA) ||
90 		sb_has_quota_suspended(sb, GRPQUOTA);
91 }
92 
93 /*
94  * Operations supported for diskquotas.
95  */
96 extern struct dquot_operations dquot_operations;
97 extern struct quotactl_ops vfs_quotactl_ops;
98 
99 #define sb_dquot_ops (&dquot_operations)
100 #define sb_quotactl_ops (&vfs_quotactl_ops)
101 
102 /* It is better to call this function outside of any transaction as it might
103  * need a lot of space in journal for dquot structure allocation. */
104 static inline void vfs_dq_init(struct inode *inode)
105 {
106 	BUG_ON(!inode->i_sb);
107 	if (sb_any_quota_enabled(inode->i_sb) && !IS_NOQUOTA(inode))
108 		inode->i_sb->dq_op->initialize(inode, -1);
109 }
110 
111 /* The following allocation/freeing/transfer functions *must* be called inside
112  * a transaction (deadlocks possible otherwise) */
113 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
114 {
115 	if (sb_any_quota_enabled(inode->i_sb)) {
116 		/* Used space is updated in alloc_space() */
117 		if (inode->i_sb->dq_op->alloc_space(inode, nr, 1) == NO_QUOTA)
118 			return 1;
119 	}
120 	else
121 		inode_add_bytes(inode, nr);
122 	return 0;
123 }
124 
125 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
126 {
127 	int ret;
128         if (!(ret =  vfs_dq_prealloc_space_nodirty(inode, nr)))
129 		mark_inode_dirty(inode);
130 	return ret;
131 }
132 
133 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
134 {
135 	if (sb_any_quota_enabled(inode->i_sb)) {
136 		/* Used space is updated in alloc_space() */
137 		if (inode->i_sb->dq_op->alloc_space(inode, nr, 0) == NO_QUOTA)
138 			return 1;
139 	}
140 	else
141 		inode_add_bytes(inode, nr);
142 	return 0;
143 }
144 
145 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
146 {
147 	int ret;
148 	if (!(ret = vfs_dq_alloc_space_nodirty(inode, nr)))
149 		mark_inode_dirty(inode);
150 	return ret;
151 }
152 
153 static inline int vfs_dq_alloc_inode(struct inode *inode)
154 {
155 	if (sb_any_quota_enabled(inode->i_sb)) {
156 		vfs_dq_init(inode);
157 		if (inode->i_sb->dq_op->alloc_inode(inode, 1) == NO_QUOTA)
158 			return 1;
159 	}
160 	return 0;
161 }
162 
163 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
164 {
165 	if (sb_any_quota_enabled(inode->i_sb))
166 		inode->i_sb->dq_op->free_space(inode, nr);
167 	else
168 		inode_sub_bytes(inode, nr);
169 }
170 
171 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
172 {
173 	vfs_dq_free_space_nodirty(inode, nr);
174 	mark_inode_dirty(inode);
175 }
176 
177 static inline void vfs_dq_free_inode(struct inode *inode)
178 {
179 	if (sb_any_quota_enabled(inode->i_sb))
180 		inode->i_sb->dq_op->free_inode(inode, 1);
181 }
182 
183 /* The following two functions cannot be called inside a transaction */
184 static inline void vfs_dq_sync(struct super_block *sb)
185 {
186 	sync_dquots(sb, -1);
187 }
188 
189 static inline int vfs_dq_off(struct super_block *sb, int remount)
190 {
191 	int ret = -ENOSYS;
192 
193 	if (sb->s_qcop && sb->s_qcop->quota_off)
194 		ret = sb->s_qcop->quota_off(sb, -1, remount);
195 	return ret;
196 }
197 
198 #else
199 
200 static inline int sb_has_quota_enabled(struct super_block *sb, int type)
201 {
202 	return 0;
203 }
204 
205 static inline int sb_any_quota_enabled(struct super_block *sb)
206 {
207 	return 0;
208 }
209 
210 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
211 {
212 	return 0;
213 }
214 
215 static inline int sb_any_quota_suspended(struct super_block *sb)
216 {
217 	return 0;
218 }
219 
220 /*
221  * NO-OP when quota not configured.
222  */
223 #define sb_dquot_ops				(NULL)
224 #define sb_quotactl_ops				(NULL)
225 
226 static inline void vfs_dq_init(struct inode *inode)
227 {
228 }
229 
230 static inline void vfs_dq_drop(struct inode *inode)
231 {
232 }
233 
234 static inline int vfs_dq_alloc_inode(struct inode *inode)
235 {
236 	return 0;
237 }
238 
239 static inline void vfs_dq_free_inode(struct inode *inode)
240 {
241 }
242 
243 static inline void vfs_dq_sync(struct super_block *sb)
244 {
245 }
246 
247 static inline int vfs_dq_off(struct super_block *sb, int remount)
248 {
249 	return 0;
250 }
251 
252 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
253 {
254 	return 0;
255 }
256 
257 static inline int vfs_dq_transfer(struct inode *inode, struct iattr *iattr)
258 {
259 	return 0;
260 }
261 
262 static inline int vfs_dq_prealloc_space_nodirty(struct inode *inode, qsize_t nr)
263 {
264 	inode_add_bytes(inode, nr);
265 	return 0;
266 }
267 
268 static inline int vfs_dq_prealloc_space(struct inode *inode, qsize_t nr)
269 {
270 	vfs_dq_prealloc_space_nodirty(inode, nr);
271 	mark_inode_dirty(inode);
272 	return 0;
273 }
274 
275 static inline int vfs_dq_alloc_space_nodirty(struct inode *inode, qsize_t nr)
276 {
277 	inode_add_bytes(inode, nr);
278 	return 0;
279 }
280 
281 static inline int vfs_dq_alloc_space(struct inode *inode, qsize_t nr)
282 {
283 	vfs_dq_alloc_space_nodirty(inode, nr);
284 	mark_inode_dirty(inode);
285 	return 0;
286 }
287 
288 static inline void vfs_dq_free_space_nodirty(struct inode *inode, qsize_t nr)
289 {
290 	inode_sub_bytes(inode, nr);
291 }
292 
293 static inline void vfs_dq_free_space(struct inode *inode, qsize_t nr)
294 {
295 	vfs_dq_free_space_nodirty(inode, nr);
296 	mark_inode_dirty(inode);
297 }
298 
299 #endif /* CONFIG_QUOTA */
300 
301 static inline int vfs_dq_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
302 {
303 	return vfs_dq_prealloc_space_nodirty(inode,
304 			nr << inode->i_sb->s_blocksize_bits);
305 }
306 
307 static inline int vfs_dq_prealloc_block(struct inode *inode, qsize_t nr)
308 {
309 	return vfs_dq_prealloc_space(inode,
310 			nr << inode->i_sb->s_blocksize_bits);
311 }
312 
313 static inline int vfs_dq_alloc_block_nodirty(struct inode *inode, qsize_t nr)
314 {
315  	return vfs_dq_alloc_space_nodirty(inode,
316 			nr << inode->i_sb->s_blocksize_bits);
317 }
318 
319 static inline int vfs_dq_alloc_block(struct inode *inode, qsize_t nr)
320 {
321 	return vfs_dq_alloc_space(inode,
322 			nr << inode->i_sb->s_blocksize_bits);
323 }
324 
325 static inline void vfs_dq_free_block_nodirty(struct inode *inode, qsize_t nr)
326 {
327 	vfs_dq_free_space_nodirty(inode, nr << inode->i_sb->s_blocksize_bits);
328 }
329 
330 static inline void vfs_dq_free_block(struct inode *inode, qsize_t nr)
331 {
332 	vfs_dq_free_space(inode, nr << inode->i_sb->s_blocksize_bits);
333 }
334 
335 /*
336  * Define uppercase equivalents for compatibility with old function names
337  * Can go away when we think all users have been converted (15/04/2008)
338  */
339 #define DQUOT_INIT(inode) vfs_dq_init(inode)
340 #define DQUOT_DROP(inode) vfs_dq_drop(inode)
341 #define DQUOT_PREALLOC_SPACE_NODIRTY(inode, nr) \
342 				vfs_dq_prealloc_space_nodirty(inode, nr)
343 #define DQUOT_PREALLOC_SPACE(inode, nr) vfs_dq_prealloc_space(inode, nr)
344 #define DQUOT_ALLOC_SPACE_NODIRTY(inode, nr) \
345 				vfs_dq_alloc_space_nodirty(inode, nr)
346 #define DQUOT_ALLOC_SPACE(inode, nr) vfs_dq_alloc_space(inode, nr)
347 #define DQUOT_PREALLOC_BLOCK_NODIRTY(inode, nr) \
348 				vfs_dq_prealloc_block_nodirty(inode, nr)
349 #define DQUOT_PREALLOC_BLOCK(inode, nr) vfs_dq_prealloc_block(inode, nr)
350 #define DQUOT_ALLOC_BLOCK_NODIRTY(inode, nr) \
351 				vfs_dq_alloc_block_nodirty(inode, nr)
352 #define DQUOT_ALLOC_BLOCK(inode, nr) vfs_dq_alloc_block(inode, nr)
353 #define DQUOT_ALLOC_INODE(inode) vfs_dq_alloc_inode(inode)
354 #define DQUOT_FREE_SPACE_NODIRTY(inode, nr) \
355 				vfs_dq_free_space_nodirty(inode, nr)
356 #define DQUOT_FREE_SPACE(inode, nr) vfs_dq_free_space(inode, nr)
357 #define DQUOT_FREE_BLOCK_NODIRTY(inode, nr) \
358 				vfs_dq_free_block_nodirty(inode, nr)
359 #define DQUOT_FREE_BLOCK(inode, nr) vfs_dq_free_block(inode, nr)
360 #define DQUOT_FREE_INODE(inode) vfs_dq_free_inode(inode)
361 #define DQUOT_TRANSFER(inode, iattr) vfs_dq_transfer(inode, iattr)
362 #define DQUOT_SYNC(sb) vfs_dq_sync(sb)
363 #define DQUOT_OFF(sb, remount) vfs_dq_off(sb, remount)
364 #define DQUOT_ON_REMOUNT(sb) vfs_dq_quota_on_remount(sb)
365 
366 #endif /* _LINUX_QUOTAOPS_ */
367