xref: /linux-6.15/include/linux/quotaops.h (revision edc7616c) 
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 static inline struct quota_info *sb_dqopt(struct super_block *sb)
13 {
14 	return &sb->s_dquot;
15 }
16 
17 #if defined(CONFIG_QUOTA)
18 
19 /*
20  * declaration of quota_function calls in kernel.
21  */
22 void inode_add_rsv_space(struct inode *inode, qsize_t number);
23 void inode_claim_rsv_space(struct inode *inode, qsize_t number);
24 void inode_sub_rsv_space(struct inode *inode, qsize_t number);
25 
26 void dquot_initialize(struct inode *inode);
27 void dquot_drop(struct inode *inode);
28 struct dquot *dqget(struct super_block *sb, unsigned int id, int type);
29 void dqput(struct dquot *dquot);
30 int dquot_scan_active(struct super_block *sb,
31 		      int (*fn)(struct dquot *dquot, unsigned long priv),
32 		      unsigned long priv);
33 struct dquot *dquot_alloc(struct super_block *sb, int type);
34 void dquot_destroy(struct dquot *dquot);
35 
36 int __dquot_alloc_space(struct inode *inode, qsize_t number,
37 		int warn, int reserve);
38 void __dquot_free_space(struct inode *inode, qsize_t number, int reserve);
39 
40 int dquot_alloc_inode(const struct inode *inode);
41 
42 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
43 void dquot_free_inode(const struct inode *inode);
44 
45 int dquot_commit(struct dquot *dquot);
46 int dquot_acquire(struct dquot *dquot);
47 int dquot_release(struct dquot *dquot);
48 int dquot_commit_info(struct super_block *sb, int type);
49 int dquot_mark_dquot_dirty(struct dquot *dquot);
50 
51 int dquot_file_open(struct inode *inode, struct file *file);
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, int wait);
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 int dquot_transfer(struct inode *inode, struct iattr *iattr);
70 int vfs_dq_quota_on_remount(struct super_block *sb);
71 
72 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
73 {
74 	return sb_dqopt(sb)->info + type;
75 }
76 
77 /*
78  * Functions for checking status of quota
79  */
80 
81 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
82 {
83 	return sb_dqopt(sb)->flags &
84 				dquot_state_flag(DQUOT_USAGE_ENABLED, type);
85 }
86 
87 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
88 {
89 	return sb_dqopt(sb)->flags &
90 				dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
91 }
92 
93 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
94 {
95 	return sb_dqopt(sb)->flags &
96 				dquot_state_flag(DQUOT_SUSPENDED, type);
97 }
98 
99 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
100 {
101 	unsigned type, tmsk = 0;
102 	for (type = 0; type < MAXQUOTAS; type++)
103 		tmsk |= sb_has_quota_suspended(sb, type) << type;
104 	return tmsk;
105 }
106 
107 /* Does kernel know about any quota information for given sb + type? */
108 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
109 {
110 	/* Currently if anything is on, then quota usage is on as well */
111 	return sb_has_quota_usage_enabled(sb, type);
112 }
113 
114 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
115 {
116 	unsigned type, tmsk = 0;
117 	for (type = 0; type < MAXQUOTAS; type++)
118 		tmsk |= sb_has_quota_loaded(sb, type) << type;
119 	return	tmsk;
120 }
121 
122 static inline bool sb_has_quota_active(struct super_block *sb, int type)
123 {
124 	return sb_has_quota_loaded(sb, type) &&
125 	       !sb_has_quota_suspended(sb, type);
126 }
127 
128 static inline unsigned sb_any_quota_active(struct super_block *sb)
129 {
130 	return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
131 }
132 
133 /*
134  * Operations supported for diskquotas.
135  */
136 extern const struct dquot_operations dquot_operations;
137 extern const struct quotactl_ops vfs_quotactl_ops;
138 
139 #define sb_dquot_ops (&dquot_operations)
140 #define sb_quotactl_ops (&vfs_quotactl_ops)
141 
142 /* Cannot be called inside a transaction */
143 static inline int vfs_dq_off(struct super_block *sb, int remount)
144 {
145 	int ret = -ENOSYS;
146 
147 	if (sb->s_qcop && sb->s_qcop->quota_off)
148 		ret = sb->s_qcop->quota_off(sb, -1, remount);
149 	return ret;
150 }
151 
152 #else
153 
154 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
155 {
156 	return 0;
157 }
158 
159 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
160 {
161 	return 0;
162 }
163 
164 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
165 {
166 	return 0;
167 }
168 
169 static inline int sb_any_quota_suspended(struct super_block *sb)
170 {
171 	return 0;
172 }
173 
174 /* Does kernel know about any quota information for given sb + type? */
175 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
176 {
177 	return 0;
178 }
179 
180 static inline int sb_any_quota_loaded(struct super_block *sb)
181 {
182 	return 0;
183 }
184 
185 static inline int sb_has_quota_active(struct super_block *sb, int type)
186 {
187 	return 0;
188 }
189 
190 static inline int sb_any_quota_active(struct super_block *sb)
191 {
192 	return 0;
193 }
194 
195 /*
196  * NO-OP when quota not configured.
197  */
198 #define sb_dquot_ops				(NULL)
199 #define sb_quotactl_ops				(NULL)
200 
201 static inline void dquot_initialize(struct inode *inode)
202 {
203 }
204 
205 static inline void dquot_drop(struct inode *inode)
206 {
207 }
208 
209 static inline int dquot_alloc_inode(const struct inode *inode)
210 {
211 	return 0;
212 }
213 
214 static inline void dquot_free_inode(const struct inode *inode)
215 {
216 }
217 
218 static inline int vfs_dq_off(struct super_block *sb, int remount)
219 {
220 	return 0;
221 }
222 
223 static inline int vfs_dq_quota_on_remount(struct super_block *sb)
224 {
225 	return 0;
226 }
227 
228 static inline int dquot_transfer(struct inode *inode, struct iattr *iattr)
229 {
230 	return 0;
231 }
232 
233 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
234 		int warn, int reserve)
235 {
236 	if (!reserve)
237 		inode_add_bytes(inode, number);
238 	return 0;
239 }
240 
241 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
242 		int reserve)
243 {
244 	if (!reserve)
245 		inode_sub_bytes(inode, number);
246 }
247 
248 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
249 {
250 	inode_add_bytes(inode, number);
251 	return 0;
252 }
253 
254 #define dquot_file_open		generic_file_open
255 
256 #endif /* CONFIG_QUOTA */
257 
258 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
259 {
260 	return __dquot_alloc_space(inode, nr, 1, 0);
261 }
262 
263 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
264 {
265 	int ret;
266 
267 	ret = dquot_alloc_space_nodirty(inode, nr);
268 	if (!ret)
269 		mark_inode_dirty(inode);
270 	return ret;
271 }
272 
273 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
274 {
275 	return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
276 }
277 
278 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
279 {
280 	return dquot_alloc_space(inode, nr << inode->i_blkbits);
281 }
282 
283 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
284 {
285 	return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0, 0);
286 }
287 
288 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
289 {
290 	int ret;
291 
292 	ret = dquot_prealloc_block_nodirty(inode, nr);
293 	if (!ret)
294 		mark_inode_dirty(inode);
295 	return ret;
296 }
297 
298 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
299 {
300 	return __dquot_alloc_space(inode, nr << inode->i_blkbits, 1, 1);
301 }
302 
303 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
304 {
305 	int ret;
306 
307 	ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
308 	if (!ret)
309 		mark_inode_dirty(inode);
310 	return ret;
311 }
312 
313 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
314 {
315 	__dquot_free_space(inode, nr, 0);
316 }
317 
318 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
319 {
320 	dquot_free_space_nodirty(inode, nr);
321 	mark_inode_dirty(inode);
322 }
323 
324 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
325 {
326 	dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
327 }
328 
329 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
330 {
331 	dquot_free_space(inode, nr << inode->i_blkbits);
332 }
333 
334 static inline void dquot_release_reservation_block(struct inode *inode,
335 		qsize_t nr)
336 {
337 	__dquot_free_space(inode, nr << inode->i_blkbits, 1);
338 }
339 
340 #endif /* _LINUX_QUOTAOPS_ */
341