1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Implementation of the diskquota system for the LINUX operating system. QUOTA
4 * is implemented using the BSD system call interface as the means of
5 * communication with the user level. This file contains the generic routines
6 * called by the different filesystems on allocation of an inode or block.
7 * These routines take care of the administration needed to have a consistent
8 * diskquota tracking system. The ideas of both user and group quotas are based
9 * on the Melbourne quota system as used on BSD derived systems. The internal
10 * implementation is based on one of the several variants of the LINUX
11 * inode-subsystem with added complexity of the diskquota system.
12 *
13 * Author: Marco van Wieringen <mvw@planets.elm.net>
14 *
15 * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
16 *
17 * Revised list management to avoid races
18 * -- Bill Hawes, <whawes@star.net>, 9/98
19 *
20 * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...().
21 * As the consequence the locking was moved from dquot_decr_...(),
22 * dquot_incr_...() to calling functions.
23 * invalidate_dquots() now writes modified dquots.
24 * Serialized quota_off() and quota_on() for mount point.
25 * Fixed a few bugs in grow_dquots().
26 * Fixed deadlock in write_dquot() - we no longer account quotas on
27 * quota files
28 * remove_dquot_ref() moved to inode.c - it now traverses through inodes
29 * add_dquot_ref() restarts after blocking
30 * Added check for bogus uid and fixed check for group in quotactl.
31 * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99
32 *
33 * Used struct list_head instead of own list struct
34 * Invalidation of referenced dquots is no longer possible
35 * Improved free_dquots list management
36 * Quota and i_blocks are now updated in one place to avoid races
37 * Warnings are now delayed so we won't block in critical section
38 * Write updated not to require dquot lock
39 * Jan Kara, <jack@suse.cz>, 9/2000
40 *
41 * Added dynamic quota structure allocation
42 * Jan Kara <jack@suse.cz> 12/2000
43 *
44 * Rewritten quota interface. Implemented new quota format and
45 * formats registering.
46 * Jan Kara, <jack@suse.cz>, 2001,2002
47 *
48 * New SMP locking.
49 * Jan Kara, <jack@suse.cz>, 10/2002
50 *
51 * Added journalled quota support, fix lock inversion problems
52 * Jan Kara, <jack@suse.cz>, 2003,2004
53 *
54 * (C) Copyright 1994 - 1997 Marco van Wieringen
55 */
56
57#include <linux/errno.h>
58#include <linux/kernel.h>
59#include <linux/fs.h>
60#include <linux/mount.h>
61#include <linux/mm.h>
62#include <linux/time.h>
63#include <linux/types.h>
64#include <linux/string.h>
65#include <linux/fcntl.h>
66#include <linux/stat.h>
67#include <linux/tty.h>
68#include <linux/file.h>
69#include <linux/slab.h>
70#include <linux/sysctl.h>
71#include <linux/init.h>
72#include <linux/module.h>
73#include <linux/proc_fs.h>
74#include <linux/security.h>
75#include <linux/sched.h>
76#include <linux/cred.h>
77#include <linux/kmod.h>
78#include <linux/namei.h>
79#include <linux/capability.h>
80#include <linux/quotaops.h>
81#include <linux/blkdev.h>
82#include <linux/sched/mm.h>
83
84#include <linux/uaccess.h>
85
86/*
87 * There are five quota SMP locks:
88 * * dq_list_lock protects all lists with quotas and quota formats.
89 * * dquot->dq_dqb_lock protects data from dq_dqb
90 * * inode->i_lock protects inode->i_blocks, i_bytes and also guards
91 * consistency of dquot->dq_dqb with inode->i_blocks, i_bytes so that
92 * dquot_transfer() can stabilize amount it transfers
93 * * dq_data_lock protects mem_dqinfo structures and modifications of dquot
94 * pointers in the inode
95 * * dq_state_lock protects modifications of quota state (on quotaon and
96 * quotaoff) and readers who care about latest values take it as well.
97 *
98 * The spinlock ordering is hence:
99 * dq_data_lock > dq_list_lock > i_lock > dquot->dq_dqb_lock,
100 * dq_list_lock > dq_state_lock
101 *
102 * Note that some things (eg. sb pointer, type, id) doesn't change during
103 * the life of the dquot structure and so needn't to be protected by a lock
104 *
105 * Operation accessing dquots via inode pointers are protected by dquot_srcu.
106 * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and
107 * synchronize_srcu(&dquot_srcu) is called after clearing pointers from
108 * inode and before dropping dquot references to avoid use of dquots after
109 * they are freed. dq_data_lock is used to serialize the pointer setting and
110 * clearing operations.
111 * Special care needs to be taken about S_NOQUOTA inode flag (marking that
112 * inode is a quota file). Functions adding pointers from inode to dquots have
113 * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they
114 * have to do all pointer modifications before dropping dq_data_lock. This makes
115 * sure they cannot race with quotaon which first sets S_NOQUOTA flag and
116 * then drops all pointers to dquots from an inode.
117 *
118 * Each dquot has its dq_lock mutex. Dquot is locked when it is being read to
119 * memory (or space for it is being allocated) on the first dqget(), when it is
120 * being written out, and when it is being released on the last dqput(). The
121 * allocation and release operations are serialized by the dq_lock and by
122 * checking the use count in dquot_release().
123 *
124 * Lock ordering (including related VFS locks) is the following:
125 * s_umount > i_mutex > journal_lock > dquot->dq_lock > dqio_sem
126 */
127
128static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock);
129static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
130__cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
131EXPORT_SYMBOL(dq_data_lock);
132DEFINE_STATIC_SRCU(dquot_srcu);
133
134static DECLARE_WAIT_QUEUE_HEAD(dquot_ref_wq);
135
136void __quota_error(struct super_block *sb, const char *func,
137 const char *fmt, ...)
138{
139 if (printk_ratelimit()) {
140 va_list args;
141 struct va_format vaf;
142
143 va_start(args, fmt);
144
145 vaf.fmt = fmt;
146 vaf.va = &args;
147
148 printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
149 sb->s_id, func, &vaf);
150
151 va_end(args);
152 }
153}
154EXPORT_SYMBOL(__quota_error);
155
156#if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
157static char *quotatypes[] = INITQFNAMES;
158#endif
159static struct quota_format_type *quota_formats; /* List of registered formats */
160static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
161
162/* SLAB cache for dquot structures */
163static struct kmem_cache *dquot_cachep;
164
165/* workqueue for work quota_release_work*/
166static struct workqueue_struct *quota_unbound_wq;
167
168void register_quota_format(struct quota_format_type *fmt)
169{
170 spin_lock(lock: &dq_list_lock);
171 fmt->qf_next = quota_formats;
172 quota_formats = fmt;
173 spin_unlock(lock: &dq_list_lock);
174}
175EXPORT_SYMBOL(register_quota_format);
176
177void unregister_quota_format(struct quota_format_type *fmt)
178{
179 struct quota_format_type **actqf;
180
181 spin_lock(lock: &dq_list_lock);
182 for (actqf = &quota_formats; *actqf && *actqf != fmt;
183 actqf = &(*actqf)->qf_next)
184 ;
185 if (*actqf)
186 *actqf = (*actqf)->qf_next;
187 spin_unlock(lock: &dq_list_lock);
188}
189EXPORT_SYMBOL(unregister_quota_format);
190
191static struct quota_format_type *find_quota_format(int id)
192{
193 struct quota_format_type *actqf;
194
195 spin_lock(lock: &dq_list_lock);
196 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
197 actqf = actqf->qf_next)
198 ;
199 if (!actqf || !try_module_get(module: actqf->qf_owner)) {
200 int qm;
201
202 spin_unlock(lock: &dq_list_lock);
203
204 for (qm = 0; module_names[qm].qm_fmt_id &&
205 module_names[qm].qm_fmt_id != id; qm++)
206 ;
207 if (!module_names[qm].qm_fmt_id ||
208 request_module(module_names[qm].qm_mod_name))
209 return NULL;
210
211 spin_lock(lock: &dq_list_lock);
212 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
213 actqf = actqf->qf_next)
214 ;
215 if (actqf && !try_module_get(module: actqf->qf_owner))
216 actqf = NULL;
217 }
218 spin_unlock(lock: &dq_list_lock);
219 return actqf;
220}
221
222static void put_quota_format(struct quota_format_type *fmt)
223{
224 module_put(module: fmt->qf_owner);
225}
226
227/*
228 * Dquot List Management:
229 * The quota code uses five lists for dquot management: the inuse_list,
230 * releasing_dquots, free_dquots, dqi_dirty_list, and dquot_hash[] array.
231 * A single dquot structure may be on some of those lists, depending on
232 * its current state.
233 *
234 * All dquots are placed to the end of inuse_list when first created, and this
235 * list is used for invalidate operation, which must look at every dquot.
236 *
237 * When the last reference of a dquot is dropped, the dquot is added to
238 * releasing_dquots. We'll then queue work item which will call
239 * synchronize_srcu() and after that perform the final cleanup of all the
240 * dquots on the list. Each cleaned up dquot is moved to free_dquots list.
241 * Both releasing_dquots and free_dquots use the dq_free list_head in the dquot
242 * struct.
243 *
244 * Unused and cleaned up dquots are in the free_dquots list and this list is
245 * searched whenever we need an available dquot. Dquots are removed from the
246 * list as soon as they are used again and dqstats.free_dquots gives the number
247 * of dquots on the list. When dquot is invalidated it's completely released
248 * from memory.
249 *
250 * Dirty dquots are added to the dqi_dirty_list of quota_info when mark
251 * dirtied, and this list is searched when writing dirty dquots back to
252 * quota file. Note that some filesystems do dirty dquot tracking on their
253 * own (e.g. in a journal) and thus don't use dqi_dirty_list.
254 *
255 * Dquots with a specific identity (device, type and id) are placed on
256 * one of the dquot_hash[] hash chains. The provides an efficient search
257 * mechanism to locate a specific dquot.
258 */
259
260static LIST_HEAD(inuse_list);
261static LIST_HEAD(free_dquots);
262static LIST_HEAD(releasing_dquots);
263static unsigned int dq_hash_bits, dq_hash_mask;
264static struct hlist_head *dquot_hash;
265
266struct dqstats dqstats;
267EXPORT_SYMBOL(dqstats);
268
269static qsize_t inode_get_rsv_space(struct inode *inode);
270static qsize_t __inode_get_rsv_space(struct inode *inode);
271static int __dquot_initialize(struct inode *inode, int type);
272
273static void quota_release_workfn(struct work_struct *work);
274static DECLARE_DELAYED_WORK(quota_release_work, quota_release_workfn);
275
276static inline unsigned int
277hashfn(const struct super_block *sb, struct kqid qid)
278{
279 unsigned int id = from_kqid(to: &init_user_ns, qid);
280 int type = qid.type;
281 unsigned long tmp;
282
283 tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
284 return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
285}
286
287/*
288 * Following list functions expect dq_list_lock to be held
289 */
290static inline void insert_dquot_hash(struct dquot *dquot)
291{
292 struct hlist_head *head;
293 head = dquot_hash + hashfn(sb: dquot->dq_sb, qid: dquot->dq_id);
294 hlist_add_head(n: &dquot->dq_hash, h: head);
295}
296
297static inline void remove_dquot_hash(struct dquot *dquot)
298{
299 hlist_del_init(n: &dquot->dq_hash);
300}
301
302static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
303 struct kqid qid)
304{
305 struct dquot *dquot;
306
307 hlist_for_each_entry(dquot, dquot_hash+hashent, dq_hash)
308 if (dquot->dq_sb == sb && qid_eq(left: dquot->dq_id, right: qid))
309 return dquot;
310
311 return NULL;
312}
313
314/* Add a dquot to the tail of the free list */
315static inline void put_dquot_last(struct dquot *dquot)
316{
317 list_add_tail(new: &dquot->dq_free, head: &free_dquots);
318 dqstats_inc(type: DQST_FREE_DQUOTS);
319}
320
321static inline void put_releasing_dquots(struct dquot *dquot)
322{
323 list_add_tail(new: &dquot->dq_free, head: &releasing_dquots);
324 set_bit(DQ_RELEASING_B, addr: &dquot->dq_flags);
325}
326
327static inline void remove_free_dquot(struct dquot *dquot)
328{
329 if (list_empty(head: &dquot->dq_free))
330 return;
331 list_del_init(entry: &dquot->dq_free);
332 if (!test_bit(DQ_RELEASING_B, &dquot->dq_flags))
333 dqstats_dec(type: DQST_FREE_DQUOTS);
334 else
335 clear_bit(DQ_RELEASING_B, addr: &dquot->dq_flags);
336}
337
338static inline void put_inuse(struct dquot *dquot)
339{
340 /* We add to the back of inuse list so we don't have to restart
341 * when traversing this list and we block */
342 list_add_tail(new: &dquot->dq_inuse, head: &inuse_list);
343 dqstats_inc(type: DQST_ALLOC_DQUOTS);
344}
345
346static inline void remove_inuse(struct dquot *dquot)
347{
348 dqstats_dec(type: DQST_ALLOC_DQUOTS);
349 list_del(entry: &dquot->dq_inuse);
350}
351/*
352 * End of list functions needing dq_list_lock
353 */
354
355static void wait_on_dquot(struct dquot *dquot)
356{
357 mutex_lock(lock: &dquot->dq_lock);
358 mutex_unlock(lock: &dquot->dq_lock);
359}
360
361static inline int dquot_active(struct dquot *dquot)
362{
363 return test_bit(DQ_ACTIVE_B, &dquot->dq_flags);
364}
365
366static inline int dquot_dirty(struct dquot *dquot)
367{
368 return test_bit(DQ_MOD_B, &dquot->dq_flags);
369}
370
371static inline int mark_dquot_dirty(struct dquot *dquot)
372{
373 return dquot->dq_sb->dq_op->mark_dirty(dquot);
374}
375
376/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
377int dquot_mark_dquot_dirty(struct dquot *dquot)
378{
379 int ret = 1;
380
381 if (!dquot_active(dquot))
382 return 0;
383
384 if (sb_dqopt(sb: dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
385 return test_and_set_bit(DQ_MOD_B, addr: &dquot->dq_flags);
386
387 /* If quota is dirty already, we don't have to acquire dq_list_lock */
388 if (dquot_dirty(dquot))
389 return 1;
390
391 spin_lock(lock: &dq_list_lock);
392 if (!test_and_set_bit(DQ_MOD_B, addr: &dquot->dq_flags)) {
393 list_add(new: &dquot->dq_dirty, head: &sb_dqopt(sb: dquot->dq_sb)->
394 info[dquot->dq_id.type].dqi_dirty_list);
395 ret = 0;
396 }
397 spin_unlock(lock: &dq_list_lock);
398 return ret;
399}
400EXPORT_SYMBOL(dquot_mark_dquot_dirty);
401
402/* Dirtify all the dquots - this can block when journalling */
403static inline int mark_all_dquot_dirty(struct dquot __rcu * const *dquots)
404{
405 int ret, err, cnt;
406 struct dquot *dquot;
407
408 ret = err = 0;
409 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
410 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
411 if (dquot)
412 /* Even in case of error we have to continue */
413 ret = mark_dquot_dirty(dquot);
414 if (!err && ret < 0)
415 err = ret;
416 }
417 return err;
418}
419
420static inline void dqput_all(struct dquot **dquot)
421{
422 unsigned int cnt;
423
424 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
425 dqput(dquot: dquot[cnt]);
426}
427
428static inline int clear_dquot_dirty(struct dquot *dquot)
429{
430 if (sb_dqopt(sb: dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
431 return test_and_clear_bit(DQ_MOD_B, addr: &dquot->dq_flags);
432
433 spin_lock(lock: &dq_list_lock);
434 if (!test_and_clear_bit(DQ_MOD_B, addr: &dquot->dq_flags)) {
435 spin_unlock(lock: &dq_list_lock);
436 return 0;
437 }
438 list_del_init(entry: &dquot->dq_dirty);
439 spin_unlock(lock: &dq_list_lock);
440 return 1;
441}
442
443void mark_info_dirty(struct super_block *sb, int type)
444{
445 spin_lock(lock: &dq_data_lock);
446 sb_dqopt(sb)->info[type].dqi_flags |= DQF_INFO_DIRTY;
447 spin_unlock(lock: &dq_data_lock);
448}
449EXPORT_SYMBOL(mark_info_dirty);
450
451/*
452 * Read dquot from disk and alloc space for it
453 */
454
455int dquot_acquire(struct dquot *dquot)
456{
457 int ret = 0, ret2 = 0;
458 unsigned int memalloc;
459 struct quota_info *dqopt = sb_dqopt(sb: dquot->dq_sb);
460
461 mutex_lock(lock: &dquot->dq_lock);
462 memalloc = memalloc_nofs_save();
463 if (!test_bit(DQ_READ_B, &dquot->dq_flags)) {
464 ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot);
465 if (ret < 0)
466 goto out_iolock;
467 }
468 /* Make sure flags update is visible after dquot has been filled */
469 smp_mb__before_atomic();
470 set_bit(DQ_READ_B, addr: &dquot->dq_flags);
471 /* Instantiate dquot if needed */
472 if (!dquot_active(dquot) && !dquot->dq_off) {
473 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
474 /* Write the info if needed */
475 if (info_dirty(info: &dqopt->info[dquot->dq_id.type])) {
476 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
477 dquot->dq_sb, dquot->dq_id.type);
478 }
479 if (ret < 0)
480 goto out_iolock;
481 if (ret2 < 0) {
482 ret = ret2;
483 goto out_iolock;
484 }
485 }
486 /*
487 * Make sure flags update is visible after on-disk struct has been
488 * allocated. Paired with smp_rmb() in dqget().
489 */
490 smp_mb__before_atomic();
491 set_bit(DQ_ACTIVE_B, addr: &dquot->dq_flags);
492out_iolock:
493 memalloc_nofs_restore(flags: memalloc);
494 mutex_unlock(lock: &dquot->dq_lock);
495 return ret;
496}
497EXPORT_SYMBOL(dquot_acquire);
498
499/*
500 * Write dquot to disk
501 */
502int dquot_commit(struct dquot *dquot)
503{
504 int ret = 0;
505 unsigned int memalloc;
506 struct quota_info *dqopt = sb_dqopt(sb: dquot->dq_sb);
507
508 mutex_lock(lock: &dquot->dq_lock);
509 memalloc = memalloc_nofs_save();
510 if (!clear_dquot_dirty(dquot))
511 goto out_lock;
512 /* Inactive dquot can be only if there was error during read/init
513 * => we have better not writing it */
514 if (dquot_active(dquot))
515 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
516 else
517 ret = -EIO;
518out_lock:
519 memalloc_nofs_restore(flags: memalloc);
520 mutex_unlock(lock: &dquot->dq_lock);
521 return ret;
522}
523EXPORT_SYMBOL(dquot_commit);
524
525/*
526 * Release dquot
527 */
528int dquot_release(struct dquot *dquot)
529{
530 int ret = 0, ret2 = 0;
531 unsigned int memalloc;
532 struct quota_info *dqopt = sb_dqopt(sb: dquot->dq_sb);
533
534 mutex_lock(lock: &dquot->dq_lock);
535 memalloc = memalloc_nofs_save();
536 /* Check whether we are not racing with some other dqget() */
537 if (dquot_is_busy(dquot))
538 goto out_dqlock;
539 if (dqopt->ops[dquot->dq_id.type]->release_dqblk) {
540 ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot);
541 /* Write the info */
542 if (info_dirty(info: &dqopt->info[dquot->dq_id.type])) {
543 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
544 dquot->dq_sb, dquot->dq_id.type);
545 }
546 if (ret >= 0)
547 ret = ret2;
548 }
549 clear_bit(DQ_ACTIVE_B, addr: &dquot->dq_flags);
550out_dqlock:
551 memalloc_nofs_restore(flags: memalloc);
552 mutex_unlock(lock: &dquot->dq_lock);
553 return ret;
554}
555EXPORT_SYMBOL(dquot_release);
556
557void dquot_destroy(struct dquot *dquot)
558{
559 kmem_cache_free(s: dquot_cachep, objp: dquot);
560}
561EXPORT_SYMBOL(dquot_destroy);
562
563static inline void do_destroy_dquot(struct dquot *dquot)
564{
565 dquot->dq_sb->dq_op->destroy_dquot(dquot);
566}
567
568/* Invalidate all dquots on the list. Note that this function is called after
569 * quota is disabled and pointers from inodes removed so there cannot be new
570 * quota users. There can still be some users of quotas due to inodes being
571 * just deleted or pruned by prune_icache() (those are not attached to any
572 * list) or parallel quotactl call. We have to wait for such users.
573 */
574static void invalidate_dquots(struct super_block *sb, int type)
575{
576 struct dquot *dquot, *tmp;
577
578restart:
579 flush_delayed_work(dwork: &quota_release_work);
580
581 spin_lock(lock: &dq_list_lock);
582 list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
583 if (dquot->dq_sb != sb)
584 continue;
585 if (dquot->dq_id.type != type)
586 continue;
587 /* Wait for dquot users */
588 if (atomic_read(v: &dquot->dq_count)) {
589 atomic_inc(v: &dquot->dq_count);
590 spin_unlock(lock: &dq_list_lock);
591 /*
592 * Once dqput() wakes us up, we know it's time to free
593 * the dquot.
594 * IMPORTANT: we rely on the fact that there is always
595 * at most one process waiting for dquot to free.
596 * Otherwise dq_count would be > 1 and we would never
597 * wake up.
598 */
599 wait_event(dquot_ref_wq,
600 atomic_read(&dquot->dq_count) == 1);
601 dqput(dquot);
602 /* At this moment dquot() need not exist (it could be
603 * reclaimed by prune_dqcache(). Hence we must
604 * restart. */
605 goto restart;
606 }
607 /*
608 * The last user already dropped its reference but dquot didn't
609 * get fully cleaned up yet. Restart the scan which flushes the
610 * work cleaning up released dquots.
611 */
612 if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) {
613 spin_unlock(lock: &dq_list_lock);
614 goto restart;
615 }
616 /*
617 * Quota now has no users and it has been written on last
618 * dqput()
619 */
620 remove_dquot_hash(dquot);
621 remove_free_dquot(dquot);
622 remove_inuse(dquot);
623 do_destroy_dquot(dquot);
624 }
625 spin_unlock(lock: &dq_list_lock);
626}
627
628/* Call callback for every active dquot on given filesystem */
629int dquot_scan_active(struct super_block *sb,
630 int (*fn)(struct dquot *dquot, unsigned long priv),
631 unsigned long priv)
632{
633 struct dquot *dquot, *old_dquot = NULL;
634 int ret = 0;
635
636 WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));
637
638 spin_lock(lock: &dq_list_lock);
639 list_for_each_entry(dquot, &inuse_list, dq_inuse) {
640 if (!dquot_active(dquot))
641 continue;
642 if (dquot->dq_sb != sb)
643 continue;
644 /* Now we have active dquot so we can just increase use count */
645 atomic_inc(v: &dquot->dq_count);
646 spin_unlock(lock: &dq_list_lock);
647 dqput(dquot: old_dquot);
648 old_dquot = dquot;
649 /*
650 * ->release_dquot() can be racing with us. Our reference
651 * protects us from new calls to it so just wait for any
652 * outstanding call and recheck the DQ_ACTIVE_B after that.
653 */
654 wait_on_dquot(dquot);
655 if (dquot_active(dquot)) {
656 ret = fn(dquot, priv);
657 if (ret < 0)
658 goto out;
659 }
660 spin_lock(lock: &dq_list_lock);
661 /* We are safe to continue now because our dquot could not
662 * be moved out of the inuse list while we hold the reference */
663 }
664 spin_unlock(lock: &dq_list_lock);
665out:
666 dqput(dquot: old_dquot);
667 return ret;
668}
669EXPORT_SYMBOL(dquot_scan_active);
670
671static inline int dquot_write_dquot(struct dquot *dquot)
672{
673 int ret = dquot->dq_sb->dq_op->write_dquot(dquot);
674 if (ret < 0) {
675 quota_error(dquot->dq_sb, "Can't write quota structure "
676 "(error %d). Quota may get out of sync!", ret);
677 /* Clear dirty bit anyway to avoid infinite loop. */
678 clear_dquot_dirty(dquot);
679 }
680 return ret;
681}
682
683/* Write all dquot structures to quota files */
684int dquot_writeback_dquots(struct super_block *sb, int type)
685{
686 struct list_head dirty;
687 struct dquot *dquot;
688 struct quota_info *dqopt = sb_dqopt(sb);
689 int cnt;
690 int err, ret = 0;
691
692 WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));
693
694 flush_delayed_work(dwork: &quota_release_work);
695
696 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
697 if (type != -1 && cnt != type)
698 continue;
699 if (!sb_has_quota_active(sb, type: cnt))
700 continue;
701 spin_lock(lock: &dq_list_lock);
702 /* Move list away to avoid livelock. */
703 list_replace_init(old: &dqopt->info[cnt].dqi_dirty_list, new: &dirty);
704 while (!list_empty(head: &dirty)) {
705 dquot = list_first_entry(&dirty, struct dquot,
706 dq_dirty);
707
708 WARN_ON(!dquot_active(dquot));
709 /* If the dquot is releasing we should not touch it */
710 if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) {
711 spin_unlock(lock: &dq_list_lock);
712 flush_delayed_work(dwork: &quota_release_work);
713 spin_lock(lock: &dq_list_lock);
714 continue;
715 }
716
717 /* Now we have active dquot from which someone is
718 * holding reference so we can safely just increase
719 * use count */
720 dqgrab(dquot);
721 spin_unlock(lock: &dq_list_lock);
722 err = dquot_write_dquot(dquot);
723 if (err && !ret)
724 ret = err;
725 dqput(dquot);
726 spin_lock(lock: &dq_list_lock);
727 }
728 spin_unlock(lock: &dq_list_lock);
729 }
730
731 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
732 if ((cnt == type || type == -1) && sb_has_quota_active(sb, type: cnt)
733 && info_dirty(info: &dqopt->info[cnt]))
734 sb->dq_op->write_info(sb, cnt);
735 dqstats_inc(type: DQST_SYNCS);
736
737 return ret;
738}
739EXPORT_SYMBOL(dquot_writeback_dquots);
740
741/* Write all dquot structures to disk and make them visible from userspace */
742int dquot_quota_sync(struct super_block *sb, int type)
743{
744 struct quota_info *dqopt = sb_dqopt(sb);
745 int cnt;
746 int ret;
747
748 ret = dquot_writeback_dquots(sb, type);
749 if (ret)
750 return ret;
751 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
752 return 0;
753
754 /* This is not very clever (and fast) but currently I don't know about
755 * any other simple way of getting quota data to disk and we must get
756 * them there for userspace to be visible... */
757 if (sb->s_op->sync_fs) {
758 ret = sb->s_op->sync_fs(sb, 1);
759 if (ret)
760 return ret;
761 }
762 ret = sync_blockdev(bdev: sb->s_bdev);
763 if (ret)
764 return ret;
765
766 /*
767 * Now when everything is written we can discard the pagecache so
768 * that userspace sees the changes.
769 */
770 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
771 if (type != -1 && cnt != type)
772 continue;
773 if (!sb_has_quota_active(sb, type: cnt))
774 continue;
775 inode_lock(inode: dqopt->files[cnt]);
776 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
777 inode_unlock(inode: dqopt->files[cnt]);
778 }
779
780 return 0;
781}
782EXPORT_SYMBOL(dquot_quota_sync);
783
784static unsigned long
785dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
786{
787 struct dquot *dquot;
788 unsigned long freed = 0;
789
790 spin_lock(lock: &dq_list_lock);
791 while (!list_empty(head: &free_dquots) && sc->nr_to_scan) {
792 dquot = list_first_entry(&free_dquots, struct dquot, dq_free);
793 remove_dquot_hash(dquot);
794 remove_free_dquot(dquot);
795 remove_inuse(dquot);
796 do_destroy_dquot(dquot);
797 sc->nr_to_scan--;
798 freed++;
799 }
800 spin_unlock(lock: &dq_list_lock);
801 return freed;
802}
803
804static unsigned long
805dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
806{
807 return vfs_pressure_ratio(
808 val: percpu_counter_read_positive(fbc: &dqstats.counter[DQST_FREE_DQUOTS]));
809}
810
811/*
812 * Safely release dquot and put reference to dquot.
813 */
814static void quota_release_workfn(struct work_struct *work)
815{
816 struct dquot *dquot;
817 struct list_head rls_head;
818
819 spin_lock(lock: &dq_list_lock);
820 /* Exchange the list head to avoid livelock. */
821 list_replace_init(old: &releasing_dquots, new: &rls_head);
822 spin_unlock(lock: &dq_list_lock);
823 synchronize_srcu(ssp: &dquot_srcu);
824
825restart:
826 spin_lock(lock: &dq_list_lock);
827 while (!list_empty(head: &rls_head)) {
828 dquot = list_first_entry(&rls_head, struct dquot, dq_free);
829 WARN_ON_ONCE(atomic_read(&dquot->dq_count));
830 /*
831 * Note that DQ_RELEASING_B protects us from racing with
832 * invalidate_dquots() calls so we are safe to work with the
833 * dquot even after we drop dq_list_lock.
834 */
835 if (dquot_dirty(dquot)) {
836 spin_unlock(lock: &dq_list_lock);
837 /* Commit dquot before releasing */
838 dquot_write_dquot(dquot);
839 goto restart;
840 }
841 if (dquot_active(dquot)) {
842 spin_unlock(lock: &dq_list_lock);
843 dquot->dq_sb->dq_op->release_dquot(dquot);
844 goto restart;
845 }
846 /* Dquot is inactive and clean, now move it to free list */
847 remove_free_dquot(dquot);
848 put_dquot_last(dquot);
849 }
850 spin_unlock(lock: &dq_list_lock);
851}
852
853/*
854 * Put reference to dquot
855 */
856void dqput(struct dquot *dquot)
857{
858 if (!dquot)
859 return;
860#ifdef CONFIG_QUOTA_DEBUG
861 if (!atomic_read(&dquot->dq_count)) {
862 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
863 quotatypes[dquot->dq_id.type],
864 from_kqid(&init_user_ns, dquot->dq_id));
865 BUG();
866 }
867#endif
868 dqstats_inc(type: DQST_DROPS);
869
870 spin_lock(lock: &dq_list_lock);
871 if (atomic_read(v: &dquot->dq_count) > 1) {
872 /* We have more than one user... nothing to do */
873 atomic_dec(v: &dquot->dq_count);
874 /* Releasing dquot during quotaoff phase? */
875 if (!sb_has_quota_active(sb: dquot->dq_sb, type: dquot->dq_id.type) &&
876 atomic_read(v: &dquot->dq_count) == 1)
877 wake_up(&dquot_ref_wq);
878 spin_unlock(lock: &dq_list_lock);
879 return;
880 }
881
882 /* Need to release dquot? */
883 WARN_ON_ONCE(!list_empty(&dquot->dq_free));
884 put_releasing_dquots(dquot);
885 atomic_dec(v: &dquot->dq_count);
886 spin_unlock(lock: &dq_list_lock);
887 queue_delayed_work(wq: quota_unbound_wq, dwork: &quota_release_work, delay: 1);
888}
889EXPORT_SYMBOL(dqput);
890
891struct dquot *dquot_alloc(struct super_block *sb, int type)
892{
893 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
894}
895EXPORT_SYMBOL(dquot_alloc);
896
897static struct dquot *get_empty_dquot(struct super_block *sb, int type)
898{
899 struct dquot *dquot;
900
901 dquot = sb->dq_op->alloc_dquot(sb, type);
902 if(!dquot)
903 return NULL;
904
905 mutex_init(&dquot->dq_lock);
906 INIT_LIST_HEAD(list: &dquot->dq_free);
907 INIT_LIST_HEAD(list: &dquot->dq_inuse);
908 INIT_HLIST_NODE(h: &dquot->dq_hash);
909 INIT_LIST_HEAD(list: &dquot->dq_dirty);
910 dquot->dq_sb = sb;
911 dquot->dq_id = make_kqid_invalid(type);
912 atomic_set(v: &dquot->dq_count, i: 1);
913 spin_lock_init(&dquot->dq_dqb_lock);
914
915 return dquot;
916}
917
918/*
919 * Get reference to dquot
920 *
921 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
922 * destroying our dquot by:
923 * a) checking for quota flags under dq_list_lock and
924 * b) getting a reference to dquot before we release dq_list_lock
925 */
926struct dquot *dqget(struct super_block *sb, struct kqid qid)
927{
928 unsigned int hashent = hashfn(sb, qid);
929 struct dquot *dquot, *empty = NULL;
930
931 if (!qid_has_mapping(ns: sb->s_user_ns, qid))
932 return ERR_PTR(error: -EINVAL);
933
934 if (!sb_has_quota_active(sb, type: qid.type))
935 return ERR_PTR(error: -ESRCH);
936we_slept:
937 spin_lock(lock: &dq_list_lock);
938 spin_lock(lock: &dq_state_lock);
939 if (!sb_has_quota_active(sb, type: qid.type)) {
940 spin_unlock(lock: &dq_state_lock);
941 spin_unlock(lock: &dq_list_lock);
942 dquot = ERR_PTR(error: -ESRCH);
943 goto out;
944 }
945 spin_unlock(lock: &dq_state_lock);
946
947 dquot = find_dquot(hashent, sb, qid);
948 if (!dquot) {
949 if (!empty) {
950 spin_unlock(lock: &dq_list_lock);
951 empty = get_empty_dquot(sb, type: qid.type);
952 if (!empty)
953 schedule(); /* Try to wait for a moment... */
954 goto we_slept;
955 }
956 dquot = empty;
957 empty = NULL;
958 dquot->dq_id = qid;
959 /* all dquots go on the inuse_list */
960 put_inuse(dquot);
961 /* hash it first so it can be found */
962 insert_dquot_hash(dquot);
963 spin_unlock(lock: &dq_list_lock);
964 dqstats_inc(type: DQST_LOOKUPS);
965 } else {
966 if (!atomic_read(v: &dquot->dq_count))
967 remove_free_dquot(dquot);
968 atomic_inc(v: &dquot->dq_count);
969 spin_unlock(lock: &dq_list_lock);
970 dqstats_inc(type: DQST_CACHE_HITS);
971 dqstats_inc(type: DQST_LOOKUPS);
972 }
973 /* Wait for dq_lock - after this we know that either dquot_release() is
974 * already finished or it will be canceled due to dq_count > 0 test */
975 wait_on_dquot(dquot);
976 /* Read the dquot / allocate space in quota file */
977 if (!dquot_active(dquot)) {
978 int err;
979
980 err = sb->dq_op->acquire_dquot(dquot);
981 if (err < 0) {
982 dqput(dquot);
983 dquot = ERR_PTR(error: err);
984 goto out;
985 }
986 }
987 /*
988 * Make sure following reads see filled structure - paired with
989 * smp_mb__before_atomic() in dquot_acquire().
990 */
991 smp_rmb();
992 /* Has somebody invalidated entry under us? */
993 WARN_ON_ONCE(hlist_unhashed(&dquot->dq_hash));
994out:
995 if (empty)
996 do_destroy_dquot(dquot: empty);
997
998 return dquot;
999}
1000EXPORT_SYMBOL(dqget);
1001
1002static inline struct dquot __rcu **i_dquot(struct inode *inode)
1003{
1004 return inode->i_sb->s_op->get_dquots(inode);
1005}
1006
1007static int dqinit_needed(struct inode *inode, int type)
1008{
1009 struct dquot __rcu * const *dquots;
1010 int cnt;
1011
1012 if (IS_NOQUOTA(inode))
1013 return 0;
1014
1015 dquots = i_dquot(inode);
1016 if (type != -1)
1017 return !dquots[type];
1018 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1019 if (!dquots[cnt])
1020 return 1;
1021 return 0;
1022}
1023
1024/* This routine is guarded by s_umount semaphore */
1025static int add_dquot_ref(struct super_block *sb, int type)
1026{
1027 struct inode *inode, *old_inode = NULL;
1028#ifdef CONFIG_QUOTA_DEBUG
1029 int reserved = 0;
1030#endif
1031 int err = 0;
1032
1033 spin_lock(lock: &sb->s_inode_list_lock);
1034 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1035 spin_lock(lock: &inode->i_lock);
1036 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
1037 !atomic_read(v: &inode->i_writecount) ||
1038 !dqinit_needed(inode, type)) {
1039 spin_unlock(lock: &inode->i_lock);
1040 continue;
1041 }
1042 __iget(inode);
1043 spin_unlock(lock: &inode->i_lock);
1044 spin_unlock(lock: &sb->s_inode_list_lock);
1045
1046#ifdef CONFIG_QUOTA_DEBUG
1047 if (unlikely(inode_get_rsv_space(inode) > 0))
1048 reserved = 1;
1049#endif
1050 iput(old_inode);
1051 err = __dquot_initialize(inode, type);
1052 if (err) {
1053 iput(inode);
1054 goto out;
1055 }
1056
1057 /*
1058 * We hold a reference to 'inode' so it couldn't have been
1059 * removed from s_inodes list while we dropped the
1060 * s_inode_list_lock. We cannot iput the inode now as we can be
1061 * holding the last reference and we cannot iput it under
1062 * s_inode_list_lock. So we keep the reference and iput it
1063 * later.
1064 */
1065 old_inode = inode;
1066 cond_resched();
1067 spin_lock(lock: &sb->s_inode_list_lock);
1068 }
1069 spin_unlock(lock: &sb->s_inode_list_lock);
1070 iput(old_inode);
1071out:
1072#ifdef CONFIG_QUOTA_DEBUG
1073 if (reserved) {
1074 quota_error(sb, "Writes happened before quota was turned on "
1075 "thus quota information is probably inconsistent. "
1076 "Please run quotacheck(8)");
1077 }
1078#endif
1079 return err;
1080}
1081
1082static void remove_dquot_ref(struct super_block *sb, int type)
1083{
1084 struct inode *inode;
1085#ifdef CONFIG_QUOTA_DEBUG
1086 int reserved = 0;
1087#endif
1088
1089 spin_lock(lock: &sb->s_inode_list_lock);
1090 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1091 /*
1092 * We have to scan also I_NEW inodes because they can already
1093 * have quota pointer initialized. Luckily, we need to touch
1094 * only quota pointers and these have separate locking
1095 * (dq_data_lock).
1096 */
1097 spin_lock(lock: &dq_data_lock);
1098 if (!IS_NOQUOTA(inode)) {
1099 struct dquot __rcu **dquots = i_dquot(inode);
1100 struct dquot *dquot = srcu_dereference_check(
1101 dquots[type], &dquot_srcu,
1102 lockdep_is_held(&dq_data_lock));
1103
1104#ifdef CONFIG_QUOTA_DEBUG
1105 if (unlikely(inode_get_rsv_space(inode) > 0))
1106 reserved = 1;
1107#endif
1108 rcu_assign_pointer(dquots[type], NULL);
1109 if (dquot)
1110 dqput(dquot);
1111 }
1112 spin_unlock(lock: &dq_data_lock);
1113 }
1114 spin_unlock(lock: &sb->s_inode_list_lock);
1115#ifdef CONFIG_QUOTA_DEBUG
1116 if (reserved) {
1117 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1118 " was disabled thus quota information is probably "
1119 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1120 }
1121#endif
1122}
1123
1124/* Gather all references from inodes and drop them */
1125static void drop_dquot_ref(struct super_block *sb, int type)
1126{
1127 if (sb->dq_op)
1128 remove_dquot_ref(sb, type);
1129}
1130
1131static inline
1132void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1133{
1134 if (dquot->dq_dqb.dqb_rsvspace >= number)
1135 dquot->dq_dqb.dqb_rsvspace -= number;
1136 else {
1137 WARN_ON_ONCE(1);
1138 dquot->dq_dqb.dqb_rsvspace = 0;
1139 }
1140 if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <=
1141 dquot->dq_dqb.dqb_bsoftlimit)
1142 dquot->dq_dqb.dqb_btime = (time64_t) 0;
1143 clear_bit(DQ_BLKS_B, addr: &dquot->dq_flags);
1144}
1145
1146static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
1147{
1148 if (sb_dqopt(sb: dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1149 dquot->dq_dqb.dqb_curinodes >= number)
1150 dquot->dq_dqb.dqb_curinodes -= number;
1151 else
1152 dquot->dq_dqb.dqb_curinodes = 0;
1153 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1154 dquot->dq_dqb.dqb_itime = (time64_t) 0;
1155 clear_bit(DQ_INODES_B, addr: &dquot->dq_flags);
1156}
1157
1158static void dquot_decr_space(struct dquot *dquot, qsize_t number)
1159{
1160 if (sb_dqopt(sb: dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1161 dquot->dq_dqb.dqb_curspace >= number)
1162 dquot->dq_dqb.dqb_curspace -= number;
1163 else
1164 dquot->dq_dqb.dqb_curspace = 0;
1165 if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <=
1166 dquot->dq_dqb.dqb_bsoftlimit)
1167 dquot->dq_dqb.dqb_btime = (time64_t) 0;
1168 clear_bit(DQ_BLKS_B, addr: &dquot->dq_flags);
1169}
1170
1171struct dquot_warn {
1172 struct super_block *w_sb;
1173 struct kqid w_dq_id;
1174 short w_type;
1175};
1176
1177static int warning_issued(struct dquot *dquot, const int warntype)
1178{
1179 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1180 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1181 ((warntype == QUOTA_NL_IHARDWARN ||
1182 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1183
1184 if (!flag)
1185 return 0;
1186 return test_and_set_bit(nr: flag, addr: &dquot->dq_flags);
1187}
1188
1189#ifdef CONFIG_PRINT_QUOTA_WARNING
1190static int flag_print_warnings = 1;
1191
1192static int need_print_warning(struct dquot_warn *warn)
1193{
1194 if (!flag_print_warnings)
1195 return 0;
1196
1197 switch (warn->w_dq_id.type) {
1198 case USRQUOTA:
1199 return uid_eq(current_fsuid(), warn->w_dq_id.uid);
1200 case GRPQUOTA:
1201 return in_group_p(warn->w_dq_id.gid);
1202 case PRJQUOTA:
1203 return 1;
1204 }
1205 return 0;
1206}
1207
1208/* Print warning to user which exceeded quota */
1209static void print_warning(struct dquot_warn *warn)
1210{
1211 char *msg = NULL;
1212 struct tty_struct *tty;
1213 int warntype = warn->w_type;
1214
1215 if (warntype == QUOTA_NL_IHARDBELOW ||
1216 warntype == QUOTA_NL_ISOFTBELOW ||
1217 warntype == QUOTA_NL_BHARDBELOW ||
1218 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
1219 return;
1220
1221 tty = get_current_tty();
1222 if (!tty)
1223 return;
1224 tty_write_message(tty, warn->w_sb->s_id);
1225 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
1226 tty_write_message(tty, ": warning, ");
1227 else
1228 tty_write_message(tty, ": write failed, ");
1229 tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
1230 switch (warntype) {
1231 case QUOTA_NL_IHARDWARN:
1232 msg = " file limit reached.\r\n";
1233 break;
1234 case QUOTA_NL_ISOFTLONGWARN:
1235 msg = " file quota exceeded too long.\r\n";
1236 break;
1237 case QUOTA_NL_ISOFTWARN:
1238 msg = " file quota exceeded.\r\n";
1239 break;
1240 case QUOTA_NL_BHARDWARN:
1241 msg = " block limit reached.\r\n";
1242 break;
1243 case QUOTA_NL_BSOFTLONGWARN:
1244 msg = " block quota exceeded too long.\r\n";
1245 break;
1246 case QUOTA_NL_BSOFTWARN:
1247 msg = " block quota exceeded.\r\n";
1248 break;
1249 }
1250 tty_write_message(tty, msg);
1251 tty_kref_put(tty);
1252}
1253#endif
1254
1255static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1256 int warntype)
1257{
1258 if (warning_issued(dquot, warntype))
1259 return;
1260 warn->w_type = warntype;
1261 warn->w_sb = dquot->dq_sb;
1262 warn->w_dq_id = dquot->dq_id;
1263}
1264
1265/*
1266 * Write warnings to the console and send warning messages over netlink.
1267 *
1268 * Note that this function can call into tty and networking code.
1269 */
1270static void flush_warnings(struct dquot_warn *warn)
1271{
1272 int i;
1273
1274 for (i = 0; i < MAXQUOTAS; i++) {
1275 if (warn[i].w_type == QUOTA_NL_NOWARN)
1276 continue;
1277#ifdef CONFIG_PRINT_QUOTA_WARNING
1278 print_warning(&warn[i]);
1279#endif
1280 quota_send_warning(qid: warn[i].w_dq_id,
1281 dev: warn[i].w_sb->s_dev, warntype: warn[i].w_type);
1282 }
1283}
1284
1285static int ignore_hardlimit(struct dquot *dquot)
1286{
1287 struct mem_dqinfo *info = &sb_dqopt(sb: dquot->dq_sb)->info[dquot->dq_id.type];
1288
1289 return capable(CAP_SYS_RESOURCE) &&
1290 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1291 !(info->dqi_flags & DQF_ROOT_SQUASH));
1292}
1293
1294static int dquot_add_inodes(struct dquot *dquot, qsize_t inodes,
1295 struct dquot_warn *warn)
1296{
1297 qsize_t newinodes;
1298 int ret = 0;
1299
1300 spin_lock(lock: &dquot->dq_dqb_lock);
1301 newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1302 if (!sb_has_quota_limits_enabled(sb: dquot->dq_sb, type: dquot->dq_id.type) ||
1303 test_bit(DQ_FAKE_B, &dquot->dq_flags))
1304 goto add;
1305
1306 if (dquot->dq_dqb.dqb_ihardlimit &&
1307 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
1308 !ignore_hardlimit(dquot)) {
1309 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
1310 ret = -EDQUOT;
1311 goto out;
1312 }
1313
1314 if (dquot->dq_dqb.dqb_isoftlimit &&
1315 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1316 dquot->dq_dqb.dqb_itime &&
1317 ktime_get_real_seconds() >= dquot->dq_dqb.dqb_itime &&
1318 !ignore_hardlimit(dquot)) {
1319 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
1320 ret = -EDQUOT;
1321 goto out;
1322 }
1323
1324 if (dquot->dq_dqb.dqb_isoftlimit &&
1325 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1326 dquot->dq_dqb.dqb_itime == 0) {
1327 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
1328 dquot->dq_dqb.dqb_itime = ktime_get_real_seconds() +
1329 sb_dqopt(sb: dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
1330 }
1331add:
1332 dquot->dq_dqb.dqb_curinodes = newinodes;
1333
1334out:
1335 spin_unlock(lock: &dquot->dq_dqb_lock);
1336 return ret;
1337}
1338
1339static int dquot_add_space(struct dquot *dquot, qsize_t space,
1340 qsize_t rsv_space, unsigned int flags,
1341 struct dquot_warn *warn)
1342{
1343 qsize_t tspace;
1344 struct super_block *sb = dquot->dq_sb;
1345 int ret = 0;
1346
1347 spin_lock(lock: &dquot->dq_dqb_lock);
1348 if (!sb_has_quota_limits_enabled(sb, type: dquot->dq_id.type) ||
1349 test_bit(DQ_FAKE_B, &dquot->dq_flags))
1350 goto finish;
1351
1352 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1353 + space + rsv_space;
1354
1355 if (dquot->dq_dqb.dqb_bhardlimit &&
1356 tspace > dquot->dq_dqb.dqb_bhardlimit &&
1357 !ignore_hardlimit(dquot)) {
1358 if (flags & DQUOT_SPACE_WARN)
1359 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
1360 ret = -EDQUOT;
1361 goto finish;
1362 }
1363
1364 if (dquot->dq_dqb.dqb_bsoftlimit &&
1365 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1366 dquot->dq_dqb.dqb_btime &&
1367 ktime_get_real_seconds() >= dquot->dq_dqb.dqb_btime &&
1368 !ignore_hardlimit(dquot)) {
1369 if (flags & DQUOT_SPACE_WARN)
1370 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
1371 ret = -EDQUOT;
1372 goto finish;
1373 }
1374
1375 if (dquot->dq_dqb.dqb_bsoftlimit &&
1376 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1377 dquot->dq_dqb.dqb_btime == 0) {
1378 if (flags & DQUOT_SPACE_WARN) {
1379 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
1380 dquot->dq_dqb.dqb_btime = ktime_get_real_seconds() +
1381 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
1382 } else {
1383 /*
1384 * We don't allow preallocation to exceed softlimit so exceeding will
1385 * be always printed
1386 */
1387 ret = -EDQUOT;
1388 goto finish;
1389 }
1390 }
1391finish:
1392 /*
1393 * We have to be careful and go through warning generation & grace time
1394 * setting even if DQUOT_SPACE_NOFAIL is set. That's why we check it
1395 * only here...
1396 */
1397 if (flags & DQUOT_SPACE_NOFAIL)
1398 ret = 0;
1399 if (!ret) {
1400 dquot->dq_dqb.dqb_rsvspace += rsv_space;
1401 dquot->dq_dqb.dqb_curspace += space;
1402 }
1403 spin_unlock(lock: &dquot->dq_dqb_lock);
1404 return ret;
1405}
1406
1407static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1408{
1409 qsize_t newinodes;
1410
1411 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1412 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
1413 !sb_has_quota_limits_enabled(sb: dquot->dq_sb, type: dquot->dq_id.type))
1414 return QUOTA_NL_NOWARN;
1415
1416 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1417 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1418 return QUOTA_NL_ISOFTBELOW;
1419 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
1420 newinodes < dquot->dq_dqb.dqb_ihardlimit)
1421 return QUOTA_NL_IHARDBELOW;
1422 return QUOTA_NL_NOWARN;
1423}
1424
1425static int info_bdq_free(struct dquot *dquot, qsize_t space)
1426{
1427 qsize_t tspace;
1428
1429 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace;
1430
1431 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1432 tspace <= dquot->dq_dqb.dqb_bsoftlimit)
1433 return QUOTA_NL_NOWARN;
1434
1435 if (tspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
1436 return QUOTA_NL_BSOFTBELOW;
1437 if (tspace >= dquot->dq_dqb.dqb_bhardlimit &&
1438 tspace - space < dquot->dq_dqb.dqb_bhardlimit)
1439 return QUOTA_NL_BHARDBELOW;
1440 return QUOTA_NL_NOWARN;
1441}
1442
1443static int inode_quota_active(const struct inode *inode)
1444{
1445 struct super_block *sb = inode->i_sb;
1446
1447 if (IS_NOQUOTA(inode))
1448 return 0;
1449 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1450}
1451
1452/*
1453 * Initialize quota pointers in inode
1454 *
1455 * It is better to call this function outside of any transaction as it
1456 * might need a lot of space in journal for dquot structure allocation.
1457 */
1458static int __dquot_initialize(struct inode *inode, int type)
1459{
1460 int cnt, init_needed = 0;
1461 struct dquot __rcu **dquots;
1462 struct dquot *got[MAXQUOTAS] = {};
1463 struct super_block *sb = inode->i_sb;
1464 qsize_t rsv;
1465 int ret = 0;
1466
1467 if (!inode_quota_active(inode))
1468 return 0;
1469
1470 dquots = i_dquot(inode);
1471
1472 /* First get references to structures we might need. */
1473 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1474 struct kqid qid;
1475 kprojid_t projid;
1476 int rc;
1477 struct dquot *dquot;
1478
1479 if (type != -1 && cnt != type)
1480 continue;
1481 /*
1482 * The i_dquot should have been initialized in most cases,
1483 * we check it without locking here to avoid unnecessary
1484 * dqget()/dqput() calls.
1485 */
1486 if (dquots[cnt])
1487 continue;
1488
1489 if (!sb_has_quota_active(sb, type: cnt))
1490 continue;
1491
1492 init_needed = 1;
1493
1494 switch (cnt) {
1495 case USRQUOTA:
1496 qid = make_kqid_uid(uid: inode->i_uid);
1497 break;
1498 case GRPQUOTA:
1499 qid = make_kqid_gid(gid: inode->i_gid);
1500 break;
1501 case PRJQUOTA:
1502 rc = inode->i_sb->dq_op->get_projid(inode, &projid);
1503 if (rc)
1504 continue;
1505 qid = make_kqid_projid(projid);
1506 break;
1507 }
1508 dquot = dqget(sb, qid);
1509 if (IS_ERR(ptr: dquot)) {
1510 /* We raced with somebody turning quotas off... */
1511 if (PTR_ERR(ptr: dquot) != -ESRCH) {
1512 ret = PTR_ERR(ptr: dquot);
1513 goto out_put;
1514 }
1515 dquot = NULL;
1516 }
1517 got[cnt] = dquot;
1518 }
1519
1520 /* All required i_dquot has been initialized */
1521 if (!init_needed)
1522 return 0;
1523
1524 spin_lock(lock: &dq_data_lock);
1525 if (IS_NOQUOTA(inode))
1526 goto out_lock;
1527 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1528 if (type != -1 && cnt != type)
1529 continue;
1530 /* Avoid races with quotaoff() */
1531 if (!sb_has_quota_active(sb, type: cnt))
1532 continue;
1533 /* We could race with quotaon or dqget() could have failed */
1534 if (!got[cnt])
1535 continue;
1536 if (!dquots[cnt]) {
1537 rcu_assign_pointer(dquots[cnt], got[cnt]);
1538 got[cnt] = NULL;
1539 /*
1540 * Make quota reservation system happy if someone
1541 * did a write before quota was turned on
1542 */
1543 rsv = inode_get_rsv_space(inode);
1544 if (unlikely(rsv)) {
1545 struct dquot *dquot = srcu_dereference_check(
1546 dquots[cnt], &dquot_srcu,
1547 lockdep_is_held(&dq_data_lock));
1548
1549 spin_lock(lock: &inode->i_lock);
1550 /* Get reservation again under proper lock */
1551 rsv = __inode_get_rsv_space(inode);
1552 spin_lock(lock: &dquot->dq_dqb_lock);
1553 dquot->dq_dqb.dqb_rsvspace += rsv;
1554 spin_unlock(lock: &dquot->dq_dqb_lock);
1555 spin_unlock(lock: &inode->i_lock);
1556 }
1557 }
1558 }
1559out_lock:
1560 spin_unlock(lock: &dq_data_lock);
1561out_put:
1562 /* Drop unused references */
1563 dqput_all(dquot: got);
1564
1565 return ret;
1566}
1567
1568int dquot_initialize(struct inode *inode)
1569{
1570 return __dquot_initialize(inode, type: -1);
1571}
1572EXPORT_SYMBOL(dquot_initialize);
1573
1574bool dquot_initialize_needed(struct inode *inode)
1575{
1576 struct dquot __rcu **dquots;
1577 int i;
1578
1579 if (!inode_quota_active(inode))
1580 return false;
1581
1582 dquots = i_dquot(inode);
1583 for (i = 0; i < MAXQUOTAS; i++)
1584 if (!dquots[i] && sb_has_quota_active(sb: inode->i_sb, type: i))
1585 return true;
1586 return false;
1587}
1588EXPORT_SYMBOL(dquot_initialize_needed);
1589
1590/*
1591 * Release all quotas referenced by inode.
1592 *
1593 * This function only be called on inode free or converting
1594 * a file to quota file, no other users for the i_dquot in
1595 * both cases, so we needn't call synchronize_srcu() after
1596 * clearing i_dquot.
1597 */
1598static void __dquot_drop(struct inode *inode)
1599{
1600 int cnt;
1601 struct dquot __rcu **dquots = i_dquot(inode);
1602 struct dquot *put[MAXQUOTAS];
1603
1604 spin_lock(lock: &dq_data_lock);
1605 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1606 put[cnt] = srcu_dereference_check(dquots[cnt], &dquot_srcu,
1607 lockdep_is_held(&dq_data_lock));
1608 rcu_assign_pointer(dquots[cnt], NULL);
1609 }
1610 spin_unlock(lock: &dq_data_lock);
1611 dqput_all(dquot: put);
1612}
1613
1614void dquot_drop(struct inode *inode)
1615{
1616 struct dquot __rcu * const *dquots;
1617 int cnt;
1618
1619 if (IS_NOQUOTA(inode))
1620 return;
1621
1622 /*
1623 * Test before calling to rule out calls from proc and such
1624 * where we are not allowed to block. Note that this is
1625 * actually reliable test even without the lock - the caller
1626 * must assure that nobody can come after the DQUOT_DROP and
1627 * add quota pointers back anyway.
1628 */
1629 dquots = i_dquot(inode);
1630 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1631 if (dquots[cnt])
1632 break;
1633 }
1634
1635 if (cnt < MAXQUOTAS)
1636 __dquot_drop(inode);
1637}
1638EXPORT_SYMBOL(dquot_drop);
1639
1640/*
1641 * inode_reserved_space is managed internally by quota, and protected by
1642 * i_lock similar to i_blocks+i_bytes.
1643 */
1644static qsize_t *inode_reserved_space(struct inode * inode)
1645{
1646 /* Filesystem must explicitly define it's own method in order to use
1647 * quota reservation interface */
1648 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1649 return inode->i_sb->dq_op->get_reserved_space(inode);
1650}
1651
1652static qsize_t __inode_get_rsv_space(struct inode *inode)
1653{
1654 if (!inode->i_sb->dq_op->get_reserved_space)
1655 return 0;
1656 return *inode_reserved_space(inode);
1657}
1658
1659static qsize_t inode_get_rsv_space(struct inode *inode)
1660{
1661 qsize_t ret;
1662
1663 if (!inode->i_sb->dq_op->get_reserved_space)
1664 return 0;
1665 spin_lock(lock: &inode->i_lock);
1666 ret = __inode_get_rsv_space(inode);
1667 spin_unlock(lock: &inode->i_lock);
1668 return ret;
1669}
1670
1671/*
1672 * This functions updates i_blocks+i_bytes fields and quota information
1673 * (together with appropriate checks).
1674 *
1675 * NOTE: We absolutely rely on the fact that caller dirties the inode
1676 * (usually helpers in quotaops.h care about this) and holds a handle for
1677 * the current transaction so that dquot write and inode write go into the
1678 * same transaction.
1679 */
1680
1681/*
1682 * This operation can block, but only after everything is updated
1683 */
1684int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
1685{
1686 int cnt, ret = 0, index;
1687 struct dquot_warn warn[MAXQUOTAS];
1688 int reserve = flags & DQUOT_SPACE_RESERVE;
1689 struct dquot __rcu **dquots;
1690 struct dquot *dquot;
1691
1692 if (!inode_quota_active(inode)) {
1693 if (reserve) {
1694 spin_lock(lock: &inode->i_lock);
1695 *inode_reserved_space(inode) += number;
1696 spin_unlock(lock: &inode->i_lock);
1697 } else {
1698 inode_add_bytes(inode, bytes: number);
1699 }
1700 goto out;
1701 }
1702
1703 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1704 warn[cnt].w_type = QUOTA_NL_NOWARN;
1705
1706 dquots = i_dquot(inode);
1707 index = srcu_read_lock(ssp: &dquot_srcu);
1708 spin_lock(lock: &inode->i_lock);
1709 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1710 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1711 if (!dquot)
1712 continue;
1713 if (reserve) {
1714 ret = dquot_add_space(dquot, space: 0, rsv_space: number, flags, warn: &warn[cnt]);
1715 } else {
1716 ret = dquot_add_space(dquot, space: number, rsv_space: 0, flags, warn: &warn[cnt]);
1717 }
1718 if (ret) {
1719 /* Back out changes we already did */
1720 for (cnt--; cnt >= 0; cnt--) {
1721 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1722 if (!dquot)
1723 continue;
1724 spin_lock(lock: &dquot->dq_dqb_lock);
1725 if (reserve)
1726 dquot_free_reserved_space(dquot, number);
1727 else
1728 dquot_decr_space(dquot, number);
1729 spin_unlock(lock: &dquot->dq_dqb_lock);
1730 }
1731 spin_unlock(lock: &inode->i_lock);
1732 goto out_flush_warn;
1733 }
1734 }
1735 if (reserve)
1736 *inode_reserved_space(inode) += number;
1737 else
1738 __inode_add_bytes(inode, bytes: number);
1739 spin_unlock(lock: &inode->i_lock);
1740
1741 if (reserve)
1742 goto out_flush_warn;
1743 ret = mark_all_dquot_dirty(dquots);
1744out_flush_warn:
1745 srcu_read_unlock(ssp: &dquot_srcu, idx: index);
1746 flush_warnings(warn);
1747out:
1748 return ret;
1749}
1750EXPORT_SYMBOL(__dquot_alloc_space);
1751
1752/*
1753 * This operation can block, but only after everything is updated
1754 */
1755int dquot_alloc_inode(struct inode *inode)
1756{
1757 int cnt, ret = 0, index;
1758 struct dquot_warn warn[MAXQUOTAS];
1759 struct dquot __rcu * const *dquots;
1760 struct dquot *dquot;
1761
1762 if (!inode_quota_active(inode))
1763 return 0;
1764 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1765 warn[cnt].w_type = QUOTA_NL_NOWARN;
1766
1767 dquots = i_dquot(inode);
1768 index = srcu_read_lock(ssp: &dquot_srcu);
1769 spin_lock(lock: &inode->i_lock);
1770 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1771 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1772 if (!dquot)
1773 continue;
1774 ret = dquot_add_inodes(dquot, inodes: 1, warn: &warn[cnt]);
1775 if (ret) {
1776 for (cnt--; cnt >= 0; cnt--) {
1777 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1778 if (!dquot)
1779 continue;
1780 /* Back out changes we already did */
1781 spin_lock(lock: &dquot->dq_dqb_lock);
1782 dquot_decr_inodes(dquot, number: 1);
1783 spin_unlock(lock: &dquot->dq_dqb_lock);
1784 }
1785 goto warn_put_all;
1786 }
1787 }
1788
1789warn_put_all:
1790 spin_unlock(lock: &inode->i_lock);
1791 if (ret == 0)
1792 ret = mark_all_dquot_dirty(dquots);
1793 srcu_read_unlock(ssp: &dquot_srcu, idx: index);
1794 flush_warnings(warn);
1795 return ret;
1796}
1797EXPORT_SYMBOL(dquot_alloc_inode);
1798
1799/*
1800 * Convert in-memory reserved quotas to real consumed quotas
1801 */
1802void dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1803{
1804 struct dquot __rcu **dquots;
1805 struct dquot *dquot;
1806 int cnt, index;
1807
1808 if (!inode_quota_active(inode)) {
1809 spin_lock(lock: &inode->i_lock);
1810 *inode_reserved_space(inode) -= number;
1811 __inode_add_bytes(inode, bytes: number);
1812 spin_unlock(lock: &inode->i_lock);
1813 return;
1814 }
1815
1816 dquots = i_dquot(inode);
1817 index = srcu_read_lock(ssp: &dquot_srcu);
1818 spin_lock(lock: &inode->i_lock);
1819 /* Claim reserved quotas to allocated quotas */
1820 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1821 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1822 if (dquot) {
1823 spin_lock(lock: &dquot->dq_dqb_lock);
1824 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_rsvspace < number))
1825 number = dquot->dq_dqb.dqb_rsvspace;
1826 dquot->dq_dqb.dqb_curspace += number;
1827 dquot->dq_dqb.dqb_rsvspace -= number;
1828 spin_unlock(lock: &dquot->dq_dqb_lock);
1829 }
1830 }
1831 /* Update inode bytes */
1832 *inode_reserved_space(inode) -= number;
1833 __inode_add_bytes(inode, bytes: number);
1834 spin_unlock(lock: &inode->i_lock);
1835 mark_all_dquot_dirty(dquots);
1836 srcu_read_unlock(ssp: &dquot_srcu, idx: index);
1837}
1838EXPORT_SYMBOL(dquot_claim_space_nodirty);
1839
1840/*
1841 * Convert allocated space back to in-memory reserved quotas
1842 */
1843void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
1844{
1845 struct dquot __rcu **dquots;
1846 struct dquot *dquot;
1847 int cnt, index;
1848
1849 if (!inode_quota_active(inode)) {
1850 spin_lock(lock: &inode->i_lock);
1851 *inode_reserved_space(inode) += number;
1852 __inode_sub_bytes(inode, bytes: number);
1853 spin_unlock(lock: &inode->i_lock);
1854 return;
1855 }
1856
1857 dquots = i_dquot(inode);
1858 index = srcu_read_lock(ssp: &dquot_srcu);
1859 spin_lock(lock: &inode->i_lock);
1860 /* Claim reserved quotas to allocated quotas */
1861 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1862 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1863 if (dquot) {
1864 spin_lock(lock: &dquot->dq_dqb_lock);
1865 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
1866 number = dquot->dq_dqb.dqb_curspace;
1867 dquot->dq_dqb.dqb_rsvspace += number;
1868 dquot->dq_dqb.dqb_curspace -= number;
1869 spin_unlock(lock: &dquot->dq_dqb_lock);
1870 }
1871 }
1872 /* Update inode bytes */
1873 *inode_reserved_space(inode) += number;
1874 __inode_sub_bytes(inode, bytes: number);
1875 spin_unlock(lock: &inode->i_lock);
1876 mark_all_dquot_dirty(dquots);
1877 srcu_read_unlock(ssp: &dquot_srcu, idx: index);
1878}
1879EXPORT_SYMBOL(dquot_reclaim_space_nodirty);
1880
1881/*
1882 * This operation can block, but only after everything is updated
1883 */
1884void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
1885{
1886 unsigned int cnt;
1887 struct dquot_warn warn[MAXQUOTAS];
1888 struct dquot __rcu **dquots;
1889 struct dquot *dquot;
1890 int reserve = flags & DQUOT_SPACE_RESERVE, index;
1891
1892 if (!inode_quota_active(inode)) {
1893 if (reserve) {
1894 spin_lock(lock: &inode->i_lock);
1895 *inode_reserved_space(inode) -= number;
1896 spin_unlock(lock: &inode->i_lock);
1897 } else {
1898 inode_sub_bytes(inode, bytes: number);
1899 }
1900 return;
1901 }
1902
1903 dquots = i_dquot(inode);
1904 index = srcu_read_lock(ssp: &dquot_srcu);
1905 spin_lock(lock: &inode->i_lock);
1906 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1907 int wtype;
1908
1909 warn[cnt].w_type = QUOTA_NL_NOWARN;
1910 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1911 if (!dquot)
1912 continue;
1913 spin_lock(lock: &dquot->dq_dqb_lock);
1914 wtype = info_bdq_free(dquot, space: number);
1915 if (wtype != QUOTA_NL_NOWARN)
1916 prepare_warning(warn: &warn[cnt], dquot, warntype: wtype);
1917 if (reserve)
1918 dquot_free_reserved_space(dquot, number);
1919 else
1920 dquot_decr_space(dquot, number);
1921 spin_unlock(lock: &dquot->dq_dqb_lock);
1922 }
1923 if (reserve)
1924 *inode_reserved_space(inode) -= number;
1925 else
1926 __inode_sub_bytes(inode, bytes: number);
1927 spin_unlock(lock: &inode->i_lock);
1928
1929 if (reserve)
1930 goto out_unlock;
1931 mark_all_dquot_dirty(dquots);
1932out_unlock:
1933 srcu_read_unlock(ssp: &dquot_srcu, idx: index);
1934 flush_warnings(warn);
1935}
1936EXPORT_SYMBOL(__dquot_free_space);
1937
1938/*
1939 * This operation can block, but only after everything is updated
1940 */
1941void dquot_free_inode(struct inode *inode)
1942{
1943 unsigned int cnt;
1944 struct dquot_warn warn[MAXQUOTAS];
1945 struct dquot __rcu * const *dquots;
1946 struct dquot *dquot;
1947 int index;
1948
1949 if (!inode_quota_active(inode))
1950 return;
1951
1952 dquots = i_dquot(inode);
1953 index = srcu_read_lock(ssp: &dquot_srcu);
1954 spin_lock(lock: &inode->i_lock);
1955 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1956 int wtype;
1957 warn[cnt].w_type = QUOTA_NL_NOWARN;
1958 dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
1959 if (!dquot)
1960 continue;
1961 spin_lock(lock: &dquot->dq_dqb_lock);
1962 wtype = info_idq_free(dquot, inodes: 1);
1963 if (wtype != QUOTA_NL_NOWARN)
1964 prepare_warning(warn: &warn[cnt], dquot, warntype: wtype);
1965 dquot_decr_inodes(dquot, number: 1);
1966 spin_unlock(lock: &dquot->dq_dqb_lock);
1967 }
1968 spin_unlock(lock: &inode->i_lock);
1969 mark_all_dquot_dirty(dquots);
1970 srcu_read_unlock(ssp: &dquot_srcu, idx: index);
1971 flush_warnings(warn);
1972}
1973EXPORT_SYMBOL(dquot_free_inode);
1974
1975/*
1976 * Transfer the number of inode and blocks from one diskquota to an other.
1977 * On success, dquot references in transfer_to are consumed and references
1978 * to original dquots that need to be released are placed there. On failure,
1979 * references are kept untouched.
1980 *
1981 * This operation can block, but only after everything is updated
1982 * A transaction must be started when entering this function.
1983 *
1984 * We are holding reference on transfer_from & transfer_to, no need to
1985 * protect them by srcu_read_lock().
1986 */
1987int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
1988{
1989 qsize_t cur_space;
1990 qsize_t rsv_space = 0;
1991 qsize_t inode_usage = 1;
1992 struct dquot __rcu **dquots;
1993 struct dquot *transfer_from[MAXQUOTAS] = {};
1994 int cnt, index, ret = 0, err;
1995 char is_valid[MAXQUOTAS] = {};
1996 struct dquot_warn warn_to[MAXQUOTAS];
1997 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1998 struct dquot_warn warn_from_space[MAXQUOTAS];
1999
2000 if (IS_NOQUOTA(inode))
2001 return 0;
2002
2003 if (inode->i_sb->dq_op->get_inode_usage) {
2004 ret = inode->i_sb->dq_op->get_inode_usage(inode, &inode_usage);
2005 if (ret)
2006 return ret;
2007 }
2008
2009 /* Initialize the arrays */
2010 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2011 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
2012 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
2013 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
2014 }
2015
2016 spin_lock(lock: &dq_data_lock);
2017 spin_lock(lock: &inode->i_lock);
2018 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
2019 spin_unlock(lock: &inode->i_lock);
2020 spin_unlock(lock: &dq_data_lock);
2021 return 0;
2022 }
2023 cur_space = __inode_get_bytes(inode);
2024 rsv_space = __inode_get_rsv_space(inode);
2025 dquots = i_dquot(inode);
2026 /*
2027 * Build the transfer_from list, check limits, and update usage in
2028 * the target structures.
2029 */
2030 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2031 /*
2032 * Skip changes for same uid or gid or for turned off quota-type.
2033 */
2034 if (!transfer_to[cnt])
2035 continue;
2036 /* Avoid races with quotaoff() */
2037 if (!sb_has_quota_active(sb: inode->i_sb, type: cnt))
2038 continue;
2039 is_valid[cnt] = 1;
2040 transfer_from[cnt] = srcu_dereference_check(dquots[cnt],
2041 &dquot_srcu, lockdep_is_held(&dq_data_lock));
2042 ret = dquot_add_inodes(dquot: transfer_to[cnt], inodes: inode_usage,
2043 warn: &warn_to[cnt]);
2044 if (ret)
2045 goto over_quota;
2046 ret = dquot_add_space(dquot: transfer_to[cnt], space: cur_space, rsv_space,
2047 DQUOT_SPACE_WARN, warn: &warn_to[cnt]);
2048 if (ret) {
2049 spin_lock(lock: &transfer_to[cnt]->dq_dqb_lock);
2050 dquot_decr_inodes(dquot: transfer_to[cnt], number: inode_usage);
2051 spin_unlock(lock: &transfer_to[cnt]->dq_dqb_lock);
2052 goto over_quota;
2053 }
2054 }
2055
2056 /* Decrease usage for source structures and update quota pointers */
2057 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2058 if (!is_valid[cnt])
2059 continue;
2060 /* Due to IO error we might not have transfer_from[] structure */
2061 if (transfer_from[cnt]) {
2062 int wtype;
2063
2064 spin_lock(lock: &transfer_from[cnt]->dq_dqb_lock);
2065 wtype = info_idq_free(dquot: transfer_from[cnt], inodes: inode_usage);
2066 if (wtype != QUOTA_NL_NOWARN)
2067 prepare_warning(warn: &warn_from_inodes[cnt],
2068 dquot: transfer_from[cnt], warntype: wtype);
2069 wtype = info_bdq_free(dquot: transfer_from[cnt],
2070 space: cur_space + rsv_space);
2071 if (wtype != QUOTA_NL_NOWARN)
2072 prepare_warning(warn: &warn_from_space[cnt],
2073 dquot: transfer_from[cnt], warntype: wtype);
2074 dquot_decr_inodes(dquot: transfer_from[cnt], number: inode_usage);
2075 dquot_decr_space(dquot: transfer_from[cnt], number: cur_space);
2076 dquot_free_reserved_space(dquot: transfer_from[cnt],
2077 number: rsv_space);
2078 spin_unlock(lock: &transfer_from[cnt]->dq_dqb_lock);
2079 }
2080 rcu_assign_pointer(dquots[cnt], transfer_to[cnt]);
2081 }
2082 spin_unlock(lock: &inode->i_lock);
2083 spin_unlock(lock: &dq_data_lock);
2084
2085 /*
2086 * These arrays are local and we hold dquot references so we don't need
2087 * the srcu protection but still take dquot_srcu to avoid warning in
2088 * mark_all_dquot_dirty().
2089 */
2090 index = srcu_read_lock(ssp: &dquot_srcu);
2091 err = mark_all_dquot_dirty(dquots: (struct dquot __rcu **)transfer_from);
2092 if (err < 0)
2093 ret = err;
2094 err = mark_all_dquot_dirty(dquots: (struct dquot __rcu **)transfer_to);
2095 if (err < 0)
2096 ret = err;
2097 srcu_read_unlock(ssp: &dquot_srcu, idx: index);
2098
2099 flush_warnings(warn: warn_to);
2100 flush_warnings(warn: warn_from_inodes);
2101 flush_warnings(warn: warn_from_space);
2102 /* Pass back references to put */
2103 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2104 if (is_valid[cnt])
2105 transfer_to[cnt] = transfer_from[cnt];
2106 return ret;
2107over_quota:
2108 /* Back out changes we already did */
2109 for (cnt--; cnt >= 0; cnt--) {
2110 if (!is_valid[cnt])
2111 continue;
2112 spin_lock(lock: &transfer_to[cnt]->dq_dqb_lock);
2113 dquot_decr_inodes(dquot: transfer_to[cnt], number: inode_usage);
2114 dquot_decr_space(dquot: transfer_to[cnt], number: cur_space);
2115 dquot_free_reserved_space(dquot: transfer_to[cnt], number: rsv_space);
2116 spin_unlock(lock: &transfer_to[cnt]->dq_dqb_lock);
2117 }
2118 spin_unlock(lock: &inode->i_lock);
2119 spin_unlock(lock: &dq_data_lock);
2120 flush_warnings(warn: warn_to);
2121 return ret;
2122}
2123EXPORT_SYMBOL(__dquot_transfer);
2124
2125/* Wrapper for transferring ownership of an inode for uid/gid only
2126 * Called from FSXXX_setattr()
2127 */
2128int dquot_transfer(struct mnt_idmap *idmap, struct inode *inode,
2129 struct iattr *iattr)
2130{
2131 struct dquot *transfer_to[MAXQUOTAS] = {};
2132 struct dquot *dquot;
2133 struct super_block *sb = inode->i_sb;
2134 int ret;
2135
2136 if (!inode_quota_active(inode))
2137 return 0;
2138
2139 if (i_uid_needs_update(idmap, attr: iattr, inode)) {
2140 kuid_t kuid = from_vfsuid(idmap, fs_userns: i_user_ns(inode),
2141 vfsuid: iattr->ia_vfsuid);
2142
2143 dquot = dqget(sb, make_kqid_uid(uid: kuid));
2144 if (IS_ERR(ptr: dquot)) {
2145 if (PTR_ERR(ptr: dquot) != -ESRCH) {
2146 ret = PTR_ERR(ptr: dquot);
2147 goto out_put;
2148 }
2149 dquot = NULL;
2150 }
2151 transfer_to[USRQUOTA] = dquot;
2152 }
2153 if (i_gid_needs_update(idmap, attr: iattr, inode)) {
2154 kgid_t kgid = from_vfsgid(idmap, fs_userns: i_user_ns(inode),
2155 vfsgid: iattr->ia_vfsgid);
2156
2157 dquot = dqget(sb, make_kqid_gid(gid: kgid));
2158 if (IS_ERR(ptr: dquot)) {
2159 if (PTR_ERR(ptr: dquot) != -ESRCH) {
2160 ret = PTR_ERR(ptr: dquot);
2161 goto out_put;
2162 }
2163 dquot = NULL;
2164 }
2165 transfer_to[GRPQUOTA] = dquot;
2166 }
2167 ret = __dquot_transfer(inode, transfer_to);
2168out_put:
2169 dqput_all(dquot: transfer_to);
2170 return ret;
2171}
2172EXPORT_SYMBOL(dquot_transfer);
2173
2174/*
2175 * Write info of quota file to disk
2176 */
2177int dquot_commit_info(struct super_block *sb, int type)
2178{
2179 struct quota_info *dqopt = sb_dqopt(sb);
2180
2181 return dqopt->ops[type]->write_file_info(sb, type);
2182}
2183EXPORT_SYMBOL(dquot_commit_info);
2184
2185int dquot_get_next_id(struct super_block *sb, struct kqid *qid)
2186{
2187 struct quota_info *dqopt = sb_dqopt(sb);
2188
2189 if (!sb_has_quota_active(sb, type: qid->type))
2190 return -ESRCH;
2191 if (!dqopt->ops[qid->type]->get_next_id)
2192 return -ENOSYS;
2193 return dqopt->ops[qid->type]->get_next_id(sb, qid);
2194}
2195EXPORT_SYMBOL(dquot_get_next_id);
2196
2197/*
2198 * Definitions of diskquota operations.
2199 */
2200const struct dquot_operations dquot_operations = {
2201 .write_dquot = dquot_commit,
2202 .acquire_dquot = dquot_acquire,
2203 .release_dquot = dquot_release,
2204 .mark_dirty = dquot_mark_dquot_dirty,
2205 .write_info = dquot_commit_info,
2206 .alloc_dquot = dquot_alloc,
2207 .destroy_dquot = dquot_destroy,
2208 .get_next_id = dquot_get_next_id,
2209};
2210EXPORT_SYMBOL(dquot_operations);
2211
2212/*
2213 * Generic helper for ->open on filesystems supporting disk quotas.
2214 */
2215int dquot_file_open(struct inode *inode, struct file *file)
2216{
2217 int error;
2218
2219 error = generic_file_open(inode, filp: file);
2220 if (!error && (file->f_mode & FMODE_WRITE))
2221 error = dquot_initialize(inode);
2222 return error;
2223}
2224EXPORT_SYMBOL(dquot_file_open);
2225
2226static void vfs_cleanup_quota_inode(struct super_block *sb, int type)
2227{
2228 struct quota_info *dqopt = sb_dqopt(sb);
2229 struct inode *inode = dqopt->files[type];
2230
2231 if (!inode)
2232 return;
2233 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2234 inode_lock(inode);
2235 inode->i_flags &= ~S_NOQUOTA;
2236 inode_unlock(inode);
2237 }
2238 dqopt->files[type] = NULL;
2239 iput(inode);
2240}
2241
2242/*
2243 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
2244 */
2245int dquot_disable(struct super_block *sb, int type, unsigned int flags)
2246{
2247 int cnt;
2248 struct quota_info *dqopt = sb_dqopt(sb);
2249
2250 rwsem_assert_held_write(sem: &sb->s_umount);
2251
2252 /* Cannot turn off usage accounting without turning off limits, or
2253 * suspend quotas and simultaneously turn quotas off. */
2254 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
2255 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
2256 DQUOT_USAGE_ENABLED)))
2257 return -EINVAL;
2258
2259 /*
2260 * Skip everything if there's nothing to do. We have to do this because
2261 * sometimes we are called when fill_super() failed and calling
2262 * sync_fs() in such cases does no good.
2263 */
2264 if (!sb_any_quota_loaded(sb))
2265 return 0;
2266
2267 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2268 if (type != -1 && cnt != type)
2269 continue;
2270 if (!sb_has_quota_loaded(sb, type: cnt))
2271 continue;
2272
2273 if (flags & DQUOT_SUSPENDED) {
2274 spin_lock(lock: &dq_state_lock);
2275 dqopt->flags |=
2276 dquot_state_flag(DQUOT_SUSPENDED, type: cnt);
2277 spin_unlock(lock: &dq_state_lock);
2278 } else {
2279 spin_lock(lock: &dq_state_lock);
2280 dqopt->flags &= ~dquot_state_flag(flags, type: cnt);
2281 /* Turning off suspended quotas? */
2282 if (!sb_has_quota_loaded(sb, type: cnt) &&
2283 sb_has_quota_suspended(sb, type: cnt)) {
2284 dqopt->flags &= ~dquot_state_flag(
2285 DQUOT_SUSPENDED, type: cnt);
2286 spin_unlock(lock: &dq_state_lock);
2287 vfs_cleanup_quota_inode(sb, type: cnt);
2288 continue;
2289 }
2290 spin_unlock(lock: &dq_state_lock);
2291 }
2292
2293 /* We still have to keep quota loaded? */
2294 if (sb_has_quota_loaded(sb, type: cnt) && !(flags & DQUOT_SUSPENDED))
2295 continue;
2296
2297 /* Note: these are blocking operations */
2298 drop_dquot_ref(sb, type: cnt);
2299 invalidate_dquots(sb, type: cnt);
2300 /*
2301 * Now all dquots should be invalidated, all writes done so we
2302 * should be only users of the info. No locks needed.
2303 */
2304 if (info_dirty(info: &dqopt->info[cnt]))
2305 sb->dq_op->write_info(sb, cnt);
2306 if (dqopt->ops[cnt]->free_file_info)
2307 dqopt->ops[cnt]->free_file_info(sb, cnt);
2308 put_quota_format(fmt: dqopt->info[cnt].dqi_format);
2309 dqopt->info[cnt].dqi_flags = 0;
2310 dqopt->info[cnt].dqi_igrace = 0;
2311 dqopt->info[cnt].dqi_bgrace = 0;
2312 dqopt->ops[cnt] = NULL;
2313 }
2314
2315 /* Skip syncing and setting flags if quota files are hidden */
2316 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2317 goto put_inodes;
2318
2319 /* Sync the superblock so that buffers with quota data are written to
2320 * disk (and so userspace sees correct data afterwards). */
2321 if (sb->s_op->sync_fs)
2322 sb->s_op->sync_fs(sb, 1);
2323 sync_blockdev(bdev: sb->s_bdev);
2324 /* Now the quota files are just ordinary files and we can set the
2325 * inode flags back. Moreover we discard the pagecache so that
2326 * userspace sees the writes we did bypassing the pagecache. We
2327 * must also discard the blockdev buffers so that we see the
2328 * changes done by userspace on the next quotaon() */
2329 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2330 if (!sb_has_quota_loaded(sb, type: cnt) && dqopt->files[cnt]) {
2331 inode_lock(inode: dqopt->files[cnt]);
2332 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
2333 inode_unlock(inode: dqopt->files[cnt]);
2334 }
2335 if (sb->s_bdev)
2336 invalidate_bdev(bdev: sb->s_bdev);
2337put_inodes:
2338 /* We are done when suspending quotas */
2339 if (flags & DQUOT_SUSPENDED)
2340 return 0;
2341
2342 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2343 if (!sb_has_quota_loaded(sb, type: cnt))
2344 vfs_cleanup_quota_inode(sb, type: cnt);
2345 return 0;
2346}
2347EXPORT_SYMBOL(dquot_disable);
2348
2349int dquot_quota_off(struct super_block *sb, int type)
2350{
2351 return dquot_disable(sb, type,
2352 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2353}
2354EXPORT_SYMBOL(dquot_quota_off);
2355
2356/*
2357 * Turn quotas on on a device
2358 */
2359
2360static int vfs_setup_quota_inode(struct inode *inode, int type)
2361{
2362 struct super_block *sb = inode->i_sb;
2363 struct quota_info *dqopt = sb_dqopt(sb);
2364
2365 if (is_bad_inode(inode))
2366 return -EUCLEAN;
2367 if (!S_ISREG(inode->i_mode))
2368 return -EACCES;
2369 if (IS_RDONLY(inode))
2370 return -EROFS;
2371 if (sb_has_quota_loaded(sb, type))
2372 return -EBUSY;
2373
2374 /*
2375 * Quota files should never be encrypted. They should be thought of as
2376 * filesystem metadata, not user data. New-style internal quota files
2377 * cannot be encrypted by users anyway, but old-style external quota
2378 * files could potentially be incorrectly created in an encrypted
2379 * directory, hence this explicit check. Some reasons why encrypted
2380 * quota files don't work include: (1) some filesystems that support
2381 * encryption don't handle it in their quota_read and quota_write, and
2382 * (2) cleaning up encrypted quota files at unmount would need special
2383 * consideration, as quota files are cleaned up later than user files.
2384 */
2385 if (IS_ENCRYPTED(inode))
2386 return -EINVAL;
2387
2388 dqopt->files[type] = igrab(inode);
2389 if (!dqopt->files[type])
2390 return -EIO;
2391 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2392 /* We don't want quota and atime on quota files (deadlocks
2393 * possible) Also nobody should write to the file - we use
2394 * special IO operations which ignore the immutable bit. */
2395 inode_lock(inode);
2396 inode->i_flags |= S_NOQUOTA;
2397 inode_unlock(inode);
2398 /*
2399 * When S_NOQUOTA is set, remove dquot references as no more
2400 * references can be added
2401 */
2402 __dquot_drop(inode);
2403 }
2404 return 0;
2405}
2406
2407int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
2408 unsigned int flags)
2409{
2410 struct quota_format_type *fmt;
2411 struct quota_info *dqopt = sb_dqopt(sb);
2412 int error;
2413
2414 lockdep_assert_held_write(&sb->s_umount);
2415
2416 /* Just unsuspend quotas? */
2417 if (WARN_ON_ONCE(flags & DQUOT_SUSPENDED))
2418 return -EINVAL;
2419
2420 fmt = find_quota_format(id: format_id);
2421 if (!fmt)
2422 return -ESRCH;
2423 if (!sb->dq_op || !sb->s_qcop ||
2424 (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) {
2425 error = -EINVAL;
2426 goto out_fmt;
2427 }
2428 /* Filesystems outside of init_user_ns not yet supported */
2429 if (sb->s_user_ns != &init_user_ns) {
2430 error = -EINVAL;
2431 goto out_fmt;
2432 }
2433 /* Usage always has to be set... */
2434 if (!(flags & DQUOT_USAGE_ENABLED)) {
2435 error = -EINVAL;
2436 goto out_fmt;
2437 }
2438 if (sb_has_quota_loaded(sb, type)) {
2439 error = -EBUSY;
2440 goto out_fmt;
2441 }
2442
2443 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2444 /* As we bypass the pagecache we must now flush all the
2445 * dirty data and invalidate caches so that kernel sees
2446 * changes from userspace. It is not enough to just flush
2447 * the quota file since if blocksize < pagesize, invalidation
2448 * of the cache could fail because of other unrelated dirty
2449 * data */
2450 sync_filesystem(sb);
2451 invalidate_bdev(bdev: sb->s_bdev);
2452 }
2453
2454 error = -EINVAL;
2455 if (!fmt->qf_ops->check_quota_file(sb, type))
2456 goto out_fmt;
2457
2458 dqopt->ops[type] = fmt->qf_ops;
2459 dqopt->info[type].dqi_format = fmt;
2460 dqopt->info[type].dqi_fmt_id = format_id;
2461 INIT_LIST_HEAD(list: &dqopt->info[type].dqi_dirty_list);
2462 error = dqopt->ops[type]->read_file_info(sb, type);
2463 if (error < 0)
2464 goto out_fmt;
2465 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) {
2466 spin_lock(lock: &dq_data_lock);
2467 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
2468 spin_unlock(lock: &dq_data_lock);
2469 }
2470 spin_lock(lock: &dq_state_lock);
2471 dqopt->flags |= dquot_state_flag(flags, type);
2472 spin_unlock(lock: &dq_state_lock);
2473
2474 error = add_dquot_ref(sb, type);
2475 if (error)
2476 dquot_disable(sb, type,
2477 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2478
2479 return error;
2480out_fmt:
2481 put_quota_format(fmt);
2482
2483 return error;
2484}
2485EXPORT_SYMBOL(dquot_load_quota_sb);
2486
2487/*
2488 * More powerful function for turning on quotas on given quota inode allowing
2489 * setting of individual quota flags
2490 */
2491int dquot_load_quota_inode(struct inode *inode, int type, int format_id,
2492 unsigned int flags)
2493{
2494 int err;
2495
2496 err = vfs_setup_quota_inode(inode, type);
2497 if (err < 0)
2498 return err;
2499 err = dquot_load_quota_sb(inode->i_sb, type, format_id, flags);
2500 if (err < 0)
2501 vfs_cleanup_quota_inode(sb: inode->i_sb, type);
2502 return err;
2503}
2504EXPORT_SYMBOL(dquot_load_quota_inode);
2505
2506/* Reenable quotas on remount RW */
2507int dquot_resume(struct super_block *sb, int type)
2508{
2509 struct quota_info *dqopt = sb_dqopt(sb);
2510 int ret = 0, cnt;
2511 unsigned int flags;
2512
2513 rwsem_assert_held_write(sem: &sb->s_umount);
2514
2515 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2516 if (type != -1 && cnt != type)
2517 continue;
2518 if (!sb_has_quota_suspended(sb, type: cnt))
2519 continue;
2520
2521 spin_lock(lock: &dq_state_lock);
2522 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2523 DQUOT_LIMITS_ENABLED,
2524 type: cnt);
2525 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, type: cnt);
2526 spin_unlock(lock: &dq_state_lock);
2527
2528 flags = dquot_generic_flag(flags, type: cnt);
2529 ret = dquot_load_quota_sb(sb, cnt, dqopt->info[cnt].dqi_fmt_id,
2530 flags);
2531 if (ret < 0)
2532 vfs_cleanup_quota_inode(sb, type: cnt);
2533 }
2534
2535 return ret;
2536}
2537EXPORT_SYMBOL(dquot_resume);
2538
2539int dquot_quota_on(struct super_block *sb, int type, int format_id,
2540 const struct path *path)
2541{
2542 int error = security_quota_on(dentry: path->dentry);
2543 if (error)
2544 return error;
2545 /* Quota file not on the same filesystem? */
2546 if (path->dentry->d_sb != sb)
2547 error = -EXDEV;
2548 else
2549 error = dquot_load_quota_inode(d_inode(dentry: path->dentry), type,
2550 format_id, DQUOT_USAGE_ENABLED |
2551 DQUOT_LIMITS_ENABLED);
2552 return error;
2553}
2554EXPORT_SYMBOL(dquot_quota_on);
2555
2556/*
2557 * This function is used when filesystem needs to initialize quotas
2558 * during mount time.
2559 */
2560int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
2561 int format_id, int type)
2562{
2563 struct dentry *dentry;
2564 int error;
2565
2566 dentry = lookup_noperm_positive_unlocked(&QSTR(qf_name), sb->s_root);
2567 if (IS_ERR(ptr: dentry))
2568 return PTR_ERR(ptr: dentry);
2569
2570 error = security_quota_on(dentry);
2571 if (!error)
2572 error = dquot_load_quota_inode(d_inode(dentry), type, format_id,
2573 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2574
2575 dput(dentry);
2576 return error;
2577}
2578EXPORT_SYMBOL(dquot_quota_on_mount);
2579
2580static int dquot_quota_enable(struct super_block *sb, unsigned int flags)
2581{
2582 int ret;
2583 int type;
2584 struct quota_info *dqopt = sb_dqopt(sb);
2585
2586 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
2587 return -ENOSYS;
2588 /* Accounting cannot be turned on while fs is mounted */
2589 flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT);
2590 if (!flags)
2591 return -EINVAL;
2592 for (type = 0; type < MAXQUOTAS; type++) {
2593 if (!(flags & qtype_enforce_flag(type)))
2594 continue;
2595 /* Can't enforce without accounting */
2596 if (!sb_has_quota_usage_enabled(sb, type)) {
2597 ret = -EINVAL;
2598 goto out_err;
2599 }
2600 if (sb_has_quota_limits_enabled(sb, type)) {
2601 /* compatible with XFS */
2602 ret = -EEXIST;
2603 goto out_err;
2604 }
2605 spin_lock(lock: &dq_state_lock);
2606 dqopt->flags |= dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
2607 spin_unlock(lock: &dq_state_lock);
2608 }
2609 return 0;
2610out_err:
2611 /* Backout enforcement enablement we already did */
2612 for (type--; type >= 0; type--) {
2613 if (flags & qtype_enforce_flag(type))
2614 dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
2615 }
2616 return ret;
2617}
2618
2619static int dquot_quota_disable(struct super_block *sb, unsigned int flags)
2620{
2621 int ret;
2622 int type;
2623 struct quota_info *dqopt = sb_dqopt(sb);
2624
2625 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
2626 return -ENOSYS;
2627 /*
2628 * We don't support turning off accounting via quotactl. In principle
2629 * quota infrastructure can do this but filesystems don't expect
2630 * userspace to be able to do it.
2631 */
2632 if (flags &
2633 (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT))
2634 return -EOPNOTSUPP;
2635
2636 /* Filter out limits not enabled */
2637 for (type = 0; type < MAXQUOTAS; type++)
2638 if (!sb_has_quota_limits_enabled(sb, type))
2639 flags &= ~qtype_enforce_flag(type);
2640 /* Nothing left? */
2641 if (!flags)
2642 return -EEXIST;
2643 for (type = 0; type < MAXQUOTAS; type++) {
2644 if (flags & qtype_enforce_flag(type)) {
2645 ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
2646 if (ret < 0)
2647 goto out_err;
2648 }
2649 }
2650 return 0;
2651out_err:
2652 /* Backout enforcement disabling we already did */
2653 for (type--; type >= 0; type--) {
2654 if (flags & qtype_enforce_flag(type)) {
2655 spin_lock(lock: &dq_state_lock);
2656 dqopt->flags |=
2657 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
2658 spin_unlock(lock: &dq_state_lock);
2659 }
2660 }
2661 return ret;
2662}
2663
2664/* Generic routine for getting common part of quota structure */
2665static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di)
2666{
2667 struct mem_dqblk *dm = &dquot->dq_dqb;
2668
2669 memset(s: di, c: 0, n: sizeof(*di));
2670 spin_lock(lock: &dquot->dq_dqb_lock);
2671 di->d_spc_hardlimit = dm->dqb_bhardlimit;
2672 di->d_spc_softlimit = dm->dqb_bsoftlimit;
2673 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2674 di->d_ino_softlimit = dm->dqb_isoftlimit;
2675 di->d_space = dm->dqb_curspace + dm->dqb_rsvspace;
2676 di->d_ino_count = dm->dqb_curinodes;
2677 di->d_spc_timer = dm->dqb_btime;
2678 di->d_ino_timer = dm->dqb_itime;
2679 spin_unlock(lock: &dquot->dq_dqb_lock);
2680}
2681
2682int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
2683 struct qc_dqblk *di)
2684{
2685 struct dquot *dquot;
2686
2687 dquot = dqget(sb, qid);
2688 if (IS_ERR(ptr: dquot))
2689 return PTR_ERR(ptr: dquot);
2690 do_get_dqblk(dquot, di);
2691 dqput(dquot);
2692
2693 return 0;
2694}
2695EXPORT_SYMBOL(dquot_get_dqblk);
2696
2697int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid,
2698 struct qc_dqblk *di)
2699{
2700 struct dquot *dquot;
2701 int err;
2702
2703 if (!sb->dq_op->get_next_id)
2704 return -ENOSYS;
2705 err = sb->dq_op->get_next_id(sb, qid);
2706 if (err < 0)
2707 return err;
2708 dquot = dqget(sb, *qid);
2709 if (IS_ERR(ptr: dquot))
2710 return PTR_ERR(ptr: dquot);
2711 do_get_dqblk(dquot, di);
2712 dqput(dquot);
2713
2714 return 0;
2715}
2716EXPORT_SYMBOL(dquot_get_next_dqblk);
2717
2718#define VFS_QC_MASK \
2719 (QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \
2720 QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \
2721 QC_SPC_TIMER | QC_INO_TIMER)
2722
2723/* Generic routine for setting common part of quota structure */
2724static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di)
2725{
2726 struct mem_dqblk *dm = &dquot->dq_dqb;
2727 int check_blim = 0, check_ilim = 0;
2728 struct mem_dqinfo *dqi = &sb_dqopt(sb: dquot->dq_sb)->info[dquot->dq_id.type];
2729 int ret;
2730
2731 if (di->d_fieldmask & ~VFS_QC_MASK)
2732 return -EINVAL;
2733
2734 if (((di->d_fieldmask & QC_SPC_SOFT) &&
2735 di->d_spc_softlimit > dqi->dqi_max_spc_limit) ||
2736 ((di->d_fieldmask & QC_SPC_HARD) &&
2737 di->d_spc_hardlimit > dqi->dqi_max_spc_limit) ||
2738 ((di->d_fieldmask & QC_INO_SOFT) &&
2739 (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) ||
2740 ((di->d_fieldmask & QC_INO_HARD) &&
2741 (di->d_ino_hardlimit > dqi->dqi_max_ino_limit)))
2742 return -ERANGE;
2743
2744 spin_lock(lock: &dquot->dq_dqb_lock);
2745 if (di->d_fieldmask & QC_SPACE) {
2746 dm->dqb_curspace = di->d_space - dm->dqb_rsvspace;
2747 check_blim = 1;
2748 set_bit(DQ_LASTSET_B + QIF_SPACE_B, addr: &dquot->dq_flags);
2749 }
2750
2751 if (di->d_fieldmask & QC_SPC_SOFT)
2752 dm->dqb_bsoftlimit = di->d_spc_softlimit;
2753 if (di->d_fieldmask & QC_SPC_HARD)
2754 dm->dqb_bhardlimit = di->d_spc_hardlimit;
2755 if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) {
2756 check_blim = 1;
2757 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, addr: &dquot->dq_flags);
2758 }
2759
2760 if (di->d_fieldmask & QC_INO_COUNT) {
2761 dm->dqb_curinodes = di->d_ino_count;
2762 check_ilim = 1;
2763 set_bit(DQ_LASTSET_B + QIF_INODES_B, addr: &dquot->dq_flags);
2764 }
2765
2766 if (di->d_fieldmask & QC_INO_SOFT)
2767 dm->dqb_isoftlimit = di->d_ino_softlimit;
2768 if (di->d_fieldmask & QC_INO_HARD)
2769 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2770 if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) {
2771 check_ilim = 1;
2772 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, addr: &dquot->dq_flags);
2773 }
2774
2775 if (di->d_fieldmask & QC_SPC_TIMER) {
2776 dm->dqb_btime = di->d_spc_timer;
2777 check_blim = 1;
2778 set_bit(DQ_LASTSET_B + QIF_BTIME_B, addr: &dquot->dq_flags);
2779 }
2780
2781 if (di->d_fieldmask & QC_INO_TIMER) {
2782 dm->dqb_itime = di->d_ino_timer;
2783 check_ilim = 1;
2784 set_bit(DQ_LASTSET_B + QIF_ITIME_B, addr: &dquot->dq_flags);
2785 }
2786
2787 if (check_blim) {
2788 if (!dm->dqb_bsoftlimit ||
2789 dm->dqb_curspace + dm->dqb_rsvspace <= dm->dqb_bsoftlimit) {
2790 dm->dqb_btime = 0;
2791 clear_bit(DQ_BLKS_B, addr: &dquot->dq_flags);
2792 } else if (!(di->d_fieldmask & QC_SPC_TIMER))
2793 /* Set grace only if user hasn't provided his own... */
2794 dm->dqb_btime = ktime_get_real_seconds() + dqi->dqi_bgrace;
2795 }
2796 if (check_ilim) {
2797 if (!dm->dqb_isoftlimit ||
2798 dm->dqb_curinodes <= dm->dqb_isoftlimit) {
2799 dm->dqb_itime = 0;
2800 clear_bit(DQ_INODES_B, addr: &dquot->dq_flags);
2801 } else if (!(di->d_fieldmask & QC_INO_TIMER))
2802 /* Set grace only if user hasn't provided his own... */
2803 dm->dqb_itime = ktime_get_real_seconds() + dqi->dqi_igrace;
2804 }
2805 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2806 dm->dqb_isoftlimit)
2807 clear_bit(DQ_FAKE_B, addr: &dquot->dq_flags);
2808 else
2809 set_bit(DQ_FAKE_B, addr: &dquot->dq_flags);
2810 spin_unlock(lock: &dquot->dq_dqb_lock);
2811 ret = mark_dquot_dirty(dquot);
2812 if (ret < 0)
2813 return ret;
2814 return 0;
2815}
2816
2817int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
2818 struct qc_dqblk *di)
2819{
2820 struct dquot *dquot;
2821 int rc;
2822
2823 dquot = dqget(sb, qid);
2824 if (IS_ERR(ptr: dquot)) {
2825 rc = PTR_ERR(ptr: dquot);
2826 goto out;
2827 }
2828 rc = do_set_dqblk(dquot, di);
2829 dqput(dquot);
2830out:
2831 return rc;
2832}
2833EXPORT_SYMBOL(dquot_set_dqblk);
2834
2835/* Generic routine for getting common part of quota file information */
2836int dquot_get_state(struct super_block *sb, struct qc_state *state)
2837{
2838 struct mem_dqinfo *mi;
2839 struct qc_type_state *tstate;
2840 struct quota_info *dqopt = sb_dqopt(sb);
2841 int type;
2842
2843 memset(s: state, c: 0, n: sizeof(*state));
2844 for (type = 0; type < MAXQUOTAS; type++) {
2845 if (!sb_has_quota_active(sb, type))
2846 continue;
2847 tstate = state->s_state + type;
2848 mi = sb_dqopt(sb)->info + type;
2849 tstate->flags = QCI_ACCT_ENABLED;
2850 spin_lock(lock: &dq_data_lock);
2851 if (mi->dqi_flags & DQF_SYS_FILE)
2852 tstate->flags |= QCI_SYSFILE;
2853 if (mi->dqi_flags & DQF_ROOT_SQUASH)
2854 tstate->flags |= QCI_ROOT_SQUASH;
2855 if (sb_has_quota_limits_enabled(sb, type))
2856 tstate->flags |= QCI_LIMITS_ENFORCED;
2857 tstate->spc_timelimit = mi->dqi_bgrace;
2858 tstate->ino_timelimit = mi->dqi_igrace;
2859 if (dqopt->files[type]) {
2860 tstate->ino = dqopt->files[type]->i_ino;
2861 tstate->blocks = dqopt->files[type]->i_blocks;
2862 }
2863 tstate->nextents = 1; /* We don't know... */
2864 spin_unlock(lock: &dq_data_lock);
2865 }
2866 return 0;
2867}
2868EXPORT_SYMBOL(dquot_get_state);
2869
2870/* Generic routine for setting common part of quota file information */
2871int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii)
2872{
2873 struct mem_dqinfo *mi;
2874
2875 if ((ii->i_fieldmask & QC_WARNS_MASK) ||
2876 (ii->i_fieldmask & QC_RT_SPC_TIMER))
2877 return -EINVAL;
2878 if (!sb_has_quota_active(sb, type))
2879 return -ESRCH;
2880 mi = sb_dqopt(sb)->info + type;
2881 if (ii->i_fieldmask & QC_FLAGS) {
2882 if ((ii->i_flags & QCI_ROOT_SQUASH &&
2883 mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD))
2884 return -EINVAL;
2885 }
2886 spin_lock(lock: &dq_data_lock);
2887 if (ii->i_fieldmask & QC_SPC_TIMER)
2888 mi->dqi_bgrace = ii->i_spc_timelimit;
2889 if (ii->i_fieldmask & QC_INO_TIMER)
2890 mi->dqi_igrace = ii->i_ino_timelimit;
2891 if (ii->i_fieldmask & QC_FLAGS) {
2892 if (ii->i_flags & QCI_ROOT_SQUASH)
2893 mi->dqi_flags |= DQF_ROOT_SQUASH;
2894 else
2895 mi->dqi_flags &= ~DQF_ROOT_SQUASH;
2896 }
2897 spin_unlock(lock: &dq_data_lock);
2898 mark_info_dirty(sb, type);
2899 /* Force write to disk */
2900 return sb->dq_op->write_info(sb, type);
2901}
2902EXPORT_SYMBOL(dquot_set_dqinfo);
2903
2904const struct quotactl_ops dquot_quotactl_sysfile_ops = {
2905 .quota_enable = dquot_quota_enable,
2906 .quota_disable = dquot_quota_disable,
2907 .quota_sync = dquot_quota_sync,
2908 .get_state = dquot_get_state,
2909 .set_info = dquot_set_dqinfo,
2910 .get_dqblk = dquot_get_dqblk,
2911 .get_nextdqblk = dquot_get_next_dqblk,
2912 .set_dqblk = dquot_set_dqblk
2913};
2914EXPORT_SYMBOL(dquot_quotactl_sysfile_ops);
2915
2916static int do_proc_dqstats(const struct ctl_table *table, int write,
2917 void *buffer, size_t *lenp, loff_t *ppos)
2918{
2919 unsigned int type = (unsigned long *)table->data - dqstats.stat;
2920 s64 value = percpu_counter_sum(fbc: &dqstats.counter[type]);
2921
2922 /* Filter negative values for non-monotonic counters */
2923 if (value < 0 && (type == DQST_ALLOC_DQUOTS ||
2924 type == DQST_FREE_DQUOTS))
2925 value = 0;
2926
2927 /* Update global table */
2928 dqstats.stat[type] = value;
2929 return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
2930}
2931
2932static const struct ctl_table fs_dqstats_table[] = {
2933 {
2934 .procname = "lookups",
2935 .data = &dqstats.stat[DQST_LOOKUPS],
2936 .maxlen = sizeof(unsigned long),
2937 .mode = 0444,
2938 .proc_handler = do_proc_dqstats,
2939 },
2940 {
2941 .procname = "drops",
2942 .data = &dqstats.stat[DQST_DROPS],
2943 .maxlen = sizeof(unsigned long),
2944 .mode = 0444,
2945 .proc_handler = do_proc_dqstats,
2946 },
2947 {
2948 .procname = "reads",
2949 .data = &dqstats.stat[DQST_READS],
2950 .maxlen = sizeof(unsigned long),
2951 .mode = 0444,
2952 .proc_handler = do_proc_dqstats,
2953 },
2954 {
2955 .procname = "writes",
2956 .data = &dqstats.stat[DQST_WRITES],
2957 .maxlen = sizeof(unsigned long),
2958 .mode = 0444,
2959 .proc_handler = do_proc_dqstats,
2960 },
2961 {
2962 .procname = "cache_hits",
2963 .data = &dqstats.stat[DQST_CACHE_HITS],
2964 .maxlen = sizeof(unsigned long),
2965 .mode = 0444,
2966 .proc_handler = do_proc_dqstats,
2967 },
2968 {
2969 .procname = "allocated_dquots",
2970 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
2971 .maxlen = sizeof(unsigned long),
2972 .mode = 0444,
2973 .proc_handler = do_proc_dqstats,
2974 },
2975 {
2976 .procname = "free_dquots",
2977 .data = &dqstats.stat[DQST_FREE_DQUOTS],
2978 .maxlen = sizeof(unsigned long),
2979 .mode = 0444,
2980 .proc_handler = do_proc_dqstats,
2981 },
2982 {
2983 .procname = "syncs",
2984 .data = &dqstats.stat[DQST_SYNCS],
2985 .maxlen = sizeof(unsigned long),
2986 .mode = 0444,
2987 .proc_handler = do_proc_dqstats,
2988 },
2989#ifdef CONFIG_PRINT_QUOTA_WARNING
2990 {
2991 .procname = "warnings",
2992 .data = &flag_print_warnings,
2993 .maxlen = sizeof(int),
2994 .mode = 0644,
2995 .proc_handler = proc_dointvec,
2996 },
2997#endif
2998};
2999
3000static int __init dquot_init(void)
3001{
3002 int i, ret;
3003 unsigned long nr_hash, order;
3004 struct shrinker *dqcache_shrinker;
3005
3006 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
3007
3008 register_sysctl_init("fs/quota", fs_dqstats_table);
3009
3010 dquot_cachep = kmem_cache_create("dquot",
3011 sizeof(struct dquot), sizeof(unsigned long) * 4,
3012 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
3013 SLAB_PANIC),
3014 NULL);
3015
3016 order = 0;
3017 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_KERNEL, order);
3018 if (!dquot_hash)
3019 panic(fmt: "Cannot create dquot hash table");
3020
3021 ret = percpu_counter_init_many(dqstats.counter, 0, GFP_KERNEL,
3022 _DQST_DQSTAT_LAST);
3023 if (ret)
3024 panic(fmt: "Cannot create dquot stat counters");
3025
3026 /* Find power-of-two hlist_heads which can fit into allocation */
3027 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
3028 dq_hash_bits = ilog2(nr_hash);
3029
3030 nr_hash = 1UL << dq_hash_bits;
3031 dq_hash_mask = nr_hash - 1;
3032 for (i = 0; i < nr_hash; i++)
3033 INIT_HLIST_HEAD(dquot_hash + i);
3034
3035 pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld,"
3036 " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order));
3037
3038 dqcache_shrinker = shrinker_alloc(flags: 0, fmt: "dquota-cache");
3039 if (!dqcache_shrinker)
3040 panic(fmt: "Cannot allocate dquot shrinker");
3041
3042 dqcache_shrinker->count_objects = dqcache_shrink_count;
3043 dqcache_shrinker->scan_objects = dqcache_shrink_scan;
3044
3045 shrinker_register(shrinker: dqcache_shrinker);
3046
3047 quota_unbound_wq = alloc_workqueue("quota_events_unbound",
3048 WQ_UNBOUND | WQ_MEM_RECLAIM, WQ_MAX_ACTIVE);
3049 if (!quota_unbound_wq)
3050 panic(fmt: "Cannot create quota_unbound_wq\n");
3051
3052 return 0;
3053}
3054fs_initcall(dquot_init);
3055