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