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