xref: /linux/include/linux/quotaops.h (revision c6fbb759) 
1 /* SPDX-License-Identifier: GPL-2.0 */
2 /*
3  * Definitions for diskquota-operations. When diskquota is configured these
4  * macros expand to the right source-code.
5  *
6  * Author:  Marco van Wieringen <mvw@planets.elm.net>
7  */
8 #ifndef _LINUX_QUOTAOPS_
9 #define _LINUX_QUOTAOPS_
10 
11 #include <linux/fs.h>
12 
13 #define DQUOT_SPACE_WARN	0x1
14 #define DQUOT_SPACE_RESERVE	0x2
15 #define DQUOT_SPACE_NOFAIL	0x4
16 
17 static inline struct quota_info *sb_dqopt(struct super_block *sb)
18 {
19 	return &sb->s_dquot;
20 }
21 
22 /* i_mutex must being held */
23 static inline bool is_quota_modification(struct user_namespace *mnt_userns,
24 					 struct inode *inode, struct iattr *ia)
25 {
26 	return ((ia->ia_valid & ATTR_SIZE) ||
27 		i_uid_needs_update(mnt_userns, ia, inode) ||
28 		i_gid_needs_update(mnt_userns, ia, inode));
29 }
30 
31 #if defined(CONFIG_QUOTA)
32 
33 #define quota_error(sb, fmt, args...) \
34 	__quota_error((sb), __func__, fmt , ## args)
35 
36 extern __printf(3, 4)
37 void __quota_error(struct super_block *sb, const char *func,
38 		   const char *fmt, ...);
39 
40 /*
41  * declaration of quota_function calls in kernel.
42  */
43 int dquot_initialize(struct inode *inode);
44 bool dquot_initialize_needed(struct inode *inode);
45 void dquot_drop(struct inode *inode);
46 struct dquot *dqget(struct super_block *sb, struct kqid qid);
47 static inline struct dquot *dqgrab(struct dquot *dquot)
48 {
49 	/* Make sure someone else has active reference to dquot */
50 	WARN_ON_ONCE(!atomic_read(&dquot->dq_count));
51 	WARN_ON_ONCE(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
52 	atomic_inc(&dquot->dq_count);
53 	return dquot;
54 }
55 
56 static inline bool dquot_is_busy(struct dquot *dquot)
57 {
58 	if (test_bit(DQ_MOD_B, &dquot->dq_flags))
59 		return true;
60 	if (atomic_read(&dquot->dq_count) > 1)
61 		return true;
62 	return false;
63 }
64 
65 void dqput(struct dquot *dquot);
66 int dquot_scan_active(struct super_block *sb,
67 		      int (*fn)(struct dquot *dquot, unsigned long priv),
68 		      unsigned long priv);
69 struct dquot *dquot_alloc(struct super_block *sb, int type);
70 void dquot_destroy(struct dquot *dquot);
71 
72 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags);
73 void __dquot_free_space(struct inode *inode, qsize_t number, int flags);
74 
75 int dquot_alloc_inode(struct inode *inode);
76 
77 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number);
78 void dquot_free_inode(struct inode *inode);
79 void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number);
80 
81 int dquot_disable(struct super_block *sb, int type, unsigned int flags);
82 /* Suspend quotas on remount RO */
83 static inline int dquot_suspend(struct super_block *sb, int type)
84 {
85 	return dquot_disable(sb, type, DQUOT_SUSPENDED);
86 }
87 int dquot_resume(struct super_block *sb, int type);
88 
89 int dquot_commit(struct dquot *dquot);
90 int dquot_acquire(struct dquot *dquot);
91 int dquot_release(struct dquot *dquot);
92 int dquot_commit_info(struct super_block *sb, int type);
93 int dquot_get_next_id(struct super_block *sb, struct kqid *qid);
94 int dquot_mark_dquot_dirty(struct dquot *dquot);
95 
96 int dquot_file_open(struct inode *inode, struct file *file);
97 
98 int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
99 	unsigned int flags);
100 int dquot_load_quota_inode(struct inode *inode, int type, int format_id,
101 	unsigned int flags);
102 int dquot_quota_on(struct super_block *sb, int type, int format_id,
103 	const struct path *path);
104 int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
105  	int format_id, int type);
106 int dquot_quota_off(struct super_block *sb, int type);
107 int dquot_writeback_dquots(struct super_block *sb, int type);
108 int dquot_quota_sync(struct super_block *sb, int type);
109 int dquot_get_state(struct super_block *sb, struct qc_state *state);
110 int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii);
111 int dquot_get_dqblk(struct super_block *sb, struct kqid id,
112 		struct qc_dqblk *di);
113 int dquot_get_next_dqblk(struct super_block *sb, struct kqid *id,
114 		struct qc_dqblk *di);
115 int dquot_set_dqblk(struct super_block *sb, struct kqid id,
116 		struct qc_dqblk *di);
117 
118 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to);
119 int dquot_transfer(struct user_namespace *mnt_userns, struct inode *inode,
120 		   struct iattr *iattr);
121 
122 static inline struct mem_dqinfo *sb_dqinfo(struct super_block *sb, int type)
123 {
124 	return sb_dqopt(sb)->info + type;
125 }
126 
127 /*
128  * Functions for checking status of quota
129  */
130 
131 static inline bool sb_has_quota_usage_enabled(struct super_block *sb, int type)
132 {
133 	return sb_dqopt(sb)->flags &
134 				dquot_state_flag(DQUOT_USAGE_ENABLED, type);
135 }
136 
137 static inline bool sb_has_quota_limits_enabled(struct super_block *sb, int type)
138 {
139 	return sb_dqopt(sb)->flags &
140 				dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
141 }
142 
143 static inline bool sb_has_quota_suspended(struct super_block *sb, int type)
144 {
145 	return sb_dqopt(sb)->flags &
146 				dquot_state_flag(DQUOT_SUSPENDED, type);
147 }
148 
149 static inline unsigned sb_any_quota_suspended(struct super_block *sb)
150 {
151 	return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_SUSPENDED);
152 }
153 
154 /* Does kernel know about any quota information for given sb + type? */
155 static inline bool sb_has_quota_loaded(struct super_block *sb, int type)
156 {
157 	/* Currently if anything is on, then quota usage is on as well */
158 	return sb_has_quota_usage_enabled(sb, type);
159 }
160 
161 static inline unsigned sb_any_quota_loaded(struct super_block *sb)
162 {
163 	return dquot_state_types(sb_dqopt(sb)->flags, DQUOT_USAGE_ENABLED);
164 }
165 
166 static inline bool sb_has_quota_active(struct super_block *sb, int type)
167 {
168 	return sb_has_quota_loaded(sb, type) &&
169 	       !sb_has_quota_suspended(sb, type);
170 }
171 
172 /*
173  * Operations supported for diskquotas.
174  */
175 extern const struct dquot_operations dquot_operations;
176 extern const struct quotactl_ops dquot_quotactl_sysfile_ops;
177 
178 #else
179 
180 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
181 {
182 	return 0;
183 }
184 
185 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
186 {
187 	return 0;
188 }
189 
190 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
191 {
192 	return 0;
193 }
194 
195 static inline int sb_any_quota_suspended(struct super_block *sb)
196 {
197 	return 0;
198 }
199 
200 /* Does kernel know about any quota information for given sb + type? */
201 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
202 {
203 	return 0;
204 }
205 
206 static inline int sb_any_quota_loaded(struct super_block *sb)
207 {
208 	return 0;
209 }
210 
211 static inline int sb_has_quota_active(struct super_block *sb, int type)
212 {
213 	return 0;
214 }
215 
216 static inline int dquot_initialize(struct inode *inode)
217 {
218 	return 0;
219 }
220 
221 static inline bool dquot_initialize_needed(struct inode *inode)
222 {
223 	return false;
224 }
225 
226 static inline void dquot_drop(struct inode *inode)
227 {
228 }
229 
230 static inline int dquot_alloc_inode(struct inode *inode)
231 {
232 	return 0;
233 }
234 
235 static inline void dquot_free_inode(struct inode *inode)
236 {
237 }
238 
239 static inline int dquot_transfer(struct user_namespace *mnt_userns,
240 				 struct inode *inode, struct iattr *iattr)
241 {
242 	return 0;
243 }
244 
245 static inline int __dquot_alloc_space(struct inode *inode, qsize_t number,
246 		int flags)
247 {
248 	if (!(flags & DQUOT_SPACE_RESERVE))
249 		inode_add_bytes(inode, number);
250 	return 0;
251 }
252 
253 static inline void __dquot_free_space(struct inode *inode, qsize_t number,
254 		int flags)
255 {
256 	if (!(flags & DQUOT_SPACE_RESERVE))
257 		inode_sub_bytes(inode, number);
258 }
259 
260 static inline int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
261 {
262 	inode_add_bytes(inode, number);
263 	return 0;
264 }
265 
266 static inline int dquot_reclaim_space_nodirty(struct inode *inode,
267 					      qsize_t number)
268 {
269 	inode_sub_bytes(inode, number);
270 	return 0;
271 }
272 
273 static inline int dquot_disable(struct super_block *sb, int type,
274 		unsigned int flags)
275 {
276 	return 0;
277 }
278 
279 static inline int dquot_suspend(struct super_block *sb, int type)
280 {
281 	return 0;
282 }
283 
284 static inline int dquot_resume(struct super_block *sb, int type)
285 {
286 	return 0;
287 }
288 
289 #define dquot_file_open		generic_file_open
290 
291 static inline int dquot_writeback_dquots(struct super_block *sb, int type)
292 {
293 	return 0;
294 }
295 
296 #endif /* CONFIG_QUOTA */
297 
298 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
299 {
300 	return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
301 }
302 
303 static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
304 {
305 	__dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
306 	mark_inode_dirty_sync(inode);
307 }
308 
309 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
310 {
311 	int ret;
312 
313 	ret = dquot_alloc_space_nodirty(inode, nr);
314 	if (!ret) {
315 		/*
316 		 * Mark inode fully dirty. Since we are allocating blocks, inode
317 		 * would become fully dirty soon anyway and it reportedly
318 		 * reduces lock contention.
319 		 */
320 		mark_inode_dirty(inode);
321 	}
322 	return ret;
323 }
324 
325 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
326 {
327 	return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
328 }
329 
330 static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
331 {
332 	dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
333 }
334 
335 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
336 {
337 	return dquot_alloc_space(inode, nr << inode->i_blkbits);
338 }
339 
340 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
341 {
342 	return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
343 }
344 
345 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
346 {
347 	int ret;
348 
349 	ret = dquot_prealloc_block_nodirty(inode, nr);
350 	if (!ret)
351 		mark_inode_dirty_sync(inode);
352 	return ret;
353 }
354 
355 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
356 {
357 	return __dquot_alloc_space(inode, nr << inode->i_blkbits,
358 				DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
359 }
360 
361 static inline int dquot_claim_block(struct inode *inode, qsize_t nr)
362 {
363 	int ret;
364 
365 	ret = dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
366 	if (!ret)
367 		mark_inode_dirty_sync(inode);
368 	return ret;
369 }
370 
371 static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
372 {
373 	dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
374 	mark_inode_dirty_sync(inode);
375 }
376 
377 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
378 {
379 	__dquot_free_space(inode, nr, 0);
380 }
381 
382 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
383 {
384 	dquot_free_space_nodirty(inode, nr);
385 	mark_inode_dirty_sync(inode);
386 }
387 
388 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
389 {
390 	dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
391 }
392 
393 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
394 {
395 	dquot_free_space(inode, nr << inode->i_blkbits);
396 }
397 
398 static inline void dquot_release_reservation_block(struct inode *inode,
399 		qsize_t nr)
400 {
401 	__dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
402 }
403 
404 unsigned int qtype_enforce_flag(int type);
405 
406 #endif /* _LINUX_QUOTAOPS_ */
407