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