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 mnt_idmap *idmap,
24 struct inode *inode, struct iattr *ia)
25 {
26 return ((ia->ia_valid & ATTR_SIZE) ||
27 i_uid_needs_update(idmap, ia, inode) ||
28 i_gid_needs_update(idmap, 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) > 0)
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 void 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 mnt_idmap *idmap, 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 mnt_idmap *idmap,
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 void dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
261 {
262 inode_add_bytes(inode, number);
263 }
264
265 static inline int dquot_reclaim_space_nodirty(struct inode *inode,
266 qsize_t number)
267 {
268 inode_sub_bytes(inode, number);
269 return 0;
270 }
271
272 static inline int dquot_disable(struct super_block *sb, int type,
273 unsigned int flags)
274 {
275 return 0;
276 }
277
278 static inline int dquot_suspend(struct super_block *sb, int type)
279 {
280 return 0;
281 }
282
283 static inline int dquot_resume(struct super_block *sb, int type)
284 {
285 return 0;
286 }
287
288 #define dquot_file_open generic_file_open
289
290 static inline int dquot_writeback_dquots(struct super_block *sb, int type)
291 {
292 return 0;
293 }
294
295 #endif /* CONFIG_QUOTA */
296
297 static inline int dquot_alloc_space_nodirty(struct inode *inode, qsize_t nr)
298 {
299 return __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN);
300 }
301
302 static inline void dquot_alloc_space_nofail(struct inode *inode, qsize_t nr)
303 {
304 __dquot_alloc_space(inode, nr, DQUOT_SPACE_WARN|DQUOT_SPACE_NOFAIL);
305 mark_inode_dirty_sync(inode);
306 }
307
308 static inline int dquot_alloc_space(struct inode *inode, qsize_t nr)
309 {
310 int ret;
311
312 ret = dquot_alloc_space_nodirty(inode, nr);
313 if (!ret) {
314 /*
315 * Mark inode fully dirty. Since we are allocating blocks, inode
316 * would become fully dirty soon anyway and it reportedly
317 * reduces lock contention.
318 */
319 mark_inode_dirty(inode);
320 }
321 return ret;
322 }
323
324 static inline int dquot_alloc_block_nodirty(struct inode *inode, qsize_t nr)
325 {
326 return dquot_alloc_space_nodirty(inode, nr << inode->i_blkbits);
327 }
328
329 static inline void dquot_alloc_block_nofail(struct inode *inode, qsize_t nr)
330 {
331 dquot_alloc_space_nofail(inode, nr << inode->i_blkbits);
332 }
333
334 static inline int dquot_alloc_block(struct inode *inode, qsize_t nr)
335 {
336 return dquot_alloc_space(inode, nr << inode->i_blkbits);
337 }
338
339 static inline int dquot_prealloc_block_nodirty(struct inode *inode, qsize_t nr)
340 {
341 return __dquot_alloc_space(inode, nr << inode->i_blkbits, 0);
342 }
343
344 static inline int dquot_prealloc_block(struct inode *inode, qsize_t nr)
345 {
346 int ret;
347
348 ret = dquot_prealloc_block_nodirty(inode, nr);
349 if (!ret)
350 mark_inode_dirty_sync(inode);
351 return ret;
352 }
353
354 static inline int dquot_reserve_block(struct inode *inode, qsize_t nr)
355 {
356 return __dquot_alloc_space(inode, nr << inode->i_blkbits,
357 DQUOT_SPACE_WARN|DQUOT_SPACE_RESERVE);
358 }
359
360 static inline void dquot_claim_block(struct inode *inode, qsize_t nr)
361 {
362 dquot_claim_space_nodirty(inode, nr << inode->i_blkbits);
363 mark_inode_dirty_sync(inode);
364 }
365
366 static inline void dquot_reclaim_block(struct inode *inode, qsize_t nr)
367 {
368 dquot_reclaim_space_nodirty(inode, nr << inode->i_blkbits);
369 mark_inode_dirty_sync(inode);
370 }
371
372 static inline void dquot_free_space_nodirty(struct inode *inode, qsize_t nr)
373 {
374 __dquot_free_space(inode, nr, 0);
375 }
376
377 static inline void dquot_free_space(struct inode *inode, qsize_t nr)
378 {
379 dquot_free_space_nodirty(inode, nr);
380 mark_inode_dirty_sync(inode);
381 }
382
383 static inline void dquot_free_block_nodirty(struct inode *inode, qsize_t nr)
384 {
385 dquot_free_space_nodirty(inode, nr << inode->i_blkbits);
386 }
387
388 static inline void dquot_free_block(struct inode *inode, qsize_t nr)
389 {
390 dquot_free_space(inode, nr << inode->i_blkbits);
391 }
392
393 static inline void dquot_release_reservation_block(struct inode *inode,
394 qsize_t nr)
395 {
396 __dquot_free_space(inode, nr << inode->i_blkbits, DQUOT_SPACE_RESERVE);
397 }
398
399 unsigned int qtype_enforce_flag(int type);
400
401 #endif /* _LINUX_QUOTAOPS_ */
402
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.