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 
sb_dqopt(struct super_block * sb)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 */
is_quota_modification(struct user_namespace * mnt_userns,struct inode * inode,struct iattr * ia)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);
dqgrab(struct dquot * dquot)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 
dquot_is_busy(struct dquot * dquot)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 */
dquot_suspend(struct super_block * sb,int type)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 
sb_dqinfo(struct super_block * sb,int type)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 
sb_has_quota_usage_enabled(struct super_block * sb,int type)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 
sb_has_quota_limits_enabled(struct super_block * sb,int type)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 
sb_has_quota_suspended(struct super_block * sb,int type)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 
sb_any_quota_suspended(struct super_block * sb)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? */
sb_has_quota_loaded(struct super_block * sb,int 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 
sb_any_quota_loaded(struct super_block * sb)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 
sb_has_quota_active(struct super_block * sb,int type)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 
sb_has_quota_usage_enabled(struct super_block * sb,int type)180 static inline int sb_has_quota_usage_enabled(struct super_block *sb, int type)
181 {
182 	return 0;
183 }
184 
sb_has_quota_limits_enabled(struct super_block * sb,int type)185 static inline int sb_has_quota_limits_enabled(struct super_block *sb, int type)
186 {
187 	return 0;
188 }
189 
sb_has_quota_suspended(struct super_block * sb,int type)190 static inline int sb_has_quota_suspended(struct super_block *sb, int type)
191 {
192 	return 0;
193 }
194 
sb_any_quota_suspended(struct super_block * sb)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? */
sb_has_quota_loaded(struct super_block * sb,int type)201 static inline int sb_has_quota_loaded(struct super_block *sb, int type)
202 {
203 	return 0;
204 }
205 
sb_any_quota_loaded(struct super_block * sb)206 static inline int sb_any_quota_loaded(struct super_block *sb)
207 {
208 	return 0;
209 }
210 
sb_has_quota_active(struct super_block * sb,int type)211 static inline int sb_has_quota_active(struct super_block *sb, int type)
212 {
213 	return 0;
214 }
215 
dquot_initialize(struct inode * inode)216 static inline int dquot_initialize(struct inode *inode)
217 {
218 	return 0;
219 }
220 
dquot_initialize_needed(struct inode * inode)221 static inline bool dquot_initialize_needed(struct inode *inode)
222 {
223 	return false;
224 }
225 
dquot_drop(struct inode * inode)226 static inline void dquot_drop(struct inode *inode)
227 {
228 }
229 
dquot_alloc_inode(struct inode * inode)230 static inline int dquot_alloc_inode(struct inode *inode)
231 {
232 	return 0;
233 }
234 
dquot_free_inode(struct inode * inode)235 static inline void dquot_free_inode(struct inode *inode)
236 {
237 }
238 
dquot_transfer(struct user_namespace * mnt_userns,struct inode * inode,struct iattr * iattr)239 static inline int dquot_transfer(struct user_namespace *mnt_userns,
240 				 struct inode *inode, struct iattr *iattr)
241 {
242 	return 0;
243 }
244 
__dquot_alloc_space(struct inode * inode,qsize_t number,int flags)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 
__dquot_free_space(struct inode * inode,qsize_t number,int flags)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 
dquot_claim_space_nodirty(struct inode * inode,qsize_t number)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 
dquot_reclaim_space_nodirty(struct inode * inode,qsize_t number)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 
dquot_disable(struct super_block * sb,int type,unsigned int flags)273 static inline int dquot_disable(struct super_block *sb, int type,
274 		unsigned int flags)
275 {
276 	return 0;
277 }
278 
dquot_suspend(struct super_block * sb,int type)279 static inline int dquot_suspend(struct super_block *sb, int type)
280 {
281 	return 0;
282 }
283 
dquot_resume(struct super_block * sb,int type)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 
dquot_writeback_dquots(struct super_block * sb,int type)291 static inline int dquot_writeback_dquots(struct super_block *sb, int type)
292 {
293 	return 0;
294 }
295 
296 #endif /* CONFIG_QUOTA */
297 
dquot_alloc_space_nodirty(struct inode * inode,qsize_t nr)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 
dquot_alloc_space_nofail(struct inode * inode,qsize_t nr)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 
dquot_alloc_space(struct inode * inode,qsize_t nr)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 
dquot_alloc_block_nodirty(struct inode * inode,qsize_t nr)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 
dquot_alloc_block_nofail(struct inode * inode,qsize_t nr)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 
dquot_alloc_block(struct inode * inode,qsize_t nr)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 
dquot_prealloc_block_nodirty(struct inode * inode,qsize_t nr)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 
dquot_prealloc_block(struct inode * inode,qsize_t nr)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 
dquot_reserve_block(struct inode * inode,qsize_t nr)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 
dquot_claim_block(struct inode * inode,qsize_t nr)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 
dquot_reclaim_block(struct inode * inode,qsize_t nr)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 
dquot_free_space_nodirty(struct inode * inode,qsize_t nr)377 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
378 {
379 	__dquot_free_space(inode, nr, 0);
380 }
381 
dquot_free_space(struct inode * inode,qsize_t nr)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 
dquot_free_block_nodirty(struct inode * inode,qsize_t nr)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 
dquot_free_block(struct inode * inode,qsize_t nr)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 
dquot_release_reservation_block(struct inode * inode,qsize_t nr)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