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