1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
2884d179dSJan Kara /*
3884d179dSJan Kara * Implementation of the diskquota system for the LINUX operating system. QUOTA
4884d179dSJan Kara * is implemented using the BSD system call interface as the means of
5884d179dSJan Kara * communication with the user level. This file contains the generic routines
6884d179dSJan Kara * called by the different filesystems on allocation of an inode or block.
7884d179dSJan Kara * These routines take care of the administration needed to have a consistent
8884d179dSJan Kara * diskquota tracking system. The ideas of both user and group quotas are based
9884d179dSJan Kara * on the Melbourne quota system as used on BSD derived systems. The internal
10884d179dSJan Kara * implementation is based on one of the several variants of the LINUX
11884d179dSJan Kara * inode-subsystem with added complexity of the diskquota system.
12884d179dSJan Kara *
13884d179dSJan Kara * Author: Marco van Wieringen <mvw@planets.elm.net>
14884d179dSJan Kara *
15884d179dSJan Kara * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
16884d179dSJan Kara *
17884d179dSJan Kara * Revised list management to avoid races
18884d179dSJan Kara * -- Bill Hawes, <whawes@star.net>, 9/98
19884d179dSJan Kara *
20884d179dSJan Kara * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...().
21884d179dSJan Kara * As the consequence the locking was moved from dquot_decr_...(),
22884d179dSJan Kara * dquot_incr_...() to calling functions.
23884d179dSJan Kara * invalidate_dquots() now writes modified dquots.
24884d179dSJan Kara * Serialized quota_off() and quota_on() for mount point.
25884d179dSJan Kara * Fixed a few bugs in grow_dquots().
26884d179dSJan Kara * Fixed deadlock in write_dquot() - we no longer account quotas on
27884d179dSJan Kara * quota files
28884d179dSJan Kara * remove_dquot_ref() moved to inode.c - it now traverses through inodes
29884d179dSJan Kara * add_dquot_ref() restarts after blocking
30884d179dSJan Kara * Added check for bogus uid and fixed check for group in quotactl.
31884d179dSJan Kara * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99
32884d179dSJan Kara *
33884d179dSJan Kara * Used struct list_head instead of own list struct
34884d179dSJan Kara * Invalidation of referenced dquots is no longer possible
35884d179dSJan Kara * Improved free_dquots list management
36884d179dSJan Kara * Quota and i_blocks are now updated in one place to avoid races
37884d179dSJan Kara * Warnings are now delayed so we won't block in critical section
38884d179dSJan Kara * Write updated not to require dquot lock
39884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 9/2000
40884d179dSJan Kara *
41884d179dSJan Kara * Added dynamic quota structure allocation
42884d179dSJan Kara * Jan Kara <jack@suse.cz> 12/2000
43884d179dSJan Kara *
44884d179dSJan Kara * Rewritten quota interface. Implemented new quota format and
45884d179dSJan Kara * formats registering.
46884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2001,2002
47884d179dSJan Kara *
48884d179dSJan Kara * New SMP locking.
49884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 10/2002
50884d179dSJan Kara *
51884d179dSJan Kara * Added journalled quota support, fix lock inversion problems
52884d179dSJan Kara * Jan Kara, <jack@suse.cz>, 2003,2004
53884d179dSJan Kara *
54884d179dSJan Kara * (C) Copyright 1994 - 1997 Marco van Wieringen
55884d179dSJan Kara */
56884d179dSJan Kara
57884d179dSJan Kara #include <linux/errno.h>
58884d179dSJan Kara #include <linux/kernel.h>
59884d179dSJan Kara #include <linux/fs.h>
60884d179dSJan Kara #include <linux/mount.h>
61884d179dSJan Kara #include <linux/mm.h>
62884d179dSJan Kara #include <linux/time.h>
63884d179dSJan Kara #include <linux/types.h>
64884d179dSJan Kara #include <linux/string.h>
65884d179dSJan Kara #include <linux/fcntl.h>
66884d179dSJan Kara #include <linux/stat.h>
67884d179dSJan Kara #include <linux/tty.h>
68884d179dSJan Kara #include <linux/file.h>
69884d179dSJan Kara #include <linux/slab.h>
70884d179dSJan Kara #include <linux/sysctl.h>
71884d179dSJan Kara #include <linux/init.h>
72884d179dSJan Kara #include <linux/module.h>
73884d179dSJan Kara #include <linux/proc_fs.h>
74884d179dSJan Kara #include <linux/security.h>
7540401530SAl Viro #include <linux/sched.h>
765b825c3aSIngo Molnar #include <linux/cred.h>
77884d179dSJan Kara #include <linux/kmod.h>
78884d179dSJan Kara #include <linux/namei.h>
79884d179dSJan Kara #include <linux/capability.h>
80884d179dSJan Kara #include <linux/quotaops.h>
813f1266f1SChristoph Hellwig #include <linux/blkdev.h>
82537e11cdSMatthew Wilcox (Oracle) #include <linux/sched/mm.h>
8355fa6091SDave Chinner #include "../internal.h" /* ugh */
84884d179dSJan Kara
85f3da9310SJeff Liu #include <linux/uaccess.h>
86884d179dSJan Kara
87884d179dSJan Kara /*
887b9ca4c6SJan Kara * There are five quota SMP locks:
897b9ca4c6SJan Kara * * dq_list_lock protects all lists with quotas and quota formats.
907b9ca4c6SJan Kara * * dquot->dq_dqb_lock protects data from dq_dqb
917b9ca4c6SJan Kara * * inode->i_lock protects inode->i_blocks, i_bytes and also guards
927b9ca4c6SJan Kara * consistency of dquot->dq_dqb with inode->i_blocks, i_bytes so that
937b9ca4c6SJan Kara * dquot_transfer() can stabilize amount it transfers
947b9ca4c6SJan Kara * * dq_data_lock protects mem_dqinfo structures and modifications of dquot
957b9ca4c6SJan Kara * pointers in the inode
967b9ca4c6SJan Kara * * dq_state_lock protects modifications of quota state (on quotaon and
977b9ca4c6SJan Kara * quotaoff) and readers who care about latest values take it as well.
98884d179dSJan Kara *
997b9ca4c6SJan Kara * The spinlock ordering is hence:
1007b9ca4c6SJan Kara * dq_data_lock > dq_list_lock > i_lock > dquot->dq_dqb_lock,
101884d179dSJan Kara * dq_list_lock > dq_state_lock
102884d179dSJan Kara *
103884d179dSJan Kara * Note that some things (eg. sb pointer, type, id) doesn't change during
104884d179dSJan Kara * the life of the dquot structure and so needn't to be protected by a lock
105884d179dSJan Kara *
106b9ba6f94SNiu Yawei * Operation accessing dquots via inode pointers are protected by dquot_srcu.
107b9ba6f94SNiu Yawei * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and
108b9ba6f94SNiu Yawei * synchronize_srcu(&dquot_srcu) is called after clearing pointers from
109b9ba6f94SNiu Yawei * inode and before dropping dquot references to avoid use of dquots after
110b9ba6f94SNiu Yawei * they are freed. dq_data_lock is used to serialize the pointer setting and
111b9ba6f94SNiu Yawei * clearing operations.
11226245c94SJan Kara * Special care needs to be taken about S_NOQUOTA inode flag (marking that
11326245c94SJan Kara * inode is a quota file). Functions adding pointers from inode to dquots have
114b9ba6f94SNiu Yawei * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they
115b9ba6f94SNiu Yawei * have to do all pointer modifications before dropping dq_data_lock. This makes
11626245c94SJan Kara * sure they cannot race with quotaon which first sets S_NOQUOTA flag and
11726245c94SJan Kara * then drops all pointers to dquots from an inode.
118884d179dSJan Kara *
1195e8cb9b6SJan Kara * Each dquot has its dq_lock mutex. Dquot is locked when it is being read to
1205e8cb9b6SJan Kara * memory (or space for it is being allocated) on the first dqget(), when it is
1215e8cb9b6SJan Kara * being written out, and when it is being released on the last dqput(). The
1225e8cb9b6SJan Kara * allocation and release operations are serialized by the dq_lock and by
1235e8cb9b6SJan Kara * checking the use count in dquot_release().
124884d179dSJan Kara *
125884d179dSJan Kara * Lock ordering (including related VFS locks) is the following:
126bc8230eeSJan Kara * s_umount > i_mutex > journal_lock > dquot->dq_lock > dqio_sem
127884d179dSJan Kara */
128884d179dSJan Kara
129c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock);
130c516610cSJan Kara static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
131c516610cSJan Kara __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
132884d179dSJan Kara EXPORT_SYMBOL(dq_data_lock);
133b9ba6f94SNiu Yawei DEFINE_STATIC_SRCU(dquot_srcu);
134884d179dSJan Kara
135503330f3SJan Kara static DECLARE_WAIT_QUEUE_HEAD(dquot_ref_wq);
136503330f3SJan Kara
__quota_error(struct super_block * sb,const char * func,const char * fmt,...)137fb5ffb0eSJiaying Zhang void __quota_error(struct super_block *sb, const char *func,
138fb5ffb0eSJiaying Zhang const char *fmt, ...)
139fb5ffb0eSJiaying Zhang {
140fb5ffb0eSJiaying Zhang if (printk_ratelimit()) {
141055adcbdSJoe Perches va_list args;
142055adcbdSJoe Perches struct va_format vaf;
143055adcbdSJoe Perches
144fb5ffb0eSJiaying Zhang va_start(args, fmt);
145055adcbdSJoe Perches
146055adcbdSJoe Perches vaf.fmt = fmt;
147055adcbdSJoe Perches vaf.va = &args;
148055adcbdSJoe Perches
149055adcbdSJoe Perches printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
150055adcbdSJoe Perches sb->s_id, func, &vaf);
151055adcbdSJoe Perches
152fb5ffb0eSJiaying Zhang va_end(args);
153fb5ffb0eSJiaying Zhang }
154fb5ffb0eSJiaying Zhang }
155fb5ffb0eSJiaying Zhang EXPORT_SYMBOL(__quota_error);
156fb5ffb0eSJiaying Zhang
157da8d1ba2SSergey Senozhatsky #if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
158884d179dSJan Kara static char *quotatypes[] = INITQFNAMES;
159da8d1ba2SSergey Senozhatsky #endif
160884d179dSJan Kara static struct quota_format_type *quota_formats; /* List of registered formats */
161884d179dSJan Kara static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
162884d179dSJan Kara
163884d179dSJan Kara /* SLAB cache for dquot structures */
164884d179dSJan Kara static struct kmem_cache *dquot_cachep;
165884d179dSJan Kara
register_quota_format(struct quota_format_type * fmt)166884d179dSJan Kara int register_quota_format(struct quota_format_type *fmt)
167884d179dSJan Kara {
168884d179dSJan Kara spin_lock(&dq_list_lock);
169884d179dSJan Kara fmt->qf_next = quota_formats;
170884d179dSJan Kara quota_formats = fmt;
171884d179dSJan Kara spin_unlock(&dq_list_lock);
172884d179dSJan Kara return 0;
173884d179dSJan Kara }
174884d179dSJan Kara EXPORT_SYMBOL(register_quota_format);
175884d179dSJan Kara
unregister_quota_format(struct quota_format_type * fmt)176884d179dSJan Kara void unregister_quota_format(struct quota_format_type *fmt)
177884d179dSJan Kara {
178884d179dSJan Kara struct quota_format_type **actqf;
179884d179dSJan Kara
180884d179dSJan Kara spin_lock(&dq_list_lock);
181268157baSJan Kara for (actqf = "a_formats; *actqf && *actqf != fmt;
182268157baSJan Kara actqf = &(*actqf)->qf_next)
183268157baSJan Kara ;
184884d179dSJan Kara if (*actqf)
185884d179dSJan Kara *actqf = (*actqf)->qf_next;
186884d179dSJan Kara spin_unlock(&dq_list_lock);
187884d179dSJan Kara }
188884d179dSJan Kara EXPORT_SYMBOL(unregister_quota_format);
189884d179dSJan Kara
find_quota_format(int id)190884d179dSJan Kara static struct quota_format_type *find_quota_format(int id)
191884d179dSJan Kara {
192884d179dSJan Kara struct quota_format_type *actqf;
193884d179dSJan Kara
194884d179dSJan Kara spin_lock(&dq_list_lock);
195268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
196268157baSJan Kara actqf = actqf->qf_next)
197268157baSJan Kara ;
198884d179dSJan Kara if (!actqf || !try_module_get(actqf->qf_owner)) {
199884d179dSJan Kara int qm;
200884d179dSJan Kara
201884d179dSJan Kara spin_unlock(&dq_list_lock);
202884d179dSJan Kara
203268157baSJan Kara for (qm = 0; module_names[qm].qm_fmt_id &&
204268157baSJan Kara module_names[qm].qm_fmt_id != id; qm++)
205268157baSJan Kara ;
206268157baSJan Kara if (!module_names[qm].qm_fmt_id ||
207268157baSJan Kara request_module(module_names[qm].qm_mod_name))
208884d179dSJan Kara return NULL;
209884d179dSJan Kara
210884d179dSJan Kara spin_lock(&dq_list_lock);
211268157baSJan Kara for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
212268157baSJan Kara actqf = actqf->qf_next)
213268157baSJan Kara ;
214884d179dSJan Kara if (actqf && !try_module_get(actqf->qf_owner))
215884d179dSJan Kara actqf = NULL;
216884d179dSJan Kara }
217884d179dSJan Kara spin_unlock(&dq_list_lock);
218884d179dSJan Kara return actqf;
219884d179dSJan Kara }
220884d179dSJan Kara
put_quota_format(struct quota_format_type * fmt)221884d179dSJan Kara static void put_quota_format(struct quota_format_type *fmt)
222884d179dSJan Kara {
223884d179dSJan Kara module_put(fmt->qf_owner);
224884d179dSJan Kara }
225884d179dSJan Kara
226884d179dSJan Kara /*
227884d179dSJan Kara * Dquot List Management:
228dabc8b20SBaokun Li * The quota code uses five lists for dquot management: the inuse_list,
229dabc8b20SBaokun Li * releasing_dquots, free_dquots, dqi_dirty_list, and dquot_hash[] array.
230dabc8b20SBaokun Li * A single dquot structure may be on some of those lists, depending on
231dabc8b20SBaokun Li * its current state.
232884d179dSJan Kara *
233884d179dSJan Kara * All dquots are placed to the end of inuse_list when first created, and this
234884d179dSJan Kara * list is used for invalidate operation, which must look at every dquot.
235884d179dSJan Kara *
236869b6ea1SJan Kara * When the last reference of a dquot is dropped, the dquot is added to
237869b6ea1SJan Kara * releasing_dquots. We'll then queue work item which will call
238dabc8b20SBaokun Li * synchronize_srcu() and after that perform the final cleanup of all the
239869b6ea1SJan Kara * dquots on the list. Each cleaned up dquot is moved to free_dquots list.
240869b6ea1SJan Kara * Both releasing_dquots and free_dquots use the dq_free list_head in the dquot
241869b6ea1SJan Kara * struct.
242dabc8b20SBaokun Li *
243869b6ea1SJan Kara * Unused and cleaned up dquots are in the free_dquots list and this list is
244869b6ea1SJan Kara * searched whenever we need an available dquot. Dquots are removed from the
245869b6ea1SJan Kara * list as soon as they are used again and dqstats.free_dquots gives the number
246869b6ea1SJan Kara * of dquots on the list. When dquot is invalidated it's completely released
247869b6ea1SJan Kara * from memory.
248884d179dSJan Kara *
249f44840adSChengguang Xu * Dirty dquots are added to the dqi_dirty_list of quota_info when mark
250f44840adSChengguang Xu * dirtied, and this list is searched when writing dirty dquots back to
251f44840adSChengguang Xu * quota file. Note that some filesystems do dirty dquot tracking on their
252f44840adSChengguang Xu * own (e.g. in a journal) and thus don't use dqi_dirty_list.
253f44840adSChengguang Xu *
254884d179dSJan Kara * Dquots with a specific identity (device, type and id) are placed on
255884d179dSJan Kara * one of the dquot_hash[] hash chains. The provides an efficient search
256884d179dSJan Kara * mechanism to locate a specific dquot.
257884d179dSJan Kara */
258884d179dSJan Kara
259884d179dSJan Kara static LIST_HEAD(inuse_list);
260884d179dSJan Kara static LIST_HEAD(free_dquots);
261dabc8b20SBaokun Li static LIST_HEAD(releasing_dquots);
262884d179dSJan Kara static unsigned int dq_hash_bits, dq_hash_mask;
263884d179dSJan Kara static struct hlist_head *dquot_hash;
264884d179dSJan Kara
265884d179dSJan Kara struct dqstats dqstats;
266884d179dSJan Kara EXPORT_SYMBOL(dqstats);
267884d179dSJan Kara
2680a5a9c72SJan Kara static qsize_t inode_get_rsv_space(struct inode *inode);
2697b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode);
2706184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type);
2710a5a9c72SJan Kara
272dabc8b20SBaokun Li static void quota_release_workfn(struct work_struct *work);
273dabc8b20SBaokun Li static DECLARE_DELAYED_WORK(quota_release_work, quota_release_workfn);
274dabc8b20SBaokun Li
275884d179dSJan Kara static inline unsigned int
hashfn(const struct super_block * sb,struct kqid qid)2761a06d420SEric W. Biederman hashfn(const struct super_block *sb, struct kqid qid)
277884d179dSJan Kara {
2781a06d420SEric W. Biederman unsigned int id = from_kqid(&init_user_ns, qid);
2791a06d420SEric W. Biederman int type = qid.type;
280884d179dSJan Kara unsigned long tmp;
281884d179dSJan Kara
282884d179dSJan Kara tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
283884d179dSJan Kara return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
284884d179dSJan Kara }
285884d179dSJan Kara
286884d179dSJan Kara /*
287884d179dSJan Kara * Following list functions expect dq_list_lock to be held
288884d179dSJan Kara */
insert_dquot_hash(struct dquot * dquot)289884d179dSJan Kara static inline void insert_dquot_hash(struct dquot *dquot)
290884d179dSJan Kara {
291268157baSJan Kara struct hlist_head *head;
2921a06d420SEric W. Biederman head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id);
293884d179dSJan Kara hlist_add_head(&dquot->dq_hash, head);
294884d179dSJan Kara }
295884d179dSJan Kara
remove_dquot_hash(struct dquot * dquot)296884d179dSJan Kara static inline void remove_dquot_hash(struct dquot *dquot)
297884d179dSJan Kara {
298884d179dSJan Kara hlist_del_init(&dquot->dq_hash);
299884d179dSJan Kara }
300884d179dSJan Kara
find_dquot(unsigned int hashent,struct super_block * sb,struct kqid qid)3017a2435d8SJan Kara static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
3021a06d420SEric W. Biederman struct kqid qid)
303884d179dSJan Kara {
304884d179dSJan Kara struct dquot *dquot;
305884d179dSJan Kara
3068c721cb0SChristophe JAILLET hlist_for_each_entry(dquot, dquot_hash+hashent, dq_hash)
3074c376dcaSEric W. Biederman if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid))
308884d179dSJan Kara return dquot;
3098c721cb0SChristophe JAILLET
310dd6f3c6dSJan Kara return NULL;
311884d179dSJan Kara }
312884d179dSJan Kara
313884d179dSJan Kara /* Add a dquot to the tail of the free list */
put_dquot_last(struct dquot * dquot)314884d179dSJan Kara static inline void put_dquot_last(struct dquot *dquot)
315884d179dSJan Kara {
316884d179dSJan Kara list_add_tail(&dquot->dq_free, &free_dquots);
317dde95888SDmitry Monakhov dqstats_inc(DQST_FREE_DQUOTS);
318884d179dSJan Kara }
319884d179dSJan Kara
put_releasing_dquots(struct dquot * dquot)320dabc8b20SBaokun Li static inline void put_releasing_dquots(struct dquot *dquot)
321dabc8b20SBaokun Li {
322dabc8b20SBaokun Li list_add_tail(&dquot->dq_free, &releasing_dquots);
323869b6ea1SJan Kara set_bit(DQ_RELEASING_B, &dquot->dq_flags);
324dabc8b20SBaokun Li }
325dabc8b20SBaokun Li
remove_free_dquot(struct dquot * dquot)326884d179dSJan Kara static inline void remove_free_dquot(struct dquot *dquot)
327884d179dSJan Kara {
328884d179dSJan Kara if (list_empty(&dquot->dq_free))
329884d179dSJan Kara return;
330884d179dSJan Kara list_del_init(&dquot->dq_free);
331869b6ea1SJan Kara if (!test_bit(DQ_RELEASING_B, &dquot->dq_flags))
332dde95888SDmitry Monakhov dqstats_dec(DQST_FREE_DQUOTS);
333869b6ea1SJan Kara else
334869b6ea1SJan Kara clear_bit(DQ_RELEASING_B, &dquot->dq_flags);
335884d179dSJan Kara }
336884d179dSJan Kara
put_inuse(struct dquot * dquot)337884d179dSJan Kara static inline void put_inuse(struct dquot *dquot)
338884d179dSJan Kara {
339884d179dSJan Kara /* We add to the back of inuse list so we don't have to restart
340884d179dSJan Kara * when traversing this list and we block */
341884d179dSJan Kara list_add_tail(&dquot->dq_inuse, &inuse_list);
342dde95888SDmitry Monakhov dqstats_inc(DQST_ALLOC_DQUOTS);
343884d179dSJan Kara }
344884d179dSJan Kara
remove_inuse(struct dquot * dquot)345884d179dSJan Kara static inline void remove_inuse(struct dquot *dquot)
346884d179dSJan Kara {
347dde95888SDmitry Monakhov dqstats_dec(DQST_ALLOC_DQUOTS);
348884d179dSJan Kara list_del(&dquot->dq_inuse);
349884d179dSJan Kara }
350884d179dSJan Kara /*
351884d179dSJan Kara * End of list functions needing dq_list_lock
352884d179dSJan Kara */
353884d179dSJan Kara
wait_on_dquot(struct dquot * dquot)354884d179dSJan Kara static void wait_on_dquot(struct dquot *dquot)
355884d179dSJan Kara {
356884d179dSJan Kara mutex_lock(&dquot->dq_lock);
357884d179dSJan Kara mutex_unlock(&dquot->dq_lock);
358884d179dSJan Kara }
359884d179dSJan Kara
dquot_active(struct dquot * dquot)36033bcfafcSBaokun Li static inline int dquot_active(struct dquot *dquot)
36133bcfafcSBaokun Li {
36233bcfafcSBaokun Li return test_bit(DQ_ACTIVE_B, &dquot->dq_flags);
36333bcfafcSBaokun Li }
36433bcfafcSBaokun Li
dquot_dirty(struct dquot * dquot)365884d179dSJan Kara static inline int dquot_dirty(struct dquot *dquot)
366884d179dSJan Kara {
367884d179dSJan Kara return test_bit(DQ_MOD_B, &dquot->dq_flags);
368884d179dSJan Kara }
369884d179dSJan Kara
mark_dquot_dirty(struct dquot * dquot)370884d179dSJan Kara static inline int mark_dquot_dirty(struct dquot *dquot)
371884d179dSJan Kara {
372884d179dSJan Kara return dquot->dq_sb->dq_op->mark_dirty(dquot);
373884d179dSJan Kara }
374884d179dSJan Kara
375eabf290dSDmitry Monakhov /* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
dquot_mark_dquot_dirty(struct dquot * dquot)376884d179dSJan Kara int dquot_mark_dquot_dirty(struct dquot *dquot)
377884d179dSJan Kara {
378eabf290dSDmitry Monakhov int ret = 1;
379eabf290dSDmitry Monakhov
38033bcfafcSBaokun Li if (!dquot_active(dquot))
3814580b30eSJan Kara return 0;
3824580b30eSJan Kara
383834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
384834057bfSJan Kara return test_and_set_bit(DQ_MOD_B, &dquot->dq_flags);
385834057bfSJan Kara
386eabf290dSDmitry Monakhov /* If quota is dirty already, we don't have to acquire dq_list_lock */
38733bcfafcSBaokun Li if (dquot_dirty(dquot))
388eabf290dSDmitry Monakhov return 1;
389eabf290dSDmitry Monakhov
390884d179dSJan Kara spin_lock(&dq_list_lock);
391eabf290dSDmitry Monakhov if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
392884d179dSJan Kara list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
3934c376dcaSEric W. Biederman info[dquot->dq_id.type].dqi_dirty_list);
394eabf290dSDmitry Monakhov ret = 0;
395eabf290dSDmitry Monakhov }
396884d179dSJan Kara spin_unlock(&dq_list_lock);
397eabf290dSDmitry Monakhov return ret;
398884d179dSJan Kara }
399884d179dSJan Kara EXPORT_SYMBOL(dquot_mark_dquot_dirty);
400884d179dSJan Kara
401dc52dd3aSDmitry Monakhov /* Dirtify all the dquots - this can block when journalling */
mark_all_dquot_dirty(struct dquot __rcu * const * dquots)402e45e8aa2SJan Kara static inline int mark_all_dquot_dirty(struct dquot __rcu * const *dquots)
403dc52dd3aSDmitry Monakhov {
404dc52dd3aSDmitry Monakhov int ret, err, cnt;
40540a673b4SWang Jianjian struct dquot *dquot;
406dc52dd3aSDmitry Monakhov
407dc52dd3aSDmitry Monakhov ret = err = 0;
408dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
40940a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
41040a673b4SWang Jianjian if (dquot)
411dc52dd3aSDmitry Monakhov /* Even in case of error we have to continue */
41240a673b4SWang Jianjian ret = mark_dquot_dirty(dquot);
413dc52dd3aSDmitry Monakhov if (!err)
414dc52dd3aSDmitry Monakhov err = ret;
415dc52dd3aSDmitry Monakhov }
416dc52dd3aSDmitry Monakhov return err;
417dc52dd3aSDmitry Monakhov }
418dc52dd3aSDmitry Monakhov
dqput_all(struct dquot ** dquot)419dc52dd3aSDmitry Monakhov static inline void dqput_all(struct dquot **dquot)
420dc52dd3aSDmitry Monakhov {
421dc52dd3aSDmitry Monakhov unsigned int cnt;
422dc52dd3aSDmitry Monakhov
423dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++)
424dc52dd3aSDmitry Monakhov dqput(dquot[cnt]);
425dc52dd3aSDmitry Monakhov }
426dc52dd3aSDmitry Monakhov
clear_dquot_dirty(struct dquot * dquot)427884d179dSJan Kara static inline int clear_dquot_dirty(struct dquot *dquot)
428884d179dSJan Kara {
429834057bfSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
430834057bfSJan Kara return test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags);
431834057bfSJan Kara
4321e0b7cb0SJan Kara spin_lock(&dq_list_lock);
4331e0b7cb0SJan Kara if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) {
4341e0b7cb0SJan Kara spin_unlock(&dq_list_lock);
435884d179dSJan Kara return 0;
4361e0b7cb0SJan Kara }
437884d179dSJan Kara list_del_init(&dquot->dq_dirty);
4381e0b7cb0SJan Kara spin_unlock(&dq_list_lock);
439884d179dSJan Kara return 1;
440884d179dSJan Kara }
441884d179dSJan Kara
mark_info_dirty(struct super_block * sb,int type)442884d179dSJan Kara void mark_info_dirty(struct super_block *sb, int type)
443884d179dSJan Kara {
44415512377SJan Kara spin_lock(&dq_data_lock);
44515512377SJan Kara sb_dqopt(sb)->info[type].dqi_flags |= DQF_INFO_DIRTY;
44615512377SJan Kara spin_unlock(&dq_data_lock);
447884d179dSJan Kara }
448884d179dSJan Kara EXPORT_SYMBOL(mark_info_dirty);
449884d179dSJan Kara
450884d179dSJan Kara /*
451884d179dSJan Kara * Read dquot from disk and alloc space for it
452884d179dSJan Kara */
453884d179dSJan Kara
dquot_acquire(struct dquot * dquot)454884d179dSJan Kara int dquot_acquire(struct dquot *dquot)
455884d179dSJan Kara {
456884d179dSJan Kara int ret = 0, ret2 = 0;
457537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc;
458884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
459884d179dSJan Kara
460884d179dSJan Kara mutex_lock(&dquot->dq_lock);
461537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save();
4623ef177ecSChengguang Xu if (!test_bit(DQ_READ_B, &dquot->dq_flags)) {
4634c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot);
464884d179dSJan Kara if (ret < 0)
465884d179dSJan Kara goto out_iolock;
4663ef177ecSChengguang Xu }
467044c9b67SJan Kara /* Make sure flags update is visible after dquot has been filled */
468044c9b67SJan Kara smp_mb__before_atomic();
469884d179dSJan Kara set_bit(DQ_READ_B, &dquot->dq_flags);
470884d179dSJan Kara /* Instantiate dquot if needed */
47133bcfafcSBaokun Li if (!dquot_active(dquot) && !dquot->dq_off) {
4724c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
473884d179dSJan Kara /* Write the info if needed */
4744c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
4754c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
4764c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type);
477268157baSJan Kara }
478884d179dSJan Kara if (ret < 0)
479884d179dSJan Kara goto out_iolock;
480884d179dSJan Kara if (ret2 < 0) {
481884d179dSJan Kara ret = ret2;
482884d179dSJan Kara goto out_iolock;
483884d179dSJan Kara }
484884d179dSJan Kara }
485044c9b67SJan Kara /*
486044c9b67SJan Kara * Make sure flags update is visible after on-disk struct has been
487044c9b67SJan Kara * allocated. Paired with smp_rmb() in dqget().
488044c9b67SJan Kara */
489044c9b67SJan Kara smp_mb__before_atomic();
490884d179dSJan Kara set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
491884d179dSJan Kara out_iolock:
492537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc);
493884d179dSJan Kara mutex_unlock(&dquot->dq_lock);
494884d179dSJan Kara return ret;
495884d179dSJan Kara }
496884d179dSJan Kara EXPORT_SYMBOL(dquot_acquire);
497884d179dSJan Kara
498884d179dSJan Kara /*
499884d179dSJan Kara * Write dquot to disk
500884d179dSJan Kara */
dquot_commit(struct dquot * dquot)501884d179dSJan Kara int dquot_commit(struct dquot *dquot)
502884d179dSJan Kara {
503b03f2456SJan Kara int ret = 0;
504537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc;
505884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
506884d179dSJan Kara
5075e8cb9b6SJan Kara mutex_lock(&dquot->dq_lock);
508537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save();
5091e0b7cb0SJan Kara if (!clear_dquot_dirty(dquot))
5105e8cb9b6SJan Kara goto out_lock;
511884d179dSJan Kara /* Inactive dquot can be only if there was error during read/init
512884d179dSJan Kara * => we have better not writing it */
51333bcfafcSBaokun Li if (dquot_active(dquot))
5144c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
515b03f2456SJan Kara else
516b03f2456SJan Kara ret = -EIO;
5175e8cb9b6SJan Kara out_lock:
518537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc);
5195e8cb9b6SJan Kara mutex_unlock(&dquot->dq_lock);
520884d179dSJan Kara return ret;
521884d179dSJan Kara }
522884d179dSJan Kara EXPORT_SYMBOL(dquot_commit);
523884d179dSJan Kara
524884d179dSJan Kara /*
525884d179dSJan Kara * Release dquot
526884d179dSJan Kara */
dquot_release(struct dquot * dquot)527884d179dSJan Kara int dquot_release(struct dquot *dquot)
528884d179dSJan Kara {
529884d179dSJan Kara int ret = 0, ret2 = 0;
530537e11cdSMatthew Wilcox (Oracle) unsigned int memalloc;
531884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
532884d179dSJan Kara
533884d179dSJan Kara mutex_lock(&dquot->dq_lock);
534537e11cdSMatthew Wilcox (Oracle) memalloc = memalloc_nofs_save();
535884d179dSJan Kara /* Check whether we are not racing with some other dqget() */
536df4bb5d1SDmitry Monakhov if (dquot_is_busy(dquot))
537884d179dSJan Kara goto out_dqlock;
5384c376dcaSEric W. Biederman if (dqopt->ops[dquot->dq_id.type]->release_dqblk) {
5394c376dcaSEric W. Biederman ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot);
540884d179dSJan Kara /* Write the info */
5414c376dcaSEric W. Biederman if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
5424c376dcaSEric W. Biederman ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
5434c376dcaSEric W. Biederman dquot->dq_sb, dquot->dq_id.type);
544268157baSJan Kara }
545884d179dSJan Kara if (ret >= 0)
546884d179dSJan Kara ret = ret2;
547884d179dSJan Kara }
548884d179dSJan Kara clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
549884d179dSJan Kara out_dqlock:
550537e11cdSMatthew Wilcox (Oracle) memalloc_nofs_restore(memalloc);
551884d179dSJan Kara mutex_unlock(&dquot->dq_lock);
552884d179dSJan Kara return ret;
553884d179dSJan Kara }
554884d179dSJan Kara EXPORT_SYMBOL(dquot_release);
555884d179dSJan Kara
dquot_destroy(struct dquot * dquot)556884d179dSJan Kara void dquot_destroy(struct dquot *dquot)
557884d179dSJan Kara {
558884d179dSJan Kara kmem_cache_free(dquot_cachep, dquot);
559884d179dSJan Kara }
560884d179dSJan Kara EXPORT_SYMBOL(dquot_destroy);
561884d179dSJan Kara
do_destroy_dquot(struct dquot * dquot)562884d179dSJan Kara static inline void do_destroy_dquot(struct dquot *dquot)
563884d179dSJan Kara {
564884d179dSJan Kara dquot->dq_sb->dq_op->destroy_dquot(dquot);
565884d179dSJan Kara }
566884d179dSJan Kara
567884d179dSJan Kara /* Invalidate all dquots on the list. Note that this function is called after
568884d179dSJan Kara * quota is disabled and pointers from inodes removed so there cannot be new
569884d179dSJan Kara * quota users. There can still be some users of quotas due to inodes being
570884d179dSJan Kara * just deleted or pruned by prune_icache() (those are not attached to any
571884d179dSJan Kara * list) or parallel quotactl call. We have to wait for such users.
572884d179dSJan Kara */
invalidate_dquots(struct super_block * sb,int type)573884d179dSJan Kara static void invalidate_dquots(struct super_block *sb, int type)
574884d179dSJan Kara {
575884d179dSJan Kara struct dquot *dquot, *tmp;
576884d179dSJan Kara
577884d179dSJan Kara restart:
578dabc8b20SBaokun Li flush_delayed_work("a_release_work);
579dabc8b20SBaokun Li
580884d179dSJan Kara spin_lock(&dq_list_lock);
581884d179dSJan Kara list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
582884d179dSJan Kara if (dquot->dq_sb != sb)
583884d179dSJan Kara continue;
5844c376dcaSEric W. Biederman if (dquot->dq_id.type != type)
585884d179dSJan Kara continue;
586884d179dSJan Kara /* Wait for dquot users */
587884d179dSJan Kara if (atomic_read(&dquot->dq_count)) {
588d6a95db3SYe Bin atomic_inc(&dquot->dq_count);
589884d179dSJan Kara spin_unlock(&dq_list_lock);
590503330f3SJan Kara /*
591503330f3SJan Kara * Once dqput() wakes us up, we know it's time to free
592884d179dSJan Kara * the dquot.
593884d179dSJan Kara * IMPORTANT: we rely on the fact that there is always
594884d179dSJan Kara * at most one process waiting for dquot to free.
595884d179dSJan Kara * Otherwise dq_count would be > 1 and we would never
596884d179dSJan Kara * wake up.
597884d179dSJan Kara */
598503330f3SJan Kara wait_event(dquot_ref_wq,
599503330f3SJan Kara atomic_read(&dquot->dq_count) == 1);
600884d179dSJan Kara dqput(dquot);
601884d179dSJan Kara /* At this moment dquot() need not exist (it could be
602884d179dSJan Kara * reclaimed by prune_dqcache(). Hence we must
603884d179dSJan Kara * restart. */
604884d179dSJan Kara goto restart;
605884d179dSJan Kara }
606884d179dSJan Kara /*
607869b6ea1SJan Kara * The last user already dropped its reference but dquot didn't
608869b6ea1SJan Kara * get fully cleaned up yet. Restart the scan which flushes the
609869b6ea1SJan Kara * work cleaning up released dquots.
610869b6ea1SJan Kara */
611869b6ea1SJan Kara if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) {
612869b6ea1SJan Kara spin_unlock(&dq_list_lock);
613869b6ea1SJan Kara goto restart;
614869b6ea1SJan Kara }
615869b6ea1SJan Kara /*
616884d179dSJan Kara * Quota now has no users and it has been written on last
617884d179dSJan Kara * dqput()
618884d179dSJan Kara */
619884d179dSJan Kara remove_dquot_hash(dquot);
620884d179dSJan Kara remove_free_dquot(dquot);
621884d179dSJan Kara remove_inuse(dquot);
622884d179dSJan Kara do_destroy_dquot(dquot);
623884d179dSJan Kara }
624884d179dSJan Kara spin_unlock(&dq_list_lock);
625884d179dSJan Kara }
626884d179dSJan Kara
627884d179dSJan Kara /* Call callback for every active dquot on given filesystem */
dquot_scan_active(struct super_block * sb,int (* fn)(struct dquot * dquot,unsigned long priv),unsigned long priv)628884d179dSJan Kara int dquot_scan_active(struct super_block *sb,
629884d179dSJan Kara int (*fn)(struct dquot *dquot, unsigned long priv),
630884d179dSJan Kara unsigned long priv)
631884d179dSJan Kara {
632884d179dSJan Kara struct dquot *dquot, *old_dquot = NULL;
633884d179dSJan Kara int ret = 0;
634884d179dSJan Kara
635ee1ac541SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));
636ee1ac541SJan Kara
637884d179dSJan Kara spin_lock(&dq_list_lock);
638884d179dSJan Kara list_for_each_entry(dquot, &inuse_list, dq_inuse) {
63933bcfafcSBaokun Li if (!dquot_active(dquot))
640884d179dSJan Kara continue;
641884d179dSJan Kara if (dquot->dq_sb != sb)
642884d179dSJan Kara continue;
643884d179dSJan Kara /* Now we have active dquot so we can just increase use count */
644884d179dSJan Kara atomic_inc(&dquot->dq_count);
645884d179dSJan Kara spin_unlock(&dq_list_lock);
646884d179dSJan Kara dqput(old_dquot);
647884d179dSJan Kara old_dquot = dquot;
6481362f4eaSJan Kara /*
6491362f4eaSJan Kara * ->release_dquot() can be racing with us. Our reference
6501362f4eaSJan Kara * protects us from new calls to it so just wait for any
6511362f4eaSJan Kara * outstanding call and recheck the DQ_ACTIVE_B after that.
6521362f4eaSJan Kara */
6531362f4eaSJan Kara wait_on_dquot(dquot);
65433bcfafcSBaokun Li if (dquot_active(dquot)) {
655884d179dSJan Kara ret = fn(dquot, priv);
656884d179dSJan Kara if (ret < 0)
657884d179dSJan Kara goto out;
6581362f4eaSJan Kara }
659884d179dSJan Kara spin_lock(&dq_list_lock);
660884d179dSJan Kara /* We are safe to continue now because our dquot could not
661884d179dSJan Kara * be moved out of the inuse list while we hold the reference */
662884d179dSJan Kara }
663884d179dSJan Kara spin_unlock(&dq_list_lock);
664884d179dSJan Kara out:
665884d179dSJan Kara dqput(old_dquot);
666884d179dSJan Kara return ret;
667884d179dSJan Kara }
668884d179dSJan Kara EXPORT_SYMBOL(dquot_scan_active);
669884d179dSJan Kara
dquot_write_dquot(struct dquot * dquot)67002412847SBaokun Li static inline int dquot_write_dquot(struct dquot *dquot)
67102412847SBaokun Li {
67202412847SBaokun Li int ret = dquot->dq_sb->dq_op->write_dquot(dquot);
67302412847SBaokun Li if (ret < 0) {
67402412847SBaokun Li quota_error(dquot->dq_sb, "Can't write quota structure "
67502412847SBaokun Li "(error %d). Quota may get out of sync!", ret);
67602412847SBaokun Li /* Clear dirty bit anyway to avoid infinite loop. */
67702412847SBaokun Li clear_dquot_dirty(dquot);
67802412847SBaokun Li }
67902412847SBaokun Li return ret;
68002412847SBaokun Li }
68102412847SBaokun Li
682ceed1723SJan Kara /* Write all dquot structures to quota files */
dquot_writeback_dquots(struct super_block * sb,int type)683ceed1723SJan Kara int dquot_writeback_dquots(struct super_block *sb, int type)
684884d179dSJan Kara {
6856ff33d99SDmitry Monakhov struct list_head dirty;
686884d179dSJan Kara struct dquot *dquot;
687884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb);
688884d179dSJan Kara int cnt;
689ceed1723SJan Kara int err, ret = 0;
690884d179dSJan Kara
6919d1ccbe7SJan Kara WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));
6929d1ccbe7SJan Kara
693884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
694884d179dSJan Kara if (type != -1 && cnt != type)
695884d179dSJan Kara continue;
696884d179dSJan Kara if (!sb_has_quota_active(sb, cnt))
697884d179dSJan Kara continue;
698884d179dSJan Kara spin_lock(&dq_list_lock);
6996ff33d99SDmitry Monakhov /* Move list away to avoid livelock. */
7006ff33d99SDmitry Monakhov list_replace_init(&dqopt->info[cnt].dqi_dirty_list, &dirty);
7016ff33d99SDmitry Monakhov while (!list_empty(&dirty)) {
7026ff33d99SDmitry Monakhov dquot = list_first_entry(&dirty, struct dquot,
703268157baSJan Kara dq_dirty);
7044580b30eSJan Kara
70533bcfafcSBaokun Li WARN_ON(!dquot_active(dquot));
706869b6ea1SJan Kara /* If the dquot is releasing we should not touch it */
707869b6ea1SJan Kara if (test_bit(DQ_RELEASING_B, &dquot->dq_flags)) {
708869b6ea1SJan Kara spin_unlock(&dq_list_lock);
709869b6ea1SJan Kara flush_delayed_work("a_release_work);
710869b6ea1SJan Kara spin_lock(&dq_list_lock);
711869b6ea1SJan Kara continue;
712869b6ea1SJan Kara }
7134580b30eSJan Kara
714884d179dSJan Kara /* Now we have active dquot from which someone is
715884d179dSJan Kara * holding reference so we can safely just increase
716884d179dSJan Kara * use count */
7179f985cb6SJan Kara dqgrab(dquot);
718884d179dSJan Kara spin_unlock(&dq_list_lock);
71902412847SBaokun Li err = dquot_write_dquot(dquot);
72002412847SBaokun Li if (err && !ret)
721474d2605SJan Kara ret = err;
722884d179dSJan Kara dqput(dquot);
723884d179dSJan Kara spin_lock(&dq_list_lock);
724884d179dSJan Kara }
725884d179dSJan Kara spin_unlock(&dq_list_lock);
726884d179dSJan Kara }
727884d179dSJan Kara
728884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++)
729884d179dSJan Kara if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
730884d179dSJan Kara && info_dirty(&dqopt->info[cnt]))
731884d179dSJan Kara sb->dq_op->write_info(sb, cnt);
732dde95888SDmitry Monakhov dqstats_inc(DQST_SYNCS);
733884d179dSJan Kara
734ceed1723SJan Kara return ret;
735ceed1723SJan Kara }
736ceed1723SJan Kara EXPORT_SYMBOL(dquot_writeback_dquots);
737ceed1723SJan Kara
738ceed1723SJan Kara /* Write all dquot structures to disk and make them visible from userspace */
dquot_quota_sync(struct super_block * sb,int type)739ceed1723SJan Kara int dquot_quota_sync(struct super_block *sb, int type)
740ceed1723SJan Kara {
741ceed1723SJan Kara struct quota_info *dqopt = sb_dqopt(sb);
742ceed1723SJan Kara int cnt;
743ceed1723SJan Kara int ret;
744ceed1723SJan Kara
745ceed1723SJan Kara ret = dquot_writeback_dquots(sb, type);
746ceed1723SJan Kara if (ret)
747ceed1723SJan Kara return ret;
748ceed1723SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
7495fb324adSChristoph Hellwig return 0;
7505fb324adSChristoph Hellwig
7515fb324adSChristoph Hellwig /* This is not very clever (and fast) but currently I don't know about
7525fb324adSChristoph Hellwig * any other simple way of getting quota data to disk and we must get
7535fb324adSChristoph Hellwig * them there for userspace to be visible... */
754dd5532a4SDarrick J. Wong if (sb->s_op->sync_fs) {
755dd5532a4SDarrick J. Wong ret = sb->s_op->sync_fs(sb, 1);
756dd5532a4SDarrick J. Wong if (ret)
757dd5532a4SDarrick J. Wong return ret;
758dd5532a4SDarrick J. Wong }
759dd5532a4SDarrick J. Wong ret = sync_blockdev(sb->s_bdev);
760dd5532a4SDarrick J. Wong if (ret)
761dd5532a4SDarrick J. Wong return ret;
7625fb324adSChristoph Hellwig
7635fb324adSChristoph Hellwig /*
7645fb324adSChristoph Hellwig * Now when everything is written we can discard the pagecache so
7655fb324adSChristoph Hellwig * that userspace sees the changes.
7665fb324adSChristoph Hellwig */
7675fb324adSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
7685fb324adSChristoph Hellwig if (type != -1 && cnt != type)
7695fb324adSChristoph Hellwig continue;
7705fb324adSChristoph Hellwig if (!sb_has_quota_active(sb, cnt))
7715fb324adSChristoph Hellwig continue;
7725955102cSAl Viro inode_lock(dqopt->files[cnt]);
773f9ef1784SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
7745955102cSAl Viro inode_unlock(dqopt->files[cnt]);
7755fb324adSChristoph Hellwig }
7765fb324adSChristoph Hellwig
777884d179dSJan Kara return 0;
778884d179dSJan Kara }
779287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_sync);
780884d179dSJan Kara
7811ab6c499SDave Chinner static unsigned long
dqcache_shrink_scan(struct shrinker * shrink,struct shrink_control * sc)7821ab6c499SDave Chinner dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
783884d179dSJan Kara {
784884d179dSJan Kara struct dquot *dquot;
7851ab6c499SDave Chinner unsigned long freed = 0;
786884d179dSJan Kara
787d68aab6bSNiu Yawei spin_lock(&dq_list_lock);
7881822193bSJan Kara while (!list_empty(&free_dquots) && sc->nr_to_scan) {
7891822193bSJan Kara dquot = list_first_entry(&free_dquots, struct dquot, dq_free);
790884d179dSJan Kara remove_dquot_hash(dquot);
791884d179dSJan Kara remove_free_dquot(dquot);
792884d179dSJan Kara remove_inuse(dquot);
793884d179dSJan Kara do_destroy_dquot(dquot);
7941ab6c499SDave Chinner sc->nr_to_scan--;
7951ab6c499SDave Chinner freed++;
796884d179dSJan Kara }
797d68aab6bSNiu Yawei spin_unlock(&dq_list_lock);
7981ab6c499SDave Chinner return freed;
799884d179dSJan Kara }
800884d179dSJan Kara
8011ab6c499SDave Chinner static unsigned long
dqcache_shrink_count(struct shrinker * shrink,struct shrink_control * sc)8021ab6c499SDave Chinner dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
803884d179dSJan Kara {
80455f841ceSGlauber Costa return vfs_pressure_ratio(
80555f841ceSGlauber Costa percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]));
806884d179dSJan Kara }
807884d179dSJan Kara
808884d179dSJan Kara static struct shrinker dqcache_shrinker = {
8091ab6c499SDave Chinner .count_objects = dqcache_shrink_count,
8101ab6c499SDave Chinner .scan_objects = dqcache_shrink_scan,
811884d179dSJan Kara .seeks = DEFAULT_SEEKS,
812884d179dSJan Kara };
813884d179dSJan Kara
814884d179dSJan Kara /*
815dabc8b20SBaokun Li * Safely release dquot and put reference to dquot.
816dabc8b20SBaokun Li */
quota_release_workfn(struct work_struct * work)817dabc8b20SBaokun Li static void quota_release_workfn(struct work_struct *work)
818dabc8b20SBaokun Li {
819dabc8b20SBaokun Li struct dquot *dquot;
820dabc8b20SBaokun Li struct list_head rls_head;
821dabc8b20SBaokun Li
822dabc8b20SBaokun Li spin_lock(&dq_list_lock);
823dabc8b20SBaokun Li /* Exchange the list head to avoid livelock. */
824dabc8b20SBaokun Li list_replace_init(&releasing_dquots, &rls_head);
825dabc8b20SBaokun Li spin_unlock(&dq_list_lock);
826869b6ea1SJan Kara synchronize_srcu(&dquot_srcu);
827dabc8b20SBaokun Li
828dabc8b20SBaokun Li restart:
829dabc8b20SBaokun Li spin_lock(&dq_list_lock);
830dabc8b20SBaokun Li while (!list_empty(&rls_head)) {
831dabc8b20SBaokun Li dquot = list_first_entry(&rls_head, struct dquot, dq_free);
832869b6ea1SJan Kara WARN_ON_ONCE(atomic_read(&dquot->dq_count));
833869b6ea1SJan Kara /*
834869b6ea1SJan Kara * Note that DQ_RELEASING_B protects us from racing with
835869b6ea1SJan Kara * invalidate_dquots() calls so we are safe to work with the
836869b6ea1SJan Kara * dquot even after we drop dq_list_lock.
837869b6ea1SJan Kara */
838dabc8b20SBaokun Li if (dquot_dirty(dquot)) {
839dabc8b20SBaokun Li spin_unlock(&dq_list_lock);
840dabc8b20SBaokun Li /* Commit dquot before releasing */
841dabc8b20SBaokun Li dquot_write_dquot(dquot);
842dabc8b20SBaokun Li goto restart;
843dabc8b20SBaokun Li }
844dabc8b20SBaokun Li if (dquot_active(dquot)) {
845dabc8b20SBaokun Li spin_unlock(&dq_list_lock);
846dabc8b20SBaokun Li dquot->dq_sb->dq_op->release_dquot(dquot);
847dabc8b20SBaokun Li goto restart;
848dabc8b20SBaokun Li }
849dabc8b20SBaokun Li /* Dquot is inactive and clean, now move it to free list */
850dabc8b20SBaokun Li remove_free_dquot(dquot);
851dabc8b20SBaokun Li put_dquot_last(dquot);
852dabc8b20SBaokun Li }
853dabc8b20SBaokun Li spin_unlock(&dq_list_lock);
854dabc8b20SBaokun Li }
855dabc8b20SBaokun Li
856dabc8b20SBaokun Li /*
857884d179dSJan Kara * Put reference to dquot
858884d179dSJan Kara */
dqput(struct dquot * dquot)859884d179dSJan Kara void dqput(struct dquot *dquot)
860884d179dSJan Kara {
861884d179dSJan Kara if (!dquot)
862884d179dSJan Kara return;
86362af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG
864884d179dSJan Kara if (!atomic_read(&dquot->dq_count)) {
865fb5ffb0eSJiaying Zhang quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
8664c376dcaSEric W. Biederman quotatypes[dquot->dq_id.type],
8674c376dcaSEric W. Biederman from_kqid(&init_user_ns, dquot->dq_id));
868884d179dSJan Kara BUG();
869884d179dSJan Kara }
870884d179dSJan Kara #endif
871dde95888SDmitry Monakhov dqstats_inc(DQST_DROPS);
872dabc8b20SBaokun Li
873884d179dSJan Kara spin_lock(&dq_list_lock);
874884d179dSJan Kara if (atomic_read(&dquot->dq_count) > 1) {
875884d179dSJan Kara /* We have more than one user... nothing to do */
876884d179dSJan Kara atomic_dec(&dquot->dq_count);
877884d179dSJan Kara /* Releasing dquot during quotaoff phase? */
8784c376dcaSEric W. Biederman if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) &&
879884d179dSJan Kara atomic_read(&dquot->dq_count) == 1)
880503330f3SJan Kara wake_up(&dquot_ref_wq);
881884d179dSJan Kara spin_unlock(&dq_list_lock);
882884d179dSJan Kara return;
883884d179dSJan Kara }
884dabc8b20SBaokun Li
885884d179dSJan Kara /* Need to release dquot? */
88662af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG
887884d179dSJan Kara /* sanity check */
888884d179dSJan Kara BUG_ON(!list_empty(&dquot->dq_free));
889884d179dSJan Kara #endif
890dabc8b20SBaokun Li put_releasing_dquots(dquot);
891869b6ea1SJan Kara atomic_dec(&dquot->dq_count);
892884d179dSJan Kara spin_unlock(&dq_list_lock);
893dabc8b20SBaokun Li queue_delayed_work(system_unbound_wq, "a_release_work, 1);
894884d179dSJan Kara }
895884d179dSJan Kara EXPORT_SYMBOL(dqput);
896884d179dSJan Kara
dquot_alloc(struct super_block * sb,int type)897884d179dSJan Kara struct dquot *dquot_alloc(struct super_block *sb, int type)
898884d179dSJan Kara {
899884d179dSJan Kara return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
900884d179dSJan Kara }
901884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc);
902884d179dSJan Kara
get_empty_dquot(struct super_block * sb,int type)903884d179dSJan Kara static struct dquot *get_empty_dquot(struct super_block *sb, int type)
904884d179dSJan Kara {
905884d179dSJan Kara struct dquot *dquot;
906884d179dSJan Kara
907884d179dSJan Kara dquot = sb->dq_op->alloc_dquot(sb, type);
908884d179dSJan Kara if(!dquot)
909dd6f3c6dSJan Kara return NULL;
910884d179dSJan Kara
911884d179dSJan Kara mutex_init(&dquot->dq_lock);
912884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_free);
913884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_inuse);
914884d179dSJan Kara INIT_HLIST_NODE(&dquot->dq_hash);
915884d179dSJan Kara INIT_LIST_HEAD(&dquot->dq_dirty);
916884d179dSJan Kara dquot->dq_sb = sb;
9171a06d420SEric W. Biederman dquot->dq_id = make_kqid_invalid(type);
918884d179dSJan Kara atomic_set(&dquot->dq_count, 1);
9197b9ca4c6SJan Kara spin_lock_init(&dquot->dq_dqb_lock);
920884d179dSJan Kara
921884d179dSJan Kara return dquot;
922884d179dSJan Kara }
923884d179dSJan Kara
924884d179dSJan Kara /*
925884d179dSJan Kara * Get reference to dquot
926884d179dSJan Kara *
927884d179dSJan Kara * Locking is slightly tricky here. We are guarded from parallel quotaoff()
928884d179dSJan Kara * destroying our dquot by:
929884d179dSJan Kara * a) checking for quota flags under dq_list_lock and
930884d179dSJan Kara * b) getting a reference to dquot before we release dq_list_lock
931884d179dSJan Kara */
dqget(struct super_block * sb,struct kqid qid)932aca645a6SEric W. Biederman struct dquot *dqget(struct super_block *sb, struct kqid qid)
933884d179dSJan Kara {
9341a06d420SEric W. Biederman unsigned int hashent = hashfn(sb, qid);
9356184fc0bSJan Kara struct dquot *dquot, *empty = NULL;
936884d179dSJan Kara
937d49d3762SEric W. Biederman if (!qid_has_mapping(sb->s_user_ns, qid))
938d49d3762SEric W. Biederman return ERR_PTR(-EINVAL);
939d49d3762SEric W. Biederman
9401a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type))
9416184fc0bSJan Kara return ERR_PTR(-ESRCH);
942884d179dSJan Kara we_slept:
943884d179dSJan Kara spin_lock(&dq_list_lock);
944884d179dSJan Kara spin_lock(&dq_state_lock);
9451a06d420SEric W. Biederman if (!sb_has_quota_active(sb, qid.type)) {
946884d179dSJan Kara spin_unlock(&dq_state_lock);
947884d179dSJan Kara spin_unlock(&dq_list_lock);
9486184fc0bSJan Kara dquot = ERR_PTR(-ESRCH);
949884d179dSJan Kara goto out;
950884d179dSJan Kara }
951884d179dSJan Kara spin_unlock(&dq_state_lock);
952884d179dSJan Kara
9531a06d420SEric W. Biederman dquot = find_dquot(hashent, sb, qid);
954dd6f3c6dSJan Kara if (!dquot) {
955dd6f3c6dSJan Kara if (!empty) {
956884d179dSJan Kara spin_unlock(&dq_list_lock);
9571a06d420SEric W. Biederman empty = get_empty_dquot(sb, qid.type);
958dd6f3c6dSJan Kara if (!empty)
959884d179dSJan Kara schedule(); /* Try to wait for a moment... */
960884d179dSJan Kara goto we_slept;
961884d179dSJan Kara }
962884d179dSJan Kara dquot = empty;
963dd6f3c6dSJan Kara empty = NULL;
9644c376dcaSEric W. Biederman dquot->dq_id = qid;
965884d179dSJan Kara /* all dquots go on the inuse_list */
966884d179dSJan Kara put_inuse(dquot);
967884d179dSJan Kara /* hash it first so it can be found */
968884d179dSJan Kara insert_dquot_hash(dquot);
969884d179dSJan Kara spin_unlock(&dq_list_lock);
970dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS);
971884d179dSJan Kara } else {
972884d179dSJan Kara if (!atomic_read(&dquot->dq_count))
973884d179dSJan Kara remove_free_dquot(dquot);
974884d179dSJan Kara atomic_inc(&dquot->dq_count);
975884d179dSJan Kara spin_unlock(&dq_list_lock);
976dde95888SDmitry Monakhov dqstats_inc(DQST_CACHE_HITS);
977dde95888SDmitry Monakhov dqstats_inc(DQST_LOOKUPS);
978884d179dSJan Kara }
979268157baSJan Kara /* Wait for dq_lock - after this we know that either dquot_release() is
980869b6ea1SJan Kara * already finished or it will be canceled due to dq_count > 0 test */
981884d179dSJan Kara wait_on_dquot(dquot);
982268157baSJan Kara /* Read the dquot / allocate space in quota file */
98333bcfafcSBaokun Li if (!dquot_active(dquot)) {
9846184fc0bSJan Kara int err;
9856184fc0bSJan Kara
9866184fc0bSJan Kara err = sb->dq_op->acquire_dquot(dquot);
9876184fc0bSJan Kara if (err < 0) {
988884d179dSJan Kara dqput(dquot);
9896184fc0bSJan Kara dquot = ERR_PTR(err);
990884d179dSJan Kara goto out;
991884d179dSJan Kara }
9926184fc0bSJan Kara }
993044c9b67SJan Kara /*
994044c9b67SJan Kara * Make sure following reads see filled structure - paired with
995044c9b67SJan Kara * smp_mb__before_atomic() in dquot_acquire().
996044c9b67SJan Kara */
997044c9b67SJan Kara smp_rmb();
998*18b9264aSJan Kara /* Has somebody invalidated entry under us? */
999*18b9264aSJan Kara WARN_ON_ONCE(hlist_unhashed(&dquot->dq_hash));
1000884d179dSJan Kara out:
1001884d179dSJan Kara if (empty)
1002884d179dSJan Kara do_destroy_dquot(empty);
1003884d179dSJan Kara
1004884d179dSJan Kara return dquot;
1005884d179dSJan Kara }
1006884d179dSJan Kara EXPORT_SYMBOL(dqget);
1007884d179dSJan Kara
i_dquot(struct inode * inode)1008e45e8aa2SJan Kara static inline struct dquot __rcu **i_dquot(struct inode *inode)
10092d0fa467SJan Kara {
101042954c37SJan Kara return inode->i_sb->s_op->get_dquots(inode);
10112d0fa467SJan Kara }
10122d0fa467SJan Kara
dqinit_needed(struct inode * inode,int type)1013884d179dSJan Kara static int dqinit_needed(struct inode *inode, int type)
1014884d179dSJan Kara {
1015e45e8aa2SJan Kara struct dquot __rcu * const *dquots;
1016884d179dSJan Kara int cnt;
1017884d179dSJan Kara
1018884d179dSJan Kara if (IS_NOQUOTA(inode))
1019884d179dSJan Kara return 0;
10205bcd3b6fSKonstantin Khlebnikov
10215bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
1022884d179dSJan Kara if (type != -1)
10235bcd3b6fSKonstantin Khlebnikov return !dquots[type];
1024884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++)
10255bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt])
1026884d179dSJan Kara return 1;
1027884d179dSJan Kara return 0;
1028884d179dSJan Kara }
1029884d179dSJan Kara
1030c3b00446SJan Kara /* This routine is guarded by s_umount semaphore */
add_dquot_ref(struct super_block * sb,int type)10311a6152d3SChao Yu static int add_dquot_ref(struct super_block *sb, int type)
1032884d179dSJan Kara {
1033884d179dSJan Kara struct inode *inode, *old_inode = NULL;
103462af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG
10350a5a9c72SJan Kara int reserved = 0;
10364c5e6c0eSJan Kara #endif
10371a6152d3SChao Yu int err = 0;
1038884d179dSJan Kara
103974278da9SDave Chinner spin_lock(&sb->s_inode_list_lock);
1040884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1041250df6edSDave Chinner spin_lock(&inode->i_lock);
1042250df6edSDave Chinner if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
1043250df6edSDave Chinner !atomic_read(&inode->i_writecount) ||
1044250df6edSDave Chinner !dqinit_needed(inode, type)) {
1045250df6edSDave Chinner spin_unlock(&inode->i_lock);
10463ae5080fSLinus Torvalds continue;
1047250df6edSDave Chinner }
1048884d179dSJan Kara __iget(inode);
1049250df6edSDave Chinner spin_unlock(&inode->i_lock);
105074278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock);
1051884d179dSJan Kara
1052d7e97117SJan Kara #ifdef CONFIG_QUOTA_DEBUG
1053d7e97117SJan Kara if (unlikely(inode_get_rsv_space(inode) > 0))
1054d7e97117SJan Kara reserved = 1;
1055d7e97117SJan Kara #endif
1056884d179dSJan Kara iput(old_inode);
10571a6152d3SChao Yu err = __dquot_initialize(inode, type);
10581a6152d3SChao Yu if (err) {
10591a6152d3SChao Yu iput(inode);
10601a6152d3SChao Yu goto out;
10611a6152d3SChao Yu }
106255fa6091SDave Chinner
106355fa6091SDave Chinner /*
106455fa6091SDave Chinner * We hold a reference to 'inode' so it couldn't have been
106555fa6091SDave Chinner * removed from s_inodes list while we dropped the
106674278da9SDave Chinner * s_inode_list_lock. We cannot iput the inode now as we can be
106755fa6091SDave Chinner * holding the last reference and we cannot iput it under
106874278da9SDave Chinner * s_inode_list_lock. So we keep the reference and iput it
106955fa6091SDave Chinner * later.
107055fa6091SDave Chinner */
1071884d179dSJan Kara old_inode = inode;
107204646aebSEric Sandeen cond_resched();
107374278da9SDave Chinner spin_lock(&sb->s_inode_list_lock);
1074884d179dSJan Kara }
107574278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock);
1076884d179dSJan Kara iput(old_inode);
10771a6152d3SChao Yu out:
107862af9b52SJan Kara #ifdef CONFIG_QUOTA_DEBUG
10790a5a9c72SJan Kara if (reserved) {
1080fb5ffb0eSJiaying Zhang quota_error(sb, "Writes happened before quota was turned on "
1081fb5ffb0eSJiaying Zhang "thus quota information is probably inconsistent. "
1082fb5ffb0eSJiaying Zhang "Please run quotacheck(8)");
10830a5a9c72SJan Kara }
10844c5e6c0eSJan Kara #endif
10851a6152d3SChao Yu return err;
1086884d179dSJan Kara }
1087884d179dSJan Kara
remove_dquot_ref(struct super_block * sb,int type)10887bce48f0SBaokun Li static void remove_dquot_ref(struct super_block *sb, int type)
1089884d179dSJan Kara {
1090884d179dSJan Kara struct inode *inode;
109178bc3334SJiang Biao #ifdef CONFIG_QUOTA_DEBUG
10927af9cce8SDmitry Monakhov int reserved = 0;
109378bc3334SJiang Biao #endif
1094884d179dSJan Kara
109574278da9SDave Chinner spin_lock(&sb->s_inode_list_lock);
1096884d179dSJan Kara list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
10973ae5080fSLinus Torvalds /*
10983ae5080fSLinus Torvalds * We have to scan also I_NEW inodes because they can already
10993ae5080fSLinus Torvalds * have quota pointer initialized. Luckily, we need to touch
11003ae5080fSLinus Torvalds * only quota pointers and these have separate locking
1101b9ba6f94SNiu Yawei * (dq_data_lock).
11023ae5080fSLinus Torvalds */
1103b9ba6f94SNiu Yawei spin_lock(&dq_data_lock);
11047af9cce8SDmitry Monakhov if (!IS_NOQUOTA(inode)) {
1105e45e8aa2SJan Kara struct dquot __rcu **dquots = i_dquot(inode);
1106e45e8aa2SJan Kara struct dquot *dquot = srcu_dereference_check(
1107e45e8aa2SJan Kara dquots[type], &dquot_srcu,
1108e45e8aa2SJan Kara lockdep_is_held(&dq_data_lock));
11097bce48f0SBaokun Li
111078bc3334SJiang Biao #ifdef CONFIG_QUOTA_DEBUG
11117af9cce8SDmitry Monakhov if (unlikely(inode_get_rsv_space(inode) > 0))
11127af9cce8SDmitry Monakhov reserved = 1;
111378bc3334SJiang Biao #endif
1114e45e8aa2SJan Kara rcu_assign_pointer(dquots[type], NULL);
11157bce48f0SBaokun Li if (dquot)
11167bce48f0SBaokun Li dqput(dquot);
1117884d179dSJan Kara }
1118b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock);
11197af9cce8SDmitry Monakhov }
112074278da9SDave Chinner spin_unlock(&sb->s_inode_list_lock);
11217af9cce8SDmitry Monakhov #ifdef CONFIG_QUOTA_DEBUG
11227af9cce8SDmitry Monakhov if (reserved) {
11237af9cce8SDmitry Monakhov printk(KERN_WARNING "VFS (%s): Writes happened after quota"
11247af9cce8SDmitry Monakhov " was disabled thus quota information is probably "
11257af9cce8SDmitry Monakhov "inconsistent. Please run quotacheck(8).\n", sb->s_id);
11267af9cce8SDmitry Monakhov }
11277af9cce8SDmitry Monakhov #endif
1128884d179dSJan Kara }
1129884d179dSJan Kara
1130884d179dSJan Kara /* Gather all references from inodes and drop them */
drop_dquot_ref(struct super_block * sb,int type)1131884d179dSJan Kara static void drop_dquot_ref(struct super_block *sb, int type)
1132884d179dSJan Kara {
11337bce48f0SBaokun Li if (sb->dq_op)
11347bce48f0SBaokun Li remove_dquot_ref(sb, type);
1135884d179dSJan Kara }
1136884d179dSJan Kara
1137884d179dSJan Kara static inline
dquot_free_reserved_space(struct dquot * dquot,qsize_t number)1138884d179dSJan Kara void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1139884d179dSJan Kara {
11400a5a9c72SJan Kara if (dquot->dq_dqb.dqb_rsvspace >= number)
1141884d179dSJan Kara dquot->dq_dqb.dqb_rsvspace -= number;
11420a5a9c72SJan Kara else {
11430a5a9c72SJan Kara WARN_ON_ONCE(1);
11440a5a9c72SJan Kara dquot->dq_dqb.dqb_rsvspace = 0;
11450a5a9c72SJan Kara }
114641e327b5Szhangyi (F) if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <=
114741e327b5Szhangyi (F) dquot->dq_dqb.dqb_bsoftlimit)
114841e327b5Szhangyi (F) dquot->dq_dqb.dqb_btime = (time64_t) 0;
114941e327b5Szhangyi (F) clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1150884d179dSJan Kara }
1151884d179dSJan Kara
dquot_decr_inodes(struct dquot * dquot,qsize_t number)11527a2435d8SJan Kara static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
1153884d179dSJan Kara {
1154884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1155884d179dSJan Kara dquot->dq_dqb.dqb_curinodes >= number)
1156884d179dSJan Kara dquot->dq_dqb.dqb_curinodes -= number;
1157884d179dSJan Kara else
1158884d179dSJan Kara dquot->dq_dqb.dqb_curinodes = 0;
1159884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1160e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = (time64_t) 0;
1161884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags);
1162884d179dSJan Kara }
1163884d179dSJan Kara
dquot_decr_space(struct dquot * dquot,qsize_t number)11647a2435d8SJan Kara static void dquot_decr_space(struct dquot *dquot, qsize_t number)
1165884d179dSJan Kara {
1166884d179dSJan Kara if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1167884d179dSJan Kara dquot->dq_dqb.dqb_curspace >= number)
1168884d179dSJan Kara dquot->dq_dqb.dqb_curspace -= number;
1169884d179dSJan Kara else
1170884d179dSJan Kara dquot->dq_dqb.dqb_curspace = 0;
117141e327b5Szhangyi (F) if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <=
117241e327b5Szhangyi (F) dquot->dq_dqb.dqb_bsoftlimit)
1173e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = (time64_t) 0;
1174884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1175884d179dSJan Kara }
1176884d179dSJan Kara
1177bf097aafSJan Kara struct dquot_warn {
1178bf097aafSJan Kara struct super_block *w_sb;
11797b9c7321SEric W. Biederman struct kqid w_dq_id;
1180bf097aafSJan Kara short w_type;
1181bf097aafSJan Kara };
1182bf097aafSJan Kara
warning_issued(struct dquot * dquot,const int warntype)1183884d179dSJan Kara static int warning_issued(struct dquot *dquot, const int warntype)
1184884d179dSJan Kara {
1185884d179dSJan Kara int flag = (warntype == QUOTA_NL_BHARDWARN ||
1186884d179dSJan Kara warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1187884d179dSJan Kara ((warntype == QUOTA_NL_IHARDWARN ||
1188884d179dSJan Kara warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1189884d179dSJan Kara
1190884d179dSJan Kara if (!flag)
1191884d179dSJan Kara return 0;
1192884d179dSJan Kara return test_and_set_bit(flag, &dquot->dq_flags);
1193884d179dSJan Kara }
1194884d179dSJan Kara
1195884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING
1196884d179dSJan Kara static int flag_print_warnings = 1;
1197884d179dSJan Kara
need_print_warning(struct dquot_warn * warn)1198bf097aafSJan Kara static int need_print_warning(struct dquot_warn *warn)
1199884d179dSJan Kara {
1200884d179dSJan Kara if (!flag_print_warnings)
1201884d179dSJan Kara return 0;
1202884d179dSJan Kara
12037b9c7321SEric W. Biederman switch (warn->w_dq_id.type) {
1204884d179dSJan Kara case USRQUOTA:
12051a06d420SEric W. Biederman return uid_eq(current_fsuid(), warn->w_dq_id.uid);
1206884d179dSJan Kara case GRPQUOTA:
12077b9c7321SEric W. Biederman return in_group_p(warn->w_dq_id.gid);
1208847aac64SLi Xi case PRJQUOTA:
1209847aac64SLi Xi return 1;
1210884d179dSJan Kara }
1211884d179dSJan Kara return 0;
1212884d179dSJan Kara }
1213884d179dSJan Kara
1214884d179dSJan Kara /* Print warning to user which exceeded quota */
print_warning(struct dquot_warn * warn)1215bf097aafSJan Kara static void print_warning(struct dquot_warn *warn)
1216884d179dSJan Kara {
1217884d179dSJan Kara char *msg = NULL;
1218884d179dSJan Kara struct tty_struct *tty;
1219bf097aafSJan Kara int warntype = warn->w_type;
1220884d179dSJan Kara
1221884d179dSJan Kara if (warntype == QUOTA_NL_IHARDBELOW ||
1222884d179dSJan Kara warntype == QUOTA_NL_ISOFTBELOW ||
1223884d179dSJan Kara warntype == QUOTA_NL_BHARDBELOW ||
1224bf097aafSJan Kara warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
1225884d179dSJan Kara return;
1226884d179dSJan Kara
1227884d179dSJan Kara tty = get_current_tty();
1228884d179dSJan Kara if (!tty)
1229884d179dSJan Kara return;
1230bf097aafSJan Kara tty_write_message(tty, warn->w_sb->s_id);
1231884d179dSJan Kara if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
1232884d179dSJan Kara tty_write_message(tty, ": warning, ");
1233884d179dSJan Kara else
1234884d179dSJan Kara tty_write_message(tty, ": write failed, ");
12357b9c7321SEric W. Biederman tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
1236884d179dSJan Kara switch (warntype) {
1237884d179dSJan Kara case QUOTA_NL_IHARDWARN:
1238884d179dSJan Kara msg = " file limit reached.\r\n";
1239884d179dSJan Kara break;
1240884d179dSJan Kara case QUOTA_NL_ISOFTLONGWARN:
1241884d179dSJan Kara msg = " file quota exceeded too long.\r\n";
1242884d179dSJan Kara break;
1243884d179dSJan Kara case QUOTA_NL_ISOFTWARN:
1244884d179dSJan Kara msg = " file quota exceeded.\r\n";
1245884d179dSJan Kara break;
1246884d179dSJan Kara case QUOTA_NL_BHARDWARN:
1247884d179dSJan Kara msg = " block limit reached.\r\n";
1248884d179dSJan Kara break;
1249884d179dSJan Kara case QUOTA_NL_BSOFTLONGWARN:
1250884d179dSJan Kara msg = " block quota exceeded too long.\r\n";
1251884d179dSJan Kara break;
1252884d179dSJan Kara case QUOTA_NL_BSOFTWARN:
1253884d179dSJan Kara msg = " block quota exceeded.\r\n";
1254884d179dSJan Kara break;
1255884d179dSJan Kara }
1256884d179dSJan Kara tty_write_message(tty, msg);
1257884d179dSJan Kara tty_kref_put(tty);
1258884d179dSJan Kara }
1259884d179dSJan Kara #endif
1260884d179dSJan Kara
prepare_warning(struct dquot_warn * warn,struct dquot * dquot,int warntype)1261bf097aafSJan Kara static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1262bf097aafSJan Kara int warntype)
1263bf097aafSJan Kara {
1264bf097aafSJan Kara if (warning_issued(dquot, warntype))
1265bf097aafSJan Kara return;
1266bf097aafSJan Kara warn->w_type = warntype;
1267bf097aafSJan Kara warn->w_sb = dquot->dq_sb;
1268bf097aafSJan Kara warn->w_dq_id = dquot->dq_id;
1269bf097aafSJan Kara }
1270bf097aafSJan Kara
1271884d179dSJan Kara /*
1272884d179dSJan Kara * Write warnings to the console and send warning messages over netlink.
1273884d179dSJan Kara *
1274bf097aafSJan Kara * Note that this function can call into tty and networking code.
1275884d179dSJan Kara */
flush_warnings(struct dquot_warn * warn)1276bf097aafSJan Kara static void flush_warnings(struct dquot_warn *warn)
1277884d179dSJan Kara {
1278884d179dSJan Kara int i;
1279884d179dSJan Kara
128086e931a3SSteven Whitehouse for (i = 0; i < MAXQUOTAS; i++) {
1281bf097aafSJan Kara if (warn[i].w_type == QUOTA_NL_NOWARN)
1282bf097aafSJan Kara continue;
1283884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING
1284bf097aafSJan Kara print_warning(&warn[i]);
1285884d179dSJan Kara #endif
12867b9c7321SEric W. Biederman quota_send_warning(warn[i].w_dq_id,
1287bf097aafSJan Kara warn[i].w_sb->s_dev, warn[i].w_type);
1288884d179dSJan Kara }
1289884d179dSJan Kara }
1290884d179dSJan Kara
ignore_hardlimit(struct dquot * dquot)12917a2435d8SJan Kara static int ignore_hardlimit(struct dquot *dquot)
1292884d179dSJan Kara {
12934c376dcaSEric W. Biederman struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
1294884d179dSJan Kara
1295884d179dSJan Kara return capable(CAP_SYS_RESOURCE) &&
1296268157baSJan Kara (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
12979c45101eSJan Kara !(info->dqi_flags & DQF_ROOT_SQUASH));
1298884d179dSJan Kara }
1299884d179dSJan Kara
dquot_add_inodes(struct dquot * dquot,qsize_t inodes,struct dquot_warn * warn)13007b9ca4c6SJan Kara static int dquot_add_inodes(struct dquot *dquot, qsize_t inodes,
1301bf097aafSJan Kara struct dquot_warn *warn)
1302884d179dSJan Kara {
13037b9ca4c6SJan Kara qsize_t newinodes;
13047b9ca4c6SJan Kara int ret = 0;
1305268157baSJan Kara
13067b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock);
13077b9ca4c6SJan Kara newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
13084c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) ||
1309884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags))
13107b9ca4c6SJan Kara goto add;
1311884d179dSJan Kara
1312884d179dSJan Kara if (dquot->dq_dqb.dqb_ihardlimit &&
1313268157baSJan Kara newinodes > dquot->dq_dqb.dqb_ihardlimit &&
1314884d179dSJan Kara !ignore_hardlimit(dquot)) {
1315bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
13167b9ca4c6SJan Kara ret = -EDQUOT;
13177b9ca4c6SJan Kara goto out;
1318884d179dSJan Kara }
1319884d179dSJan Kara
1320884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit &&
1321268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1322268157baSJan Kara dquot->dq_dqb.dqb_itime &&
1323e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_itime &&
1324884d179dSJan Kara !ignore_hardlimit(dquot)) {
1325bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
13267b9ca4c6SJan Kara ret = -EDQUOT;
13277b9ca4c6SJan Kara goto out;
1328884d179dSJan Kara }
1329884d179dSJan Kara
1330884d179dSJan Kara if (dquot->dq_dqb.dqb_isoftlimit &&
1331268157baSJan Kara newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1332884d179dSJan Kara dquot->dq_dqb.dqb_itime == 0) {
1333bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
1334e008bb61SArnd Bergmann dquot->dq_dqb.dqb_itime = ktime_get_real_seconds() +
13354c376dcaSEric W. Biederman sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
1336884d179dSJan Kara }
13377b9ca4c6SJan Kara add:
13387b9ca4c6SJan Kara dquot->dq_dqb.dqb_curinodes = newinodes;
1339884d179dSJan Kara
13407b9ca4c6SJan Kara out:
13417b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock);
13427b9ca4c6SJan Kara return ret;
1343884d179dSJan Kara }
1344884d179dSJan Kara
dquot_add_space(struct dquot * dquot,qsize_t space,qsize_t rsv_space,unsigned int flags,struct dquot_warn * warn)13457b9ca4c6SJan Kara static int dquot_add_space(struct dquot *dquot, qsize_t space,
13467b9ca4c6SJan Kara qsize_t rsv_space, unsigned int flags,
1347bf097aafSJan Kara struct dquot_warn *warn)
1348884d179dSJan Kara {
1349884d179dSJan Kara qsize_t tspace;
1350268157baSJan Kara struct super_block *sb = dquot->dq_sb;
13517b9ca4c6SJan Kara int ret = 0;
1352884d179dSJan Kara
13537b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock);
13544c376dcaSEric W. Biederman if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) ||
1355884d179dSJan Kara test_bit(DQ_FAKE_B, &dquot->dq_flags))
1356ac3d7939SJan Kara goto finish;
1357884d179dSJan Kara
1358884d179dSJan Kara tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
13597b9ca4c6SJan Kara + space + rsv_space;
13607b9ca4c6SJan Kara
1361884d179dSJan Kara if (dquot->dq_dqb.dqb_bhardlimit &&
1362884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bhardlimit &&
1363884d179dSJan Kara !ignore_hardlimit(dquot)) {
13647b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN)
1365bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
13667b9ca4c6SJan Kara ret = -EDQUOT;
1367ac3d7939SJan Kara goto finish;
1368884d179dSJan Kara }
1369884d179dSJan Kara
1370884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit &&
1371884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1372268157baSJan Kara dquot->dq_dqb.dqb_btime &&
1373e008bb61SArnd Bergmann ktime_get_real_seconds() >= dquot->dq_dqb.dqb_btime &&
1374884d179dSJan Kara !ignore_hardlimit(dquot)) {
13757b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN)
1376bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
13777b9ca4c6SJan Kara ret = -EDQUOT;
1378ac3d7939SJan Kara goto finish;
1379884d179dSJan Kara }
1380884d179dSJan Kara
1381884d179dSJan Kara if (dquot->dq_dqb.dqb_bsoftlimit &&
1382884d179dSJan Kara tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1383884d179dSJan Kara dquot->dq_dqb.dqb_btime == 0) {
13847b9ca4c6SJan Kara if (flags & DQUOT_SPACE_WARN) {
1385bf097aafSJan Kara prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
1386e008bb61SArnd Bergmann dquot->dq_dqb.dqb_btime = ktime_get_real_seconds() +
13874c376dcaSEric W. Biederman sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
13887b9ca4c6SJan Kara } else {
1389884d179dSJan Kara /*
1390884d179dSJan Kara * We don't allow preallocation to exceed softlimit so exceeding will
1391884d179dSJan Kara * be always printed
1392884d179dSJan Kara */
13937b9ca4c6SJan Kara ret = -EDQUOT;
1394ac3d7939SJan Kara goto finish;
1395884d179dSJan Kara }
13967b9ca4c6SJan Kara }
1397ac3d7939SJan Kara finish:
1398ac3d7939SJan Kara /*
1399ac3d7939SJan Kara * We have to be careful and go through warning generation & grace time
1400ac3d7939SJan Kara * setting even if DQUOT_SPACE_NOFAIL is set. That's why we check it
1401ac3d7939SJan Kara * only here...
1402ac3d7939SJan Kara */
1403ac3d7939SJan Kara if (flags & DQUOT_SPACE_NOFAIL)
1404ac3d7939SJan Kara ret = 0;
1405ac3d7939SJan Kara if (!ret) {
14067b9ca4c6SJan Kara dquot->dq_dqb.dqb_rsvspace += rsv_space;
14077b9ca4c6SJan Kara dquot->dq_dqb.dqb_curspace += space;
1408ac3d7939SJan Kara }
14097b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock);
14107b9ca4c6SJan Kara return ret;
1411884d179dSJan Kara }
1412884d179dSJan Kara
info_idq_free(struct dquot * dquot,qsize_t inodes)1413884d179dSJan Kara static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1414884d179dSJan Kara {
1415268157baSJan Kara qsize_t newinodes;
1416268157baSJan Kara
1417884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1418884d179dSJan Kara dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
14194c376dcaSEric W. Biederman !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type))
1420884d179dSJan Kara return QUOTA_NL_NOWARN;
1421884d179dSJan Kara
1422268157baSJan Kara newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1423268157baSJan Kara if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1424884d179dSJan Kara return QUOTA_NL_ISOFTBELOW;
1425884d179dSJan Kara if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
1426268157baSJan Kara newinodes < dquot->dq_dqb.dqb_ihardlimit)
1427884d179dSJan Kara return QUOTA_NL_IHARDBELOW;
1428884d179dSJan Kara return QUOTA_NL_NOWARN;
1429884d179dSJan Kara }
1430884d179dSJan Kara
info_bdq_free(struct dquot * dquot,qsize_t space)1431884d179dSJan Kara static int info_bdq_free(struct dquot *dquot, qsize_t space)
1432884d179dSJan Kara {
143341e327b5Szhangyi (F) qsize_t tspace;
143441e327b5Szhangyi (F)
143541e327b5Szhangyi (F) tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace;
143641e327b5Szhangyi (F)
1437884d179dSJan Kara if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
143841e327b5Szhangyi (F) tspace <= dquot->dq_dqb.dqb_bsoftlimit)
1439884d179dSJan Kara return QUOTA_NL_NOWARN;
1440884d179dSJan Kara
144141e327b5Szhangyi (F) if (tspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
1442884d179dSJan Kara return QUOTA_NL_BSOFTBELOW;
144341e327b5Szhangyi (F) if (tspace >= dquot->dq_dqb.dqb_bhardlimit &&
144441e327b5Szhangyi (F) tspace - space < dquot->dq_dqb.dqb_bhardlimit)
1445884d179dSJan Kara return QUOTA_NL_BHARDBELOW;
1446884d179dSJan Kara return QUOTA_NL_NOWARN;
1447884d179dSJan Kara }
14480a5a9c72SJan Kara
inode_quota_active(const struct inode * inode)14494b9bdfa1SBaokun Li static int inode_quota_active(const struct inode *inode)
1450189eef59SChristoph Hellwig {
1451189eef59SChristoph Hellwig struct super_block *sb = inode->i_sb;
1452189eef59SChristoph Hellwig
1453189eef59SChristoph Hellwig if (IS_NOQUOTA(inode))
1454189eef59SChristoph Hellwig return 0;
1455189eef59SChristoph Hellwig return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1456189eef59SChristoph Hellwig }
1457189eef59SChristoph Hellwig
1458884d179dSJan Kara /*
1459884d179dSJan Kara * Initialize quota pointers in inode
1460871a2931SChristoph Hellwig *
1461871a2931SChristoph Hellwig * It is better to call this function outside of any transaction as it
1462871a2931SChristoph Hellwig * might need a lot of space in journal for dquot structure allocation.
1463884d179dSJan Kara */
__dquot_initialize(struct inode * inode,int type)14646184fc0bSJan Kara static int __dquot_initialize(struct inode *inode, int type)
1465884d179dSJan Kara {
14661ea06becSNiu Yawei int cnt, init_needed = 0;
1467e45e8aa2SJan Kara struct dquot __rcu **dquots;
1468e45e8aa2SJan Kara struct dquot *got[MAXQUOTAS] = {};
1469884d179dSJan Kara struct super_block *sb = inode->i_sb;
14700a5a9c72SJan Kara qsize_t rsv;
14716184fc0bSJan Kara int ret = 0;
1472884d179dSJan Kara
14734b9bdfa1SBaokun Li if (!inode_quota_active(inode))
14746184fc0bSJan Kara return 0;
1475884d179dSJan Kara
14765bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
14775bcd3b6fSKonstantin Khlebnikov
1478884d179dSJan Kara /* First get references to structures we might need. */
1479884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1480aca645a6SEric W. Biederman struct kqid qid;
1481847aac64SLi Xi kprojid_t projid;
1482847aac64SLi Xi int rc;
14836184fc0bSJan Kara struct dquot *dquot;
1484847aac64SLi Xi
1485884d179dSJan Kara if (type != -1 && cnt != type)
1486884d179dSJan Kara continue;
14871ea06becSNiu Yawei /*
14881ea06becSNiu Yawei * The i_dquot should have been initialized in most cases,
14891ea06becSNiu Yawei * we check it without locking here to avoid unnecessary
14901ea06becSNiu Yawei * dqget()/dqput() calls.
14911ea06becSNiu Yawei */
14925bcd3b6fSKonstantin Khlebnikov if (dquots[cnt])
14931ea06becSNiu Yawei continue;
1494847aac64SLi Xi
1495847aac64SLi Xi if (!sb_has_quota_active(sb, cnt))
1496847aac64SLi Xi continue;
1497847aac64SLi Xi
14981ea06becSNiu Yawei init_needed = 1;
14991ea06becSNiu Yawei
1500884d179dSJan Kara switch (cnt) {
1501884d179dSJan Kara case USRQUOTA:
1502aca645a6SEric W. Biederman qid = make_kqid_uid(inode->i_uid);
1503884d179dSJan Kara break;
1504884d179dSJan Kara case GRPQUOTA:
1505aca645a6SEric W. Biederman qid = make_kqid_gid(inode->i_gid);
1506884d179dSJan Kara break;
1507847aac64SLi Xi case PRJQUOTA:
1508847aac64SLi Xi rc = inode->i_sb->dq_op->get_projid(inode, &projid);
1509847aac64SLi Xi if (rc)
1510847aac64SLi Xi continue;
1511847aac64SLi Xi qid = make_kqid_projid(projid);
1512847aac64SLi Xi break;
1513884d179dSJan Kara }
15146184fc0bSJan Kara dquot = dqget(sb, qid);
15156184fc0bSJan Kara if (IS_ERR(dquot)) {
15166184fc0bSJan Kara /* We raced with somebody turning quotas off... */
15176184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) {
15186184fc0bSJan Kara ret = PTR_ERR(dquot);
15196184fc0bSJan Kara goto out_put;
15206184fc0bSJan Kara }
15216184fc0bSJan Kara dquot = NULL;
15226184fc0bSJan Kara }
15236184fc0bSJan Kara got[cnt] = dquot;
1524884d179dSJan Kara }
1525884d179dSJan Kara
15261ea06becSNiu Yawei /* All required i_dquot has been initialized */
15271ea06becSNiu Yawei if (!init_needed)
15286184fc0bSJan Kara return 0;
15291ea06becSNiu Yawei
1530b9ba6f94SNiu Yawei spin_lock(&dq_data_lock);
1531884d179dSJan Kara if (IS_NOQUOTA(inode))
15326184fc0bSJan Kara goto out_lock;
1533884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1534884d179dSJan Kara if (type != -1 && cnt != type)
1535884d179dSJan Kara continue;
1536884d179dSJan Kara /* Avoid races with quotaoff() */
1537884d179dSJan Kara if (!sb_has_quota_active(sb, cnt))
1538884d179dSJan Kara continue;
15394408ea41SJan Kara /* We could race with quotaon or dqget() could have failed */
15404408ea41SJan Kara if (!got[cnt])
15414408ea41SJan Kara continue;
15425bcd3b6fSKonstantin Khlebnikov if (!dquots[cnt]) {
1543e45e8aa2SJan Kara rcu_assign_pointer(dquots[cnt], got[cnt]);
1544dd6f3c6dSJan Kara got[cnt] = NULL;
15450a5a9c72SJan Kara /*
15460a5a9c72SJan Kara * Make quota reservation system happy if someone
15470a5a9c72SJan Kara * did a write before quota was turned on
15480a5a9c72SJan Kara */
15490a5a9c72SJan Kara rsv = inode_get_rsv_space(inode);
15507b9ca4c6SJan Kara if (unlikely(rsv)) {
1551e45e8aa2SJan Kara struct dquot *dquot = srcu_dereference_check(
1552e45e8aa2SJan Kara dquots[cnt], &dquot_srcu,
1553e45e8aa2SJan Kara lockdep_is_held(&dq_data_lock));
1554e45e8aa2SJan Kara
15557b9ca4c6SJan Kara spin_lock(&inode->i_lock);
15567b9ca4c6SJan Kara /* Get reservation again under proper lock */
15577b9ca4c6SJan Kara rsv = __inode_get_rsv_space(inode);
1558e45e8aa2SJan Kara spin_lock(&dquot->dq_dqb_lock);
1559e45e8aa2SJan Kara dquot->dq_dqb.dqb_rsvspace += rsv;
1560e45e8aa2SJan Kara spin_unlock(&dquot->dq_dqb_lock);
15617b9ca4c6SJan Kara spin_unlock(&inode->i_lock);
15627b9ca4c6SJan Kara }
1563884d179dSJan Kara }
1564884d179dSJan Kara }
15656184fc0bSJan Kara out_lock:
1566b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock);
15676184fc0bSJan Kara out_put:
1568884d179dSJan Kara /* Drop unused references */
1569dc52dd3aSDmitry Monakhov dqput_all(got);
15706184fc0bSJan Kara
15716184fc0bSJan Kara return ret;
1572871a2931SChristoph Hellwig }
1573871a2931SChristoph Hellwig
dquot_initialize(struct inode * inode)15746184fc0bSJan Kara int dquot_initialize(struct inode *inode)
1575871a2931SChristoph Hellwig {
15766184fc0bSJan Kara return __dquot_initialize(inode, -1);
1577884d179dSJan Kara }
1578884d179dSJan Kara EXPORT_SYMBOL(dquot_initialize);
1579884d179dSJan Kara
dquot_initialize_needed(struct inode * inode)1580b8cb5a54STahsin Erdogan bool dquot_initialize_needed(struct inode *inode)
1581b8cb5a54STahsin Erdogan {
1582e45e8aa2SJan Kara struct dquot __rcu **dquots;
1583b8cb5a54STahsin Erdogan int i;
1584b8cb5a54STahsin Erdogan
15854b9bdfa1SBaokun Li if (!inode_quota_active(inode))
1586b8cb5a54STahsin Erdogan return false;
1587b8cb5a54STahsin Erdogan
1588b8cb5a54STahsin Erdogan dquots = i_dquot(inode);
1589b8cb5a54STahsin Erdogan for (i = 0; i < MAXQUOTAS; i++)
1590b8cb5a54STahsin Erdogan if (!dquots[i] && sb_has_quota_active(inode->i_sb, i))
1591b8cb5a54STahsin Erdogan return true;
1592b8cb5a54STahsin Erdogan return false;
1593b8cb5a54STahsin Erdogan }
1594b8cb5a54STahsin Erdogan EXPORT_SYMBOL(dquot_initialize_needed);
1595b8cb5a54STahsin Erdogan
1596884d179dSJan Kara /*
1597b9ba6f94SNiu Yawei * Release all quotas referenced by inode.
1598b9ba6f94SNiu Yawei *
1599b9ba6f94SNiu Yawei * This function only be called on inode free or converting
1600b9ba6f94SNiu Yawei * a file to quota file, no other users for the i_dquot in
1601b9ba6f94SNiu Yawei * both cases, so we needn't call synchronize_srcu() after
1602b9ba6f94SNiu Yawei * clearing i_dquot.
1603884d179dSJan Kara */
__dquot_drop(struct inode * inode)16049f754758SChristoph Hellwig static void __dquot_drop(struct inode *inode)
1605884d179dSJan Kara {
1606884d179dSJan Kara int cnt;
1607e45e8aa2SJan Kara struct dquot __rcu **dquots = i_dquot(inode);
1608884d179dSJan Kara struct dquot *put[MAXQUOTAS];
1609884d179dSJan Kara
1610b9ba6f94SNiu Yawei spin_lock(&dq_data_lock);
1611884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1612e45e8aa2SJan Kara put[cnt] = srcu_dereference_check(dquots[cnt], &dquot_srcu,
1613e45e8aa2SJan Kara lockdep_is_held(&dq_data_lock));
1614e45e8aa2SJan Kara rcu_assign_pointer(dquots[cnt], NULL);
1615884d179dSJan Kara }
1616b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock);
1617dc52dd3aSDmitry Monakhov dqput_all(put);
1618884d179dSJan Kara }
1619884d179dSJan Kara
dquot_drop(struct inode * inode)16209f754758SChristoph Hellwig void dquot_drop(struct inode *inode)
1621884d179dSJan Kara {
1622e45e8aa2SJan Kara struct dquot __rcu * const *dquots;
1623884d179dSJan Kara int cnt;
16249f754758SChristoph Hellwig
16259f754758SChristoph Hellwig if (IS_NOQUOTA(inode))
16269f754758SChristoph Hellwig return;
16279f754758SChristoph Hellwig
16289f754758SChristoph Hellwig /*
16299f754758SChristoph Hellwig * Test before calling to rule out calls from proc and such
1630884d179dSJan Kara * where we are not allowed to block. Note that this is
1631884d179dSJan Kara * actually reliable test even without the lock - the caller
1632884d179dSJan Kara * must assure that nobody can come after the DQUOT_DROP and
16339f754758SChristoph Hellwig * add quota pointers back anyway.
16349f754758SChristoph Hellwig */
16355bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
16369f754758SChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
16375bcd3b6fSKonstantin Khlebnikov if (dquots[cnt])
1638884d179dSJan Kara break;
16399f754758SChristoph Hellwig }
16409f754758SChristoph Hellwig
1641884d179dSJan Kara if (cnt < MAXQUOTAS)
16429f754758SChristoph Hellwig __dquot_drop(inode);
1643884d179dSJan Kara }
16449f754758SChristoph Hellwig EXPORT_SYMBOL(dquot_drop);
1645884d179dSJan Kara
1646884d179dSJan Kara /*
1647fd8fbfc1SDmitry Monakhov * inode_reserved_space is managed internally by quota, and protected by
1648fd8fbfc1SDmitry Monakhov * i_lock similar to i_blocks+i_bytes.
1649fd8fbfc1SDmitry Monakhov */
inode_reserved_space(struct inode * inode)1650fd8fbfc1SDmitry Monakhov static qsize_t *inode_reserved_space(struct inode * inode)
1651fd8fbfc1SDmitry Monakhov {
1652fd8fbfc1SDmitry Monakhov /* Filesystem must explicitly define it's own method in order to use
1653fd8fbfc1SDmitry Monakhov * quota reservation interface */
1654fd8fbfc1SDmitry Monakhov BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1655fd8fbfc1SDmitry Monakhov return inode->i_sb->dq_op->get_reserved_space(inode);
1656fd8fbfc1SDmitry Monakhov }
1657fd8fbfc1SDmitry Monakhov
__inode_get_rsv_space(struct inode * inode)16587b9ca4c6SJan Kara static qsize_t __inode_get_rsv_space(struct inode *inode)
1659fd8fbfc1SDmitry Monakhov {
16607b9ca4c6SJan Kara if (!inode->i_sb->dq_op->get_reserved_space)
16617b9ca4c6SJan Kara return 0;
16627b9ca4c6SJan Kara return *inode_reserved_space(inode);
1663fd8fbfc1SDmitry Monakhov }
1664fd8fbfc1SDmitry Monakhov
inode_get_rsv_space(struct inode * inode)1665fd8fbfc1SDmitry Monakhov static qsize_t inode_get_rsv_space(struct inode *inode)
1666fd8fbfc1SDmitry Monakhov {
1667fd8fbfc1SDmitry Monakhov qsize_t ret;
166805b5d898SJan Kara
166905b5d898SJan Kara if (!inode->i_sb->dq_op->get_reserved_space)
167005b5d898SJan Kara return 0;
1671fd8fbfc1SDmitry Monakhov spin_lock(&inode->i_lock);
16727b9ca4c6SJan Kara ret = __inode_get_rsv_space(inode);
1673fd8fbfc1SDmitry Monakhov spin_unlock(&inode->i_lock);
1674fd8fbfc1SDmitry Monakhov return ret;
1675fd8fbfc1SDmitry Monakhov }
1676fd8fbfc1SDmitry Monakhov
1677fd8fbfc1SDmitry Monakhov /*
16785dd4056dSChristoph Hellwig * This functions updates i_blocks+i_bytes fields and quota information
16795dd4056dSChristoph Hellwig * (together with appropriate checks).
16805dd4056dSChristoph Hellwig *
16815dd4056dSChristoph Hellwig * NOTE: We absolutely rely on the fact that caller dirties the inode
16825dd4056dSChristoph Hellwig * (usually helpers in quotaops.h care about this) and holds a handle for
16835dd4056dSChristoph Hellwig * the current transaction so that dquot write and inode write go into the
16845dd4056dSChristoph Hellwig * same transaction.
1685884d179dSJan Kara */
1686884d179dSJan Kara
1687884d179dSJan Kara /*
1688884d179dSJan Kara * This operation can block, but only after everything is updated
1689884d179dSJan Kara */
__dquot_alloc_space(struct inode * inode,qsize_t number,int flags)169056246f9aSEric Sandeen int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
1691884d179dSJan Kara {
1692b9ba6f94SNiu Yawei int cnt, ret = 0, index;
1693bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS];
169456246f9aSEric Sandeen int reserve = flags & DQUOT_SPACE_RESERVE;
1695e45e8aa2SJan Kara struct dquot __rcu **dquots;
169640a673b4SWang Jianjian struct dquot *dquot;
1697884d179dSJan Kara
16984b9bdfa1SBaokun Li if (!inode_quota_active(inode)) {
1699a478e522SJan Kara if (reserve) {
1700a478e522SJan Kara spin_lock(&inode->i_lock);
1701a478e522SJan Kara *inode_reserved_space(inode) += number;
1702a478e522SJan Kara spin_unlock(&inode->i_lock);
1703a478e522SJan Kara } else {
1704a478e522SJan Kara inode_add_bytes(inode, number);
1705a478e522SJan Kara }
1706fd8fbfc1SDmitry Monakhov goto out;
1707fd8fbfc1SDmitry Monakhov }
1708fd8fbfc1SDmitry Monakhov
1709884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1710bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN;
1711884d179dSJan Kara
17125bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
1713b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu);
17147b9ca4c6SJan Kara spin_lock(&inode->i_lock);
1715884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
171640a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
171740a673b4SWang Jianjian if (!dquot)
1718884d179dSJan Kara continue;
1719df15a2a5SChengguang Xu if (reserve) {
172040a673b4SWang Jianjian ret = dquot_add_space(dquot, 0, number, flags, &warn[cnt]);
17217b9ca4c6SJan Kara } else {
172240a673b4SWang Jianjian ret = dquot_add_space(dquot, number, 0, flags, &warn[cnt]);
17237b9ca4c6SJan Kara }
17247b9ca4c6SJan Kara if (ret) {
17257b9ca4c6SJan Kara /* Back out changes we already did */
17267b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) {
172740a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
172840a673b4SWang Jianjian if (!dquot)
17297b9ca4c6SJan Kara continue;
173040a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock);
1731632a9f3aSChengguang Xu if (reserve)
173240a673b4SWang Jianjian dquot_free_reserved_space(dquot, number);
1733632a9f3aSChengguang Xu else
173440a673b4SWang Jianjian dquot_decr_space(dquot, number);
173540a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock);
17367b9ca4c6SJan Kara }
17377b9ca4c6SJan Kara spin_unlock(&inode->i_lock);
1738fd8fbfc1SDmitry Monakhov goto out_flush_warn;
1739884d179dSJan Kara }
1740884d179dSJan Kara }
1741884d179dSJan Kara if (reserve)
1742a478e522SJan Kara *inode_reserved_space(inode) += number;
1743884d179dSJan Kara else
17447b9ca4c6SJan Kara __inode_add_bytes(inode, number);
1745a478e522SJan Kara spin_unlock(&inode->i_lock);
1746fd8fbfc1SDmitry Monakhov
1747fd8fbfc1SDmitry Monakhov if (reserve)
1748fd8fbfc1SDmitry Monakhov goto out_flush_warn;
1749bf097aafSJan Kara mark_all_dquot_dirty(dquots);
1750fd8fbfc1SDmitry Monakhov out_flush_warn:
1751b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index);
1752bf097aafSJan Kara flush_warnings(warn);
1753fd8fbfc1SDmitry Monakhov out:
1754884d179dSJan Kara return ret;
1755884d179dSJan Kara }
17565dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_alloc_space);
1757884d179dSJan Kara
1758884d179dSJan Kara /*
1759884d179dSJan Kara * This operation can block, but only after everything is updated
1760884d179dSJan Kara */
dquot_alloc_inode(struct inode * inode)17616bab3596SJan Kara int dquot_alloc_inode(struct inode *inode)
1762884d179dSJan Kara {
1763b9ba6f94SNiu Yawei int cnt, ret = 0, index;
1764bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS];
1765e45e8aa2SJan Kara struct dquot __rcu * const *dquots;
176640a673b4SWang Jianjian struct dquot *dquot;
1767884d179dSJan Kara
17684b9bdfa1SBaokun Li if (!inode_quota_active(inode))
176963936ddaSChristoph Hellwig return 0;
1770884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1771bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN;
1772b9ba6f94SNiu Yawei
17735bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
1774b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu);
17757b9ca4c6SJan Kara spin_lock(&inode->i_lock);
1776884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
177740a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
177840a673b4SWang Jianjian if (!dquot)
1779884d179dSJan Kara continue;
178040a673b4SWang Jianjian ret = dquot_add_inodes(dquot, 1, &warn[cnt]);
17817b9ca4c6SJan Kara if (ret) {
17827b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) {
178340a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
178440a673b4SWang Jianjian if (!dquot)
17857b9ca4c6SJan Kara continue;
17867b9ca4c6SJan Kara /* Back out changes we already did */
178740a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock);
178840a673b4SWang Jianjian dquot_decr_inodes(dquot, 1);
178940a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock);
17907b9ca4c6SJan Kara }
1791884d179dSJan Kara goto warn_put_all;
1792884d179dSJan Kara }
1793884d179dSJan Kara }
1794efd8f0e6SChristoph Hellwig
1795884d179dSJan Kara warn_put_all:
17967b9ca4c6SJan Kara spin_unlock(&inode->i_lock);
179763936ddaSChristoph Hellwig if (ret == 0)
1798bf097aafSJan Kara mark_all_dquot_dirty(dquots);
1799b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index);
1800bf097aafSJan Kara flush_warnings(warn);
1801884d179dSJan Kara return ret;
1802884d179dSJan Kara }
1803884d179dSJan Kara EXPORT_SYMBOL(dquot_alloc_inode);
1804884d179dSJan Kara
18055dd4056dSChristoph Hellwig /*
18065dd4056dSChristoph Hellwig * Convert in-memory reserved quotas to real consumed quotas
18075dd4056dSChristoph Hellwig */
dquot_claim_space_nodirty(struct inode * inode,qsize_t number)18085dd4056dSChristoph Hellwig int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1809884d179dSJan Kara {
1810e45e8aa2SJan Kara struct dquot __rcu **dquots;
181140a673b4SWang Jianjian struct dquot *dquot;
1812b9ba6f94SNiu Yawei int cnt, index;
1813884d179dSJan Kara
18144b9bdfa1SBaokun Li if (!inode_quota_active(inode)) {
18150ed60de3SJan Kara spin_lock(&inode->i_lock);
18160ed60de3SJan Kara *inode_reserved_space(inode) -= number;
18170ed60de3SJan Kara __inode_add_bytes(inode, number);
18180ed60de3SJan Kara spin_unlock(&inode->i_lock);
18195dd4056dSChristoph Hellwig return 0;
1820884d179dSJan Kara }
1821884d179dSJan Kara
18225bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
1823b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu);
18247b9ca4c6SJan Kara spin_lock(&inode->i_lock);
1825884d179dSJan Kara /* Claim reserved quotas to allocated quotas */
1826884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
182740a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
182840a673b4SWang Jianjian if (dquot) {
18297b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock);
18303ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_rsvspace < number))
18313ab167d2SJan Kara number = dquot->dq_dqb.dqb_rsvspace;
18323ab167d2SJan Kara dquot->dq_dqb.dqb_curspace += number;
18333ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace -= number;
18347b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock);
18353ab167d2SJan Kara }
1836884d179dSJan Kara }
1837884d179dSJan Kara /* Update inode bytes */
18380ed60de3SJan Kara *inode_reserved_space(inode) -= number;
18390ed60de3SJan Kara __inode_add_bytes(inode, number);
18400ed60de3SJan Kara spin_unlock(&inode->i_lock);
18415bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots);
1842b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index);
18435dd4056dSChristoph Hellwig return 0;
1844884d179dSJan Kara }
18455dd4056dSChristoph Hellwig EXPORT_SYMBOL(dquot_claim_space_nodirty);
1846884d179dSJan Kara
1847884d179dSJan Kara /*
18481c8924ebSJan Kara * Convert allocated space back to in-memory reserved quotas
18491c8924ebSJan Kara */
dquot_reclaim_space_nodirty(struct inode * inode,qsize_t number)18501c8924ebSJan Kara void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
18511c8924ebSJan Kara {
1852e45e8aa2SJan Kara struct dquot __rcu **dquots;
185340a673b4SWang Jianjian struct dquot *dquot;
1854b9ba6f94SNiu Yawei int cnt, index;
18551c8924ebSJan Kara
18564b9bdfa1SBaokun Li if (!inode_quota_active(inode)) {
18570ed60de3SJan Kara spin_lock(&inode->i_lock);
18580ed60de3SJan Kara *inode_reserved_space(inode) += number;
18590ed60de3SJan Kara __inode_sub_bytes(inode, number);
18600ed60de3SJan Kara spin_unlock(&inode->i_lock);
18611c8924ebSJan Kara return;
18621c8924ebSJan Kara }
18631c8924ebSJan Kara
18645bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
1865b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu);
18667b9ca4c6SJan Kara spin_lock(&inode->i_lock);
18671c8924ebSJan Kara /* Claim reserved quotas to allocated quotas */
18681c8924ebSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
186940a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
187040a673b4SWang Jianjian if (dquot) {
18717b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock);
18723ab167d2SJan Kara if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
18733ab167d2SJan Kara number = dquot->dq_dqb.dqb_curspace;
18743ab167d2SJan Kara dquot->dq_dqb.dqb_rsvspace += number;
18753ab167d2SJan Kara dquot->dq_dqb.dqb_curspace -= number;
18767b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock);
18773ab167d2SJan Kara }
18781c8924ebSJan Kara }
18791c8924ebSJan Kara /* Update inode bytes */
18800ed60de3SJan Kara *inode_reserved_space(inode) += number;
18810ed60de3SJan Kara __inode_sub_bytes(inode, number);
18820ed60de3SJan Kara spin_unlock(&inode->i_lock);
18835bcd3b6fSKonstantin Khlebnikov mark_all_dquot_dirty(dquots);
1884b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index);
18851c8924ebSJan Kara return;
18861c8924ebSJan Kara }
18871c8924ebSJan Kara EXPORT_SYMBOL(dquot_reclaim_space_nodirty);
18881c8924ebSJan Kara
18891c8924ebSJan Kara /*
1890884d179dSJan Kara * This operation can block, but only after everything is updated
1891884d179dSJan Kara */
__dquot_free_space(struct inode * inode,qsize_t number,int flags)189256246f9aSEric Sandeen void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
1893884d179dSJan Kara {
1894884d179dSJan Kara unsigned int cnt;
1895bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS];
1896e45e8aa2SJan Kara struct dquot __rcu **dquots;
189740a673b4SWang Jianjian struct dquot *dquot;
1898b9ba6f94SNiu Yawei int reserve = flags & DQUOT_SPACE_RESERVE, index;
1899884d179dSJan Kara
19004b9bdfa1SBaokun Li if (!inode_quota_active(inode)) {
1901a478e522SJan Kara if (reserve) {
1902a478e522SJan Kara spin_lock(&inode->i_lock);
1903a478e522SJan Kara *inode_reserved_space(inode) -= number;
1904a478e522SJan Kara spin_unlock(&inode->i_lock);
1905a478e522SJan Kara } else {
1906a478e522SJan Kara inode_sub_bytes(inode, number);
1907a478e522SJan Kara }
19085dd4056dSChristoph Hellwig return;
1909884d179dSJan Kara }
1910884d179dSJan Kara
19115bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
1912b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu);
19137b9ca4c6SJan Kara spin_lock(&inode->i_lock);
1914884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1915bf097aafSJan Kara int wtype;
1916bf097aafSJan Kara
1917bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN;
191840a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
191940a673b4SWang Jianjian if (!dquot)
1920884d179dSJan Kara continue;
192140a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock);
192240a673b4SWang Jianjian wtype = info_bdq_free(dquot, number);
1923bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN)
192440a673b4SWang Jianjian prepare_warning(&warn[cnt], dquot, wtype);
1925fd8fbfc1SDmitry Monakhov if (reserve)
192640a673b4SWang Jianjian dquot_free_reserved_space(dquot, number);
1927fd8fbfc1SDmitry Monakhov else
192840a673b4SWang Jianjian dquot_decr_space(dquot, number);
192940a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock);
1930884d179dSJan Kara }
19317b9ca4c6SJan Kara if (reserve)
1932a478e522SJan Kara *inode_reserved_space(inode) -= number;
19337b9ca4c6SJan Kara else
19347b9ca4c6SJan Kara __inode_sub_bytes(inode, number);
1935a478e522SJan Kara spin_unlock(&inode->i_lock);
1936fd8fbfc1SDmitry Monakhov
1937fd8fbfc1SDmitry Monakhov if (reserve)
1938fd8fbfc1SDmitry Monakhov goto out_unlock;
1939bf097aafSJan Kara mark_all_dquot_dirty(dquots);
1940fd8fbfc1SDmitry Monakhov out_unlock:
1941b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index);
1942bf097aafSJan Kara flush_warnings(warn);
1943884d179dSJan Kara }
19445dd4056dSChristoph Hellwig EXPORT_SYMBOL(__dquot_free_space);
1945fd8fbfc1SDmitry Monakhov
1946fd8fbfc1SDmitry Monakhov /*
1947884d179dSJan Kara * This operation can block, but only after everything is updated
1948884d179dSJan Kara */
dquot_free_inode(struct inode * inode)19496bab3596SJan Kara void dquot_free_inode(struct inode *inode)
1950884d179dSJan Kara {
1951884d179dSJan Kara unsigned int cnt;
1952bf097aafSJan Kara struct dquot_warn warn[MAXQUOTAS];
1953e45e8aa2SJan Kara struct dquot __rcu * const *dquots;
195440a673b4SWang Jianjian struct dquot *dquot;
1955b9ba6f94SNiu Yawei int index;
1956884d179dSJan Kara
19574b9bdfa1SBaokun Li if (!inode_quota_active(inode))
195863936ddaSChristoph Hellwig return;
1959884d179dSJan Kara
19605bcd3b6fSKonstantin Khlebnikov dquots = i_dquot(inode);
1961b9ba6f94SNiu Yawei index = srcu_read_lock(&dquot_srcu);
19627b9ca4c6SJan Kara spin_lock(&inode->i_lock);
1963884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1964bf097aafSJan Kara int wtype;
1965bf097aafSJan Kara warn[cnt].w_type = QUOTA_NL_NOWARN;
196640a673b4SWang Jianjian dquot = srcu_dereference(dquots[cnt], &dquot_srcu);
196740a673b4SWang Jianjian if (!dquot)
1968884d179dSJan Kara continue;
196940a673b4SWang Jianjian spin_lock(&dquot->dq_dqb_lock);
197040a673b4SWang Jianjian wtype = info_idq_free(dquot, 1);
1971bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN)
197240a673b4SWang Jianjian prepare_warning(&warn[cnt], dquot, wtype);
197340a673b4SWang Jianjian dquot_decr_inodes(dquot, 1);
197440a673b4SWang Jianjian spin_unlock(&dquot->dq_dqb_lock);
1975884d179dSJan Kara }
19767b9ca4c6SJan Kara spin_unlock(&inode->i_lock);
1977bf097aafSJan Kara mark_all_dquot_dirty(dquots);
1978b9ba6f94SNiu Yawei srcu_read_unlock(&dquot_srcu, index);
1979bf097aafSJan Kara flush_warnings(warn);
1980884d179dSJan Kara }
1981884d179dSJan Kara EXPORT_SYMBOL(dquot_free_inode);
1982884d179dSJan Kara
1983884d179dSJan Kara /*
1984884d179dSJan Kara * Transfer the number of inode and blocks from one diskquota to an other.
1985bc8e5f07SJan Kara * On success, dquot references in transfer_to are consumed and references
1986bc8e5f07SJan Kara * to original dquots that need to be released are placed there. On failure,
1987bc8e5f07SJan Kara * references are kept untouched.
1988884d179dSJan Kara *
1989884d179dSJan Kara * This operation can block, but only after everything is updated
1990884d179dSJan Kara * A transaction must be started when entering this function.
1991bc8e5f07SJan Kara *
1992b9ba6f94SNiu Yawei * We are holding reference on transfer_from & transfer_to, no need to
1993b9ba6f94SNiu Yawei * protect them by srcu_read_lock().
1994884d179dSJan Kara */
__dquot_transfer(struct inode * inode,struct dquot ** transfer_to)1995bc8e5f07SJan Kara int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
1996884d179dSJan Kara {
19977b9ca4c6SJan Kara qsize_t cur_space;
1998884d179dSJan Kara qsize_t rsv_space = 0;
19997a9ca53aSTahsin Erdogan qsize_t inode_usage = 1;
2000e45e8aa2SJan Kara struct dquot __rcu **dquots;
2001bc8e5f07SJan Kara struct dquot *transfer_from[MAXQUOTAS] = {};
200240a673b4SWang Jianjian int cnt, index, ret = 0;
20039e32784bSDmitry char is_valid[MAXQUOTAS] = {};
2004bf097aafSJan Kara struct dquot_warn warn_to[MAXQUOTAS];
2005bf097aafSJan Kara struct dquot_warn warn_from_inodes[MAXQUOTAS];
2006bf097aafSJan Kara struct dquot_warn warn_from_space[MAXQUOTAS];
2007884d179dSJan Kara
2008884d179dSJan Kara if (IS_NOQUOTA(inode))
2009efd8f0e6SChristoph Hellwig return 0;
20107a9ca53aSTahsin Erdogan
20117a9ca53aSTahsin Erdogan if (inode->i_sb->dq_op->get_inode_usage) {
20127a9ca53aSTahsin Erdogan ret = inode->i_sb->dq_op->get_inode_usage(inode, &inode_usage);
20137a9ca53aSTahsin Erdogan if (ret)
20147a9ca53aSTahsin Erdogan return ret;
20157a9ca53aSTahsin Erdogan }
20167a9ca53aSTahsin Erdogan
2017884d179dSJan Kara /* Initialize the arrays */
2018bf097aafSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2019bf097aafSJan Kara warn_to[cnt].w_type = QUOTA_NL_NOWARN;
2020bf097aafSJan Kara warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
2021bf097aafSJan Kara warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
2022bf097aafSJan Kara }
2023b9ba6f94SNiu Yawei
2024b9ba6f94SNiu Yawei spin_lock(&dq_data_lock);
20257b9ca4c6SJan Kara spin_lock(&inode->i_lock);
2026884d179dSJan Kara if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
20277b9ca4c6SJan Kara spin_unlock(&inode->i_lock);
2028b9ba6f94SNiu Yawei spin_unlock(&dq_data_lock);
2029bc8e5f07SJan Kara return 0;
2030884d179dSJan Kara }
20317b9ca4c6SJan Kara cur_space = __inode_get_bytes(inode);
20327b9ca4c6SJan Kara rsv_space = __inode_get_rsv_space(inode);
2033e45e8aa2SJan Kara dquots = i_dquot(inode);
20347b9ca4c6SJan Kara /*
20357b9ca4c6SJan Kara * Build the transfer_from list, check limits, and update usage in
20367b9ca4c6SJan Kara * the target structures.
20377b9ca4c6SJan Kara */
2038884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
20399e32784bSDmitry /*
20409e32784bSDmitry * Skip changes for same uid or gid or for turned off quota-type.
20419e32784bSDmitry */
2042dd6f3c6dSJan Kara if (!transfer_to[cnt])
2043884d179dSJan Kara continue;
20449e32784bSDmitry /* Avoid races with quotaoff() */
20459e32784bSDmitry if (!sb_has_quota_active(inode->i_sb, cnt))
20469e32784bSDmitry continue;
20479e32784bSDmitry is_valid[cnt] = 1;
2048e45e8aa2SJan Kara transfer_from[cnt] = srcu_dereference_check(dquots[cnt],
2049e45e8aa2SJan Kara &dquot_srcu, lockdep_is_held(&dq_data_lock));
20507b9ca4c6SJan Kara ret = dquot_add_inodes(transfer_to[cnt], inode_usage,
20517b9ca4c6SJan Kara &warn_to[cnt]);
2052efd8f0e6SChristoph Hellwig if (ret)
2053efd8f0e6SChristoph Hellwig goto over_quota;
2054c6d9c35dSyangerkun ret = dquot_add_space(transfer_to[cnt], cur_space, rsv_space,
2055c6d9c35dSyangerkun DQUOT_SPACE_WARN, &warn_to[cnt]);
20567b9ca4c6SJan Kara if (ret) {
20570a51fb71SKonstantin Khlebnikov spin_lock(&transfer_to[cnt]->dq_dqb_lock);
20587b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage);
20590a51fb71SKonstantin Khlebnikov spin_unlock(&transfer_to[cnt]->dq_dqb_lock);
2060884d179dSJan Kara goto over_quota;
2061884d179dSJan Kara }
20627b9ca4c6SJan Kara }
2063884d179dSJan Kara
20647b9ca4c6SJan Kara /* Decrease usage for source structures and update quota pointers */
2065884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
20669e32784bSDmitry if (!is_valid[cnt])
2067884d179dSJan Kara continue;
2068884d179dSJan Kara /* Due to IO error we might not have transfer_from[] structure */
2069884d179dSJan Kara if (transfer_from[cnt]) {
2070bf097aafSJan Kara int wtype;
20717b9ca4c6SJan Kara
20727b9ca4c6SJan Kara spin_lock(&transfer_from[cnt]->dq_dqb_lock);
20737a9ca53aSTahsin Erdogan wtype = info_idq_free(transfer_from[cnt], inode_usage);
2074bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN)
2075bf097aafSJan Kara prepare_warning(&warn_from_inodes[cnt],
2076bf097aafSJan Kara transfer_from[cnt], wtype);
20777b9ca4c6SJan Kara wtype = info_bdq_free(transfer_from[cnt],
20787b9ca4c6SJan Kara cur_space + rsv_space);
2079bf097aafSJan Kara if (wtype != QUOTA_NL_NOWARN)
2080bf097aafSJan Kara prepare_warning(&warn_from_space[cnt],
2081bf097aafSJan Kara transfer_from[cnt], wtype);
20827a9ca53aSTahsin Erdogan dquot_decr_inodes(transfer_from[cnt], inode_usage);
2083884d179dSJan Kara dquot_decr_space(transfer_from[cnt], cur_space);
2084884d179dSJan Kara dquot_free_reserved_space(transfer_from[cnt],
2085884d179dSJan Kara rsv_space);
20867b9ca4c6SJan Kara spin_unlock(&transfer_from[cnt]->dq_dqb_lock);
2087884d179dSJan Kara }
2088e45e8aa2SJan Kara rcu_assign_pointer(dquots[cnt], transfer_to[cnt]);
2089884d179dSJan Kara }
20907b9ca4c6SJan Kara spin_unlock(&inode->i_lock);
2091884d179dSJan Kara spin_unlock(&dq_data_lock);
2092884d179dSJan Kara
209340a673b4SWang Jianjian /*
209440a673b4SWang Jianjian * These arrays are local and we hold dquot references so we don't need
209540a673b4SWang Jianjian * the srcu protection but still take dquot_srcu to avoid warning in
209640a673b4SWang Jianjian * mark_all_dquot_dirty().
209740a673b4SWang Jianjian */
209840a673b4SWang Jianjian index = srcu_read_lock(&dquot_srcu);
2099e45e8aa2SJan Kara mark_all_dquot_dirty((struct dquot __rcu **)transfer_from);
2100e45e8aa2SJan Kara mark_all_dquot_dirty((struct dquot __rcu **)transfer_to);
210140a673b4SWang Jianjian srcu_read_unlock(&dquot_srcu, index);
210240a673b4SWang Jianjian
2103bf097aafSJan Kara flush_warnings(warn_to);
2104bf097aafSJan Kara flush_warnings(warn_from_inodes);
2105bf097aafSJan Kara flush_warnings(warn_from_space);
2106bc8e5f07SJan Kara /* Pass back references to put */
2107dc52dd3aSDmitry Monakhov for (cnt = 0; cnt < MAXQUOTAS; cnt++)
21089e32784bSDmitry if (is_valid[cnt])
2109bc8e5f07SJan Kara transfer_to[cnt] = transfer_from[cnt];
211086f3cbecSJan Kara return 0;
2111884d179dSJan Kara over_quota:
21127b9ca4c6SJan Kara /* Back out changes we already did */
21137b9ca4c6SJan Kara for (cnt--; cnt >= 0; cnt--) {
21147b9ca4c6SJan Kara if (!is_valid[cnt])
21157b9ca4c6SJan Kara continue;
21167b9ca4c6SJan Kara spin_lock(&transfer_to[cnt]->dq_dqb_lock);
21177b9ca4c6SJan Kara dquot_decr_inodes(transfer_to[cnt], inode_usage);
21187b9ca4c6SJan Kara dquot_decr_space(transfer_to[cnt], cur_space);
21197b9ca4c6SJan Kara dquot_free_reserved_space(transfer_to[cnt], rsv_space);
21207b9ca4c6SJan Kara spin_unlock(&transfer_to[cnt]->dq_dqb_lock);
21217b9ca4c6SJan Kara }
21227b9ca4c6SJan Kara spin_unlock(&inode->i_lock);
2123884d179dSJan Kara spin_unlock(&dq_data_lock);
2124bf097aafSJan Kara flush_warnings(warn_to);
212586f3cbecSJan Kara return ret;
2126884d179dSJan Kara }
2127bc8e5f07SJan Kara EXPORT_SYMBOL(__dquot_transfer);
2128884d179dSJan Kara
21298ddd69d6SDmitry Monakhov /* Wrapper for transferring ownership of an inode for uid/gid only
21308ddd69d6SDmitry Monakhov * Called from FSXXX_setattr()
21318ddd69d6SDmitry Monakhov */
dquot_transfer(struct mnt_idmap * idmap,struct inode * inode,struct iattr * iattr)2132f861646aSChristian Brauner int dquot_transfer(struct mnt_idmap *idmap, struct inode *inode,
213371e7b535SChristian Brauner struct iattr *iattr)
2134884d179dSJan Kara {
2135bc8e5f07SJan Kara struct dquot *transfer_to[MAXQUOTAS] = {};
21366184fc0bSJan Kara struct dquot *dquot;
2137bc8e5f07SJan Kara struct super_block *sb = inode->i_sb;
2138bc8e5f07SJan Kara int ret;
21398ddd69d6SDmitry Monakhov
21404b9bdfa1SBaokun Li if (!inode_quota_active(inode))
2141884d179dSJan Kara return 0;
2142bc8e5f07SJan Kara
21430dbe12f2SChristian Brauner if (i_uid_needs_update(idmap, iattr, inode)) {
21444d7ca409SChristian Brauner kuid_t kuid = from_vfsuid(idmap, i_user_ns(inode),
2145b27c82e1SChristian Brauner iattr->ia_vfsuid);
2146b27c82e1SChristian Brauner
2147b27c82e1SChristian Brauner dquot = dqget(sb, make_kqid_uid(kuid));
21486184fc0bSJan Kara if (IS_ERR(dquot)) {
21496184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) {
21506184fc0bSJan Kara ret = PTR_ERR(dquot);
21516184fc0bSJan Kara goto out_put;
21526184fc0bSJan Kara }
21536184fc0bSJan Kara dquot = NULL;
21546184fc0bSJan Kara }
21556184fc0bSJan Kara transfer_to[USRQUOTA] = dquot;
21566184fc0bSJan Kara }
21570dbe12f2SChristian Brauner if (i_gid_needs_update(idmap, iattr, inode)) {
21584d7ca409SChristian Brauner kgid_t kgid = from_vfsgid(idmap, i_user_ns(inode),
2159b27c82e1SChristian Brauner iattr->ia_vfsgid);
2160b27c82e1SChristian Brauner
2161b27c82e1SChristian Brauner dquot = dqget(sb, make_kqid_gid(kgid));
21626184fc0bSJan Kara if (IS_ERR(dquot)) {
21636184fc0bSJan Kara if (PTR_ERR(dquot) != -ESRCH) {
21646184fc0bSJan Kara ret = PTR_ERR(dquot);
21656184fc0bSJan Kara goto out_put;
21666184fc0bSJan Kara }
21676184fc0bSJan Kara dquot = NULL;
21686184fc0bSJan Kara }
21696184fc0bSJan Kara transfer_to[GRPQUOTA] = dquot;
21706184fc0bSJan Kara }
2171bc8e5f07SJan Kara ret = __dquot_transfer(inode, transfer_to);
21726184fc0bSJan Kara out_put:
2173bc8e5f07SJan Kara dqput_all(transfer_to);
2174bc8e5f07SJan Kara return ret;
2175884d179dSJan Kara }
2176b43fa828SChristoph Hellwig EXPORT_SYMBOL(dquot_transfer);
2177884d179dSJan Kara
2178884d179dSJan Kara /*
2179884d179dSJan Kara * Write info of quota file to disk
2180884d179dSJan Kara */
dquot_commit_info(struct super_block * sb,int type)2181884d179dSJan Kara int dquot_commit_info(struct super_block *sb, int type)
2182884d179dSJan Kara {
2183884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb);
2184884d179dSJan Kara
21859a8ae30eSJan Kara return dqopt->ops[type]->write_file_info(sb, type);
2186884d179dSJan Kara }
2187884d179dSJan Kara EXPORT_SYMBOL(dquot_commit_info);
2188884d179dSJan Kara
dquot_get_next_id(struct super_block * sb,struct kqid * qid)2189be6257b2SJan Kara int dquot_get_next_id(struct super_block *sb, struct kqid *qid)
2190be6257b2SJan Kara {
2191be6257b2SJan Kara struct quota_info *dqopt = sb_dqopt(sb);
2192be6257b2SJan Kara
21939d1ccbe7SJan Kara if (!sb_has_quota_active(sb, qid->type))
21949d1ccbe7SJan Kara return -ESRCH;
21959d1ccbe7SJan Kara if (!dqopt->ops[qid->type]->get_next_id)
21969d1ccbe7SJan Kara return -ENOSYS;
2197f14618c6SJan Kara return dqopt->ops[qid->type]->get_next_id(sb, qid);
2198be6257b2SJan Kara }
2199be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_id);
2200be6257b2SJan Kara
2201884d179dSJan Kara /*
2202884d179dSJan Kara * Definitions of diskquota operations.
2203884d179dSJan Kara */
220461e225dcSAlexey Dobriyan const struct dquot_operations dquot_operations = {
2205884d179dSJan Kara .write_dquot = dquot_commit,
2206884d179dSJan Kara .acquire_dquot = dquot_acquire,
2207884d179dSJan Kara .release_dquot = dquot_release,
2208884d179dSJan Kara .mark_dirty = dquot_mark_dquot_dirty,
2209884d179dSJan Kara .write_info = dquot_commit_info,
2210884d179dSJan Kara .alloc_dquot = dquot_alloc,
2211884d179dSJan Kara .destroy_dquot = dquot_destroy,
2212be6257b2SJan Kara .get_next_id = dquot_get_next_id,
2213884d179dSJan Kara };
2214123e9cafSChristoph Hellwig EXPORT_SYMBOL(dquot_operations);
2215884d179dSJan Kara
2216884d179dSJan Kara /*
2217907f4554SChristoph Hellwig * Generic helper for ->open on filesystems supporting disk quotas.
2218907f4554SChristoph Hellwig */
dquot_file_open(struct inode * inode,struct file * file)2219907f4554SChristoph Hellwig int dquot_file_open(struct inode *inode, struct file *file)
2220907f4554SChristoph Hellwig {
2221907f4554SChristoph Hellwig int error;
2222907f4554SChristoph Hellwig
2223907f4554SChristoph Hellwig error = generic_file_open(inode, file);
2224907f4554SChristoph Hellwig if (!error && (file->f_mode & FMODE_WRITE))
222588d8ff97SChao Yu error = dquot_initialize(inode);
2226907f4554SChristoph Hellwig return error;
2227907f4554SChristoph Hellwig }
2228907f4554SChristoph Hellwig EXPORT_SYMBOL(dquot_file_open);
2229907f4554SChristoph Hellwig
vfs_cleanup_quota_inode(struct super_block * sb,int type)22302ec1f301SJan Kara static void vfs_cleanup_quota_inode(struct super_block *sb, int type)
22312ec1f301SJan Kara {
22322ec1f301SJan Kara struct quota_info *dqopt = sb_dqopt(sb);
22332ec1f301SJan Kara struct inode *inode = dqopt->files[type];
22342ec1f301SJan Kara
22352ec1f301SJan Kara if (!inode)
22362ec1f301SJan Kara return;
22372ec1f301SJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
22382ec1f301SJan Kara inode_lock(inode);
22392ec1f301SJan Kara inode->i_flags &= ~S_NOQUOTA;
22402ec1f301SJan Kara inode_unlock(inode);
22412ec1f301SJan Kara }
22422ec1f301SJan Kara dqopt->files[type] = NULL;
22432ec1f301SJan Kara iput(inode);
22442ec1f301SJan Kara }
22452ec1f301SJan Kara
2246907f4554SChristoph Hellwig /*
2247884d179dSJan Kara * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
2248884d179dSJan Kara */
dquot_disable(struct super_block * sb,int type,unsigned int flags)22490f0dd62fSChristoph Hellwig int dquot_disable(struct super_block *sb, int type, unsigned int flags)
2250884d179dSJan Kara {
22512ec1f301SJan Kara int cnt;
2252884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb);
2253884d179dSJan Kara
22547d6cd73dSJan Kara /* s_umount should be held in exclusive mode */
22557d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
22567d6cd73dSJan Kara up_read(&sb->s_umount);
22577d6cd73dSJan Kara
2258884d179dSJan Kara /* Cannot turn off usage accounting without turning off limits, or
2259884d179dSJan Kara * suspend quotas and simultaneously turn quotas off. */
2260884d179dSJan Kara if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
2261884d179dSJan Kara || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
2262884d179dSJan Kara DQUOT_USAGE_ENABLED)))
2263884d179dSJan Kara return -EINVAL;
2264884d179dSJan Kara
2265884d179dSJan Kara /*
2266884d179dSJan Kara * Skip everything if there's nothing to do. We have to do this because
2267884d179dSJan Kara * sometimes we are called when fill_super() failed and calling
2268884d179dSJan Kara * sync_fs() in such cases does no good.
2269884d179dSJan Kara */
2270c3b00446SJan Kara if (!sb_any_quota_loaded(sb))
2271884d179dSJan Kara return 0;
2272c3b00446SJan Kara
2273884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2274884d179dSJan Kara if (type != -1 && cnt != type)
2275884d179dSJan Kara continue;
2276884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt))
2277884d179dSJan Kara continue;
2278884d179dSJan Kara
2279884d179dSJan Kara if (flags & DQUOT_SUSPENDED) {
2280884d179dSJan Kara spin_lock(&dq_state_lock);
2281884d179dSJan Kara dqopt->flags |=
2282884d179dSJan Kara dquot_state_flag(DQUOT_SUSPENDED, cnt);
2283884d179dSJan Kara spin_unlock(&dq_state_lock);
2284884d179dSJan Kara } else {
2285884d179dSJan Kara spin_lock(&dq_state_lock);
2286884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(flags, cnt);
2287884d179dSJan Kara /* Turning off suspended quotas? */
2288884d179dSJan Kara if (!sb_has_quota_loaded(sb, cnt) &&
2289884d179dSJan Kara sb_has_quota_suspended(sb, cnt)) {
2290884d179dSJan Kara dqopt->flags &= ~dquot_state_flag(
2291884d179dSJan Kara DQUOT_SUSPENDED, cnt);
2292884d179dSJan Kara spin_unlock(&dq_state_lock);
22932ec1f301SJan Kara vfs_cleanup_quota_inode(sb, cnt);
2294884d179dSJan Kara continue;
2295884d179dSJan Kara }
2296884d179dSJan Kara spin_unlock(&dq_state_lock);
2297884d179dSJan Kara }
2298884d179dSJan Kara
2299884d179dSJan Kara /* We still have to keep quota loaded? */
2300884d179dSJan Kara if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
2301884d179dSJan Kara continue;
2302884d179dSJan Kara
2303884d179dSJan Kara /* Note: these are blocking operations */
2304884d179dSJan Kara drop_dquot_ref(sb, cnt);
2305884d179dSJan Kara invalidate_dquots(sb, cnt);
2306884d179dSJan Kara /*
2307268157baSJan Kara * Now all dquots should be invalidated, all writes done so we
2308268157baSJan Kara * should be only users of the info. No locks needed.
2309884d179dSJan Kara */
2310884d179dSJan Kara if (info_dirty(&dqopt->info[cnt]))
2311884d179dSJan Kara sb->dq_op->write_info(sb, cnt);
2312884d179dSJan Kara if (dqopt->ops[cnt]->free_file_info)
2313884d179dSJan Kara dqopt->ops[cnt]->free_file_info(sb, cnt);
2314884d179dSJan Kara put_quota_format(dqopt->info[cnt].dqi_format);
2315884d179dSJan Kara dqopt->info[cnt].dqi_flags = 0;
2316884d179dSJan Kara dqopt->info[cnt].dqi_igrace = 0;
2317884d179dSJan Kara dqopt->info[cnt].dqi_bgrace = 0;
2318884d179dSJan Kara dqopt->ops[cnt] = NULL;
2319884d179dSJan Kara }
2320884d179dSJan Kara
2321884d179dSJan Kara /* Skip syncing and setting flags if quota files are hidden */
2322884d179dSJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2323884d179dSJan Kara goto put_inodes;
2324884d179dSJan Kara
2325884d179dSJan Kara /* Sync the superblock so that buffers with quota data are written to
2326884d179dSJan Kara * disk (and so userspace sees correct data afterwards). */
2327884d179dSJan Kara if (sb->s_op->sync_fs)
2328884d179dSJan Kara sb->s_op->sync_fs(sb, 1);
2329884d179dSJan Kara sync_blockdev(sb->s_bdev);
2330884d179dSJan Kara /* Now the quota files are just ordinary files and we can set the
2331884d179dSJan Kara * inode flags back. Moreover we discard the pagecache so that
2332884d179dSJan Kara * userspace sees the writes we did bypassing the pagecache. We
2333884d179dSJan Kara * must also discard the blockdev buffers so that we see the
2334884d179dSJan Kara * changes done by userspace on the next quotaon() */
2335884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++)
23362ec1f301SJan Kara if (!sb_has_quota_loaded(sb, cnt) && dqopt->files[cnt]) {
23372ec1f301SJan Kara inode_lock(dqopt->files[cnt]);
23382ec1f301SJan Kara truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
23392ec1f301SJan Kara inode_unlock(dqopt->files[cnt]);
2340884d179dSJan Kara }
2341884d179dSJan Kara if (sb->s_bdev)
2342884d179dSJan Kara invalidate_bdev(sb->s_bdev);
2343884d179dSJan Kara put_inodes:
23442ec1f301SJan Kara /* We are done when suspending quotas */
23452ec1f301SJan Kara if (flags & DQUOT_SUSPENDED)
23462ec1f301SJan Kara return 0;
23472ec1f301SJan Kara
2348884d179dSJan Kara for (cnt = 0; cnt < MAXQUOTAS; cnt++)
23492ec1f301SJan Kara if (!sb_has_quota_loaded(sb, cnt))
23502ec1f301SJan Kara vfs_cleanup_quota_inode(sb, cnt);
23512ec1f301SJan Kara return 0;
2352884d179dSJan Kara }
23530f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_disable);
2354884d179dSJan Kara
dquot_quota_off(struct super_block * sb,int type)2355287a8095SChristoph Hellwig int dquot_quota_off(struct super_block *sb, int type)
2356884d179dSJan Kara {
23570f0dd62fSChristoph Hellwig return dquot_disable(sb, type,
23580f0dd62fSChristoph Hellwig DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2359884d179dSJan Kara }
2360287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_off);
23610f0dd62fSChristoph Hellwig
2362884d179dSJan Kara /*
2363884d179dSJan Kara * Turn quotas on on a device
2364884d179dSJan Kara */
2365884d179dSJan Kara
vfs_setup_quota_inode(struct inode * inode,int type)2366c7d3d283SJan Kara static int vfs_setup_quota_inode(struct inode *inode, int type)
2367c7d3d283SJan Kara {
2368c7d3d283SJan Kara struct super_block *sb = inode->i_sb;
2369c7d3d283SJan Kara struct quota_info *dqopt = sb_dqopt(sb);
2370c7d3d283SJan Kara
2371d3238774SBaokun Li if (is_bad_inode(inode))
2372d3238774SBaokun Li return -EUCLEAN;
2373c7d3d283SJan Kara if (!S_ISREG(inode->i_mode))
2374c7d3d283SJan Kara return -EACCES;
2375c7d3d283SJan Kara if (IS_RDONLY(inode))
2376c7d3d283SJan Kara return -EROFS;
2377c7d3d283SJan Kara if (sb_has_quota_loaded(sb, type))
2378c7d3d283SJan Kara return -EBUSY;
2379c7d3d283SJan Kara
23800b98335aSEric Biggers /*
23810b98335aSEric Biggers * Quota files should never be encrypted. They should be thought of as
23820b98335aSEric Biggers * filesystem metadata, not user data. New-style internal quota files
23830b98335aSEric Biggers * cannot be encrypted by users anyway, but old-style external quota
23840b98335aSEric Biggers * files could potentially be incorrectly created in an encrypted
23850b98335aSEric Biggers * directory, hence this explicit check. Some reasons why encrypted
23860b98335aSEric Biggers * quota files don't work include: (1) some filesystems that support
23870b98335aSEric Biggers * encryption don't handle it in their quota_read and quota_write, and
23880b98335aSEric Biggers * (2) cleaning up encrypted quota files at unmount would need special
23890b98335aSEric Biggers * consideration, as quota files are cleaned up later than user files.
23900b98335aSEric Biggers */
23910b98335aSEric Biggers if (IS_ENCRYPTED(inode))
23920b98335aSEric Biggers return -EINVAL;
23930b98335aSEric Biggers
2394c7d3d283SJan Kara dqopt->files[type] = igrab(inode);
2395c7d3d283SJan Kara if (!dqopt->files[type])
2396c7d3d283SJan Kara return -EIO;
2397c7d3d283SJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2398c7d3d283SJan Kara /* We don't want quota and atime on quota files (deadlocks
2399c7d3d283SJan Kara * possible) Also nobody should write to the file - we use
2400c7d3d283SJan Kara * special IO operations which ignore the immutable bit. */
2401c7d3d283SJan Kara inode_lock(inode);
2402c7d3d283SJan Kara inode->i_flags |= S_NOQUOTA;
2403c7d3d283SJan Kara inode_unlock(inode);
2404884d179dSJan Kara /*
2405c7d3d283SJan Kara * When S_NOQUOTA is set, remove dquot references as no more
2406c7d3d283SJan Kara * references can be added
2407884d179dSJan Kara */
2408c7d3d283SJan Kara __dquot_drop(inode);
2409c7d3d283SJan Kara }
2410c7d3d283SJan Kara return 0;
2411c7d3d283SJan Kara }
2412c7d3d283SJan Kara
dquot_load_quota_sb(struct super_block * sb,int type,int format_id,unsigned int flags)2413c7d3d283SJan Kara int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
2414884d179dSJan Kara unsigned int flags)
2415884d179dSJan Kara {
2416884d179dSJan Kara struct quota_format_type *fmt = find_quota_format(format_id);
2417884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb);
2418884d179dSJan Kara int error;
2419884d179dSJan Kara
24207a64774aSChristoph Hellwig lockdep_assert_held_write(&sb->s_umount);
24217a64774aSChristoph Hellwig
2422dc19432aSJan Kara /* Just unsuspend quotas? */
2423dc19432aSJan Kara BUG_ON(flags & DQUOT_SUSPENDED);
2424dc19432aSJan Kara
2425884d179dSJan Kara if (!fmt)
2426884d179dSJan Kara return -ESRCH;
242786be6b8bSJan Kara if (!sb->dq_op || !sb->s_qcop ||
2428847aac64SLi Xi (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) {
2429884d179dSJan Kara error = -EINVAL;
2430884d179dSJan Kara goto out_fmt;
2431884d179dSJan Kara }
24325c004828SEric W. Biederman /* Filesystems outside of init_user_ns not yet supported */
24335c004828SEric W. Biederman if (sb->s_user_ns != &init_user_ns) {
24345c004828SEric W. Biederman error = -EINVAL;
24355c004828SEric W. Biederman goto out_fmt;
24365c004828SEric W. Biederman }
2437884d179dSJan Kara /* Usage always has to be set... */
2438884d179dSJan Kara if (!(flags & DQUOT_USAGE_ENABLED)) {
2439884d179dSJan Kara error = -EINVAL;
2440884d179dSJan Kara goto out_fmt;
2441884d179dSJan Kara }
2442c3b00446SJan Kara if (sb_has_quota_loaded(sb, type)) {
2443c3b00446SJan Kara error = -EBUSY;
2444c3b00446SJan Kara goto out_fmt;
2445c3b00446SJan Kara }
2446884d179dSJan Kara
2447884d179dSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2448ab94c39bSJan Kara /* As we bypass the pagecache we must now flush all the
2449ab94c39bSJan Kara * dirty data and invalidate caches so that kernel sees
2450ab94c39bSJan Kara * changes from userspace. It is not enough to just flush
2451ab94c39bSJan Kara * the quota file since if blocksize < pagesize, invalidation
2452ab94c39bSJan Kara * of the cache could fail because of other unrelated dirty
2453ab94c39bSJan Kara * data */
2454ab94c39bSJan Kara sync_filesystem(sb);
2455884d179dSJan Kara invalidate_bdev(sb->s_bdev);
2456884d179dSJan Kara }
2457884d179dSJan Kara
2458884d179dSJan Kara error = -EINVAL;
2459884d179dSJan Kara if (!fmt->qf_ops->check_quota_file(sb, type))
2460c7d3d283SJan Kara goto out_fmt;
2461884d179dSJan Kara
2462884d179dSJan Kara dqopt->ops[type] = fmt->qf_ops;
2463884d179dSJan Kara dqopt->info[type].dqi_format = fmt;
2464884d179dSJan Kara dqopt->info[type].dqi_fmt_id = format_id;
2465884d179dSJan Kara INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
2466268157baSJan Kara error = dqopt->ops[type]->read_file_info(sb, type);
246742fdb858SJan Kara if (error < 0)
2468c7d3d283SJan Kara goto out_fmt;
246915512377SJan Kara if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) {
247015512377SJan Kara spin_lock(&dq_data_lock);
247146fe44ceSJan Kara dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
247215512377SJan Kara spin_unlock(&dq_data_lock);
247315512377SJan Kara }
2474884d179dSJan Kara spin_lock(&dq_state_lock);
2475884d179dSJan Kara dqopt->flags |= dquot_state_flag(flags, type);
2476884d179dSJan Kara spin_unlock(&dq_state_lock);
2477884d179dSJan Kara
24781a6152d3SChao Yu error = add_dquot_ref(sb, type);
24791a6152d3SChao Yu if (error)
24806a4e3363SJan Kara dquot_disable(sb, type,
24816a4e3363SJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2482884d179dSJan Kara
24831a6152d3SChao Yu return error;
2484884d179dSJan Kara out_fmt:
2485884d179dSJan Kara put_quota_format(fmt);
2486884d179dSJan Kara
2487884d179dSJan Kara return error;
2488884d179dSJan Kara }
2489c7d3d283SJan Kara EXPORT_SYMBOL(dquot_load_quota_sb);
2490c7d3d283SJan Kara
2491c7d3d283SJan Kara /*
2492dc19432aSJan Kara * More powerful function for turning on quotas on given quota inode allowing
2493dc19432aSJan Kara * setting of individual quota flags
2494c7d3d283SJan Kara */
dquot_load_quota_inode(struct inode * inode,int type,int format_id,unsigned int flags)2495dc19432aSJan Kara int dquot_load_quota_inode(struct inode *inode, int type, int format_id,
2496c7d3d283SJan Kara unsigned int flags)
2497c7d3d283SJan Kara {
2498c7d3d283SJan Kara int err;
2499c7d3d283SJan Kara
2500c7d3d283SJan Kara err = vfs_setup_quota_inode(inode, type);
2501c7d3d283SJan Kara if (err < 0)
2502c7d3d283SJan Kara return err;
2503c7d3d283SJan Kara err = dquot_load_quota_sb(inode->i_sb, type, format_id, flags);
2504c7d3d283SJan Kara if (err < 0)
2505c7d3d283SJan Kara vfs_cleanup_quota_inode(inode->i_sb, type);
2506c7d3d283SJan Kara return err;
2507c7d3d283SJan Kara }
2508dc19432aSJan Kara EXPORT_SYMBOL(dquot_load_quota_inode);
2509884d179dSJan Kara
2510884d179dSJan Kara /* Reenable quotas on remount RW */
dquot_resume(struct super_block * sb,int type)25110f0dd62fSChristoph Hellwig int dquot_resume(struct super_block *sb, int type)
2512884d179dSJan Kara {
2513884d179dSJan Kara struct quota_info *dqopt = sb_dqopt(sb);
25140f0dd62fSChristoph Hellwig int ret = 0, cnt;
2515884d179dSJan Kara unsigned int flags;
2516884d179dSJan Kara
25177d6cd73dSJan Kara /* s_umount should be held in exclusive mode */
25187d6cd73dSJan Kara if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
25197d6cd73dSJan Kara up_read(&sb->s_umount);
25207d6cd73dSJan Kara
25210f0dd62fSChristoph Hellwig for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
25220f0dd62fSChristoph Hellwig if (type != -1 && cnt != type)
25230f0dd62fSChristoph Hellwig continue;
2524c3b00446SJan Kara if (!sb_has_quota_suspended(sb, cnt))
25250f0dd62fSChristoph Hellwig continue;
2526c3b00446SJan Kara
2527884d179dSJan Kara spin_lock(&dq_state_lock);
2528884d179dSJan Kara flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
25290f0dd62fSChristoph Hellwig DQUOT_LIMITS_ENABLED,
25300f0dd62fSChristoph Hellwig cnt);
25310f0dd62fSChristoph Hellwig dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2532884d179dSJan Kara spin_unlock(&dq_state_lock);
2533884d179dSJan Kara
25340f0dd62fSChristoph Hellwig flags = dquot_generic_flag(flags, cnt);
2535ae45f07dSJan Kara ret = dquot_load_quota_sb(sb, cnt, dqopt->info[cnt].dqi_fmt_id,
2536ae45f07dSJan Kara flags);
2537ae45f07dSJan Kara if (ret < 0)
2538e51d68e7SAnant Thazhemadam vfs_cleanup_quota_inode(sb, cnt);
25390f0dd62fSChristoph Hellwig }
2540884d179dSJan Kara
2541884d179dSJan Kara return ret;
2542884d179dSJan Kara }
25430f0dd62fSChristoph Hellwig EXPORT_SYMBOL(dquot_resume);
2544884d179dSJan Kara
dquot_quota_on(struct super_block * sb,int type,int format_id,const struct path * path)2545f00c9e44SJan Kara int dquot_quota_on(struct super_block *sb, int type, int format_id,
25468c54ca9cSAl Viro const struct path *path)
2547884d179dSJan Kara {
2548884d179dSJan Kara int error = security_quota_on(path->dentry);
2549884d179dSJan Kara if (error)
2550884d179dSJan Kara return error;
2551884d179dSJan Kara /* Quota file not on the same filesystem? */
2552d8c9584eSAl Viro if (path->dentry->d_sb != sb)
2553884d179dSJan Kara error = -EXDEV;
2554884d179dSJan Kara else
2555dc19432aSJan Kara error = dquot_load_quota_inode(d_inode(path->dentry), type,
2556884d179dSJan Kara format_id, DQUOT_USAGE_ENABLED |
2557884d179dSJan Kara DQUOT_LIMITS_ENABLED);
2558884d179dSJan Kara return error;
2559884d179dSJan Kara }
2560287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on);
2561884d179dSJan Kara
2562884d179dSJan Kara /*
2563884d179dSJan Kara * This function is used when filesystem needs to initialize quotas
2564884d179dSJan Kara * during mount time.
2565884d179dSJan Kara */
dquot_quota_on_mount(struct super_block * sb,char * qf_name,int format_id,int type)2566287a8095SChristoph Hellwig int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
2567884d179dSJan Kara int format_id, int type)
2568884d179dSJan Kara {
2569884d179dSJan Kara struct dentry *dentry;
2570884d179dSJan Kara int error;
2571884d179dSJan Kara
25726c2d4798SAl Viro dentry = lookup_positive_unlocked(qf_name, sb->s_root, strlen(qf_name));
2573884d179dSJan Kara if (IS_ERR(dentry))
2574884d179dSJan Kara return PTR_ERR(dentry);
2575884d179dSJan Kara
2576884d179dSJan Kara error = security_quota_on(dentry);
2577884d179dSJan Kara if (!error)
2578dc19432aSJan Kara error = dquot_load_quota_inode(d_inode(dentry), type, format_id,
2579884d179dSJan Kara DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2580884d179dSJan Kara
2581884d179dSJan Kara dput(dentry);
2582884d179dSJan Kara return error;
2583884d179dSJan Kara }
2584287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_quota_on_mount);
2585884d179dSJan Kara
dquot_quota_enable(struct super_block * sb,unsigned int flags)25863e2af67eSJan Kara static int dquot_quota_enable(struct super_block *sb, unsigned int flags)
25873e2af67eSJan Kara {
25883e2af67eSJan Kara int ret;
25893e2af67eSJan Kara int type;
25903e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb);
25913e2af67eSJan Kara
25923e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
25933e2af67eSJan Kara return -ENOSYS;
25943e2af67eSJan Kara /* Accounting cannot be turned on while fs is mounted */
25953e2af67eSJan Kara flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT);
25963e2af67eSJan Kara if (!flags)
25973e2af67eSJan Kara return -EINVAL;
25983e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) {
25993e2af67eSJan Kara if (!(flags & qtype_enforce_flag(type)))
26003e2af67eSJan Kara continue;
26013e2af67eSJan Kara /* Can't enforce without accounting */
2602069a9166SJan Kara if (!sb_has_quota_usage_enabled(sb, type)) {
2603069a9166SJan Kara ret = -EINVAL;
26043e2af67eSJan Kara goto out_err;
26053e2af67eSJan Kara }
2606069a9166SJan Kara if (sb_has_quota_limits_enabled(sb, type)) {
2607069a9166SJan Kara ret = -EBUSY;
2608069a9166SJan Kara goto out_err;
2609069a9166SJan Kara }
2610069a9166SJan Kara spin_lock(&dq_state_lock);
2611069a9166SJan Kara dqopt->flags |= dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
2612069a9166SJan Kara spin_unlock(&dq_state_lock);
2613069a9166SJan Kara }
26143e2af67eSJan Kara return 0;
26153e2af67eSJan Kara out_err:
26163e2af67eSJan Kara /* Backout enforcement enablement we already did */
26173e2af67eSJan Kara for (type--; type >= 0; type--) {
26183e2af67eSJan Kara if (flags & qtype_enforce_flag(type))
26193e2af67eSJan Kara dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
26203e2af67eSJan Kara }
26213e2af67eSJan Kara /* Error code translation for better compatibility with XFS */
26223e2af67eSJan Kara if (ret == -EBUSY)
26233e2af67eSJan Kara ret = -EEXIST;
26243e2af67eSJan Kara return ret;
26253e2af67eSJan Kara }
26263e2af67eSJan Kara
dquot_quota_disable(struct super_block * sb,unsigned int flags)26273e2af67eSJan Kara static int dquot_quota_disable(struct super_block *sb, unsigned int flags)
26283e2af67eSJan Kara {
26293e2af67eSJan Kara int ret;
26303e2af67eSJan Kara int type;
26313e2af67eSJan Kara struct quota_info *dqopt = sb_dqopt(sb);
26323e2af67eSJan Kara
26333e2af67eSJan Kara if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
26343e2af67eSJan Kara return -ENOSYS;
26353e2af67eSJan Kara /*
26363e2af67eSJan Kara * We don't support turning off accounting via quotactl. In principle
26373e2af67eSJan Kara * quota infrastructure can do this but filesystems don't expect
26383e2af67eSJan Kara * userspace to be able to do it.
26393e2af67eSJan Kara */
26403e2af67eSJan Kara if (flags &
26413e2af67eSJan Kara (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT))
26423e2af67eSJan Kara return -EOPNOTSUPP;
26433e2af67eSJan Kara
26443e2af67eSJan Kara /* Filter out limits not enabled */
26453e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++)
26463e2af67eSJan Kara if (!sb_has_quota_limits_enabled(sb, type))
26473e2af67eSJan Kara flags &= ~qtype_enforce_flag(type);
26483e2af67eSJan Kara /* Nothing left? */
26493e2af67eSJan Kara if (!flags)
26503e2af67eSJan Kara return -EEXIST;
26513e2af67eSJan Kara for (type = 0; type < MAXQUOTAS; type++) {
26523e2af67eSJan Kara if (flags & qtype_enforce_flag(type)) {
26533e2af67eSJan Kara ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
26543e2af67eSJan Kara if (ret < 0)
26553e2af67eSJan Kara goto out_err;
26563e2af67eSJan Kara }
26573e2af67eSJan Kara }
26583e2af67eSJan Kara return 0;
26593e2af67eSJan Kara out_err:
26603e2af67eSJan Kara /* Backout enforcement disabling we already did */
26613e2af67eSJan Kara for (type--; type >= 0; type--) {
2662069a9166SJan Kara if (flags & qtype_enforce_flag(type)) {
2663069a9166SJan Kara spin_lock(&dq_state_lock);
2664069a9166SJan Kara dqopt->flags |=
2665069a9166SJan Kara dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
2666069a9166SJan Kara spin_unlock(&dq_state_lock);
2667069a9166SJan Kara }
26683e2af67eSJan Kara }
26693e2af67eSJan Kara return ret;
26703e2af67eSJan Kara }
26713e2af67eSJan Kara
2672884d179dSJan Kara /* Generic routine for getting common part of quota structure */
do_get_dqblk(struct dquot * dquot,struct qc_dqblk * di)267314bf61ffSJan Kara static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di)
2674884d179dSJan Kara {
2675884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb;
2676884d179dSJan Kara
2677b9b2dd36SChristoph Hellwig memset(di, 0, sizeof(*di));
26787b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock);
267914bf61ffSJan Kara di->d_spc_hardlimit = dm->dqb_bhardlimit;
268014bf61ffSJan Kara di->d_spc_softlimit = dm->dqb_bsoftlimit;
2681b9b2dd36SChristoph Hellwig di->d_ino_hardlimit = dm->dqb_ihardlimit;
2682b9b2dd36SChristoph Hellwig di->d_ino_softlimit = dm->dqb_isoftlimit;
268314bf61ffSJan Kara di->d_space = dm->dqb_curspace + dm->dqb_rsvspace;
268414bf61ffSJan Kara di->d_ino_count = dm->dqb_curinodes;
268514bf61ffSJan Kara di->d_spc_timer = dm->dqb_btime;
268614bf61ffSJan Kara di->d_ino_timer = dm->dqb_itime;
26877b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock);
2688884d179dSJan Kara }
2689884d179dSJan Kara
dquot_get_dqblk(struct super_block * sb,struct kqid qid,struct qc_dqblk * di)269074a8a103SEric W. Biederman int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
269114bf61ffSJan Kara struct qc_dqblk *di)
2692884d179dSJan Kara {
2693884d179dSJan Kara struct dquot *dquot;
2694884d179dSJan Kara
2695aca645a6SEric W. Biederman dquot = dqget(sb, qid);
26966184fc0bSJan Kara if (IS_ERR(dquot))
26976184fc0bSJan Kara return PTR_ERR(dquot);
2698884d179dSJan Kara do_get_dqblk(dquot, di);
2699884d179dSJan Kara dqput(dquot);
2700884d179dSJan Kara
2701884d179dSJan Kara return 0;
2702884d179dSJan Kara }
2703287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_get_dqblk);
2704884d179dSJan Kara
dquot_get_next_dqblk(struct super_block * sb,struct kqid * qid,struct qc_dqblk * di)2705be6257b2SJan Kara int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid,
2706be6257b2SJan Kara struct qc_dqblk *di)
2707be6257b2SJan Kara {
2708be6257b2SJan Kara struct dquot *dquot;
2709be6257b2SJan Kara int err;
2710be6257b2SJan Kara
2711be6257b2SJan Kara if (!sb->dq_op->get_next_id)
2712be6257b2SJan Kara return -ENOSYS;
2713be6257b2SJan Kara err = sb->dq_op->get_next_id(sb, qid);
2714be6257b2SJan Kara if (err < 0)
2715be6257b2SJan Kara return err;
2716be6257b2SJan Kara dquot = dqget(sb, *qid);
2717be6257b2SJan Kara if (IS_ERR(dquot))
2718be6257b2SJan Kara return PTR_ERR(dquot);
2719be6257b2SJan Kara do_get_dqblk(dquot, di);
2720be6257b2SJan Kara dqput(dquot);
2721be6257b2SJan Kara
2722be6257b2SJan Kara return 0;
2723be6257b2SJan Kara }
2724be6257b2SJan Kara EXPORT_SYMBOL(dquot_get_next_dqblk);
2725be6257b2SJan Kara
272614bf61ffSJan Kara #define VFS_QC_MASK \
272714bf61ffSJan Kara (QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \
272814bf61ffSJan Kara QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \
272914bf61ffSJan Kara QC_SPC_TIMER | QC_INO_TIMER)
2730c472b432SChristoph Hellwig
2731884d179dSJan Kara /* Generic routine for setting common part of quota structure */
do_set_dqblk(struct dquot * dquot,struct qc_dqblk * di)273214bf61ffSJan Kara static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di)
2733884d179dSJan Kara {
2734884d179dSJan Kara struct mem_dqblk *dm = &dquot->dq_dqb;
2735884d179dSJan Kara int check_blim = 0, check_ilim = 0;
27364c376dcaSEric W. Biederman struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
2737884d179dSJan Kara
273814bf61ffSJan Kara if (di->d_fieldmask & ~VFS_QC_MASK)
2739c472b432SChristoph Hellwig return -EINVAL;
2740c472b432SChristoph Hellwig
274114bf61ffSJan Kara if (((di->d_fieldmask & QC_SPC_SOFT) &&
2742b10a0819SJan Kara di->d_spc_softlimit > dqi->dqi_max_spc_limit) ||
274314bf61ffSJan Kara ((di->d_fieldmask & QC_SPC_HARD) &&
2744b10a0819SJan Kara di->d_spc_hardlimit > dqi->dqi_max_spc_limit) ||
274514bf61ffSJan Kara ((di->d_fieldmask & QC_INO_SOFT) &&
2746b10a0819SJan Kara (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) ||
274714bf61ffSJan Kara ((di->d_fieldmask & QC_INO_HARD) &&
2748b10a0819SJan Kara (di->d_ino_hardlimit > dqi->dqi_max_ino_limit)))
2749884d179dSJan Kara return -ERANGE;
2750884d179dSJan Kara
27517b9ca4c6SJan Kara spin_lock(&dquot->dq_dqb_lock);
275214bf61ffSJan Kara if (di->d_fieldmask & QC_SPACE) {
275314bf61ffSJan Kara dm->dqb_curspace = di->d_space - dm->dqb_rsvspace;
2754884d179dSJan Kara check_blim = 1;
275508261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
2756884d179dSJan Kara }
2757c472b432SChristoph Hellwig
275814bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_SOFT)
275914bf61ffSJan Kara dm->dqb_bsoftlimit = di->d_spc_softlimit;
276014bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_HARD)
276114bf61ffSJan Kara dm->dqb_bhardlimit = di->d_spc_hardlimit;
276214bf61ffSJan Kara if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) {
2763884d179dSJan Kara check_blim = 1;
276408261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
2765884d179dSJan Kara }
2766c472b432SChristoph Hellwig
276714bf61ffSJan Kara if (di->d_fieldmask & QC_INO_COUNT) {
276814bf61ffSJan Kara dm->dqb_curinodes = di->d_ino_count;
2769884d179dSJan Kara check_ilim = 1;
277008261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
2771884d179dSJan Kara }
2772c472b432SChristoph Hellwig
277314bf61ffSJan Kara if (di->d_fieldmask & QC_INO_SOFT)
2774c472b432SChristoph Hellwig dm->dqb_isoftlimit = di->d_ino_softlimit;
277514bf61ffSJan Kara if (di->d_fieldmask & QC_INO_HARD)
2776c472b432SChristoph Hellwig dm->dqb_ihardlimit = di->d_ino_hardlimit;
277714bf61ffSJan Kara if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) {
2778884d179dSJan Kara check_ilim = 1;
277908261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
2780884d179dSJan Kara }
2781c472b432SChristoph Hellwig
278214bf61ffSJan Kara if (di->d_fieldmask & QC_SPC_TIMER) {
278314bf61ffSJan Kara dm->dqb_btime = di->d_spc_timer;
2784884d179dSJan Kara check_blim = 1;
278508261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
2786884d179dSJan Kara }
2787c472b432SChristoph Hellwig
278814bf61ffSJan Kara if (di->d_fieldmask & QC_INO_TIMER) {
278914bf61ffSJan Kara dm->dqb_itime = di->d_ino_timer;
2790884d179dSJan Kara check_ilim = 1;
279108261673SAndrew Perepechko set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
2792884d179dSJan Kara }
2793884d179dSJan Kara
2794884d179dSJan Kara if (check_blim) {
2795268157baSJan Kara if (!dm->dqb_bsoftlimit ||
27964b8e1106SChengguang Xu dm->dqb_curspace + dm->dqb_rsvspace <= dm->dqb_bsoftlimit) {
2797884d179dSJan Kara dm->dqb_btime = 0;
2798884d179dSJan Kara clear_bit(DQ_BLKS_B, &dquot->dq_flags);
279914bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_SPC_TIMER))
2800268157baSJan Kara /* Set grace only if user hasn't provided his own... */
2801e008bb61SArnd Bergmann dm->dqb_btime = ktime_get_real_seconds() + dqi->dqi_bgrace;
2802884d179dSJan Kara }
2803884d179dSJan Kara if (check_ilim) {
2804268157baSJan Kara if (!dm->dqb_isoftlimit ||
28054b8e1106SChengguang Xu dm->dqb_curinodes <= dm->dqb_isoftlimit) {
2806884d179dSJan Kara dm->dqb_itime = 0;
2807884d179dSJan Kara clear_bit(DQ_INODES_B, &dquot->dq_flags);
280814bf61ffSJan Kara } else if (!(di->d_fieldmask & QC_INO_TIMER))
2809268157baSJan Kara /* Set grace only if user hasn't provided his own... */
2810e008bb61SArnd Bergmann dm->dqb_itime = ktime_get_real_seconds() + dqi->dqi_igrace;
2811884d179dSJan Kara }
2812268157baSJan Kara if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2813268157baSJan Kara dm->dqb_isoftlimit)
2814884d179dSJan Kara clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2815884d179dSJan Kara else
2816884d179dSJan Kara set_bit(DQ_FAKE_B, &dquot->dq_flags);
28177b9ca4c6SJan Kara spin_unlock(&dquot->dq_dqb_lock);
2818884d179dSJan Kara mark_dquot_dirty(dquot);
2819884d179dSJan Kara
2820884d179dSJan Kara return 0;
2821884d179dSJan Kara }
2822884d179dSJan Kara
dquot_set_dqblk(struct super_block * sb,struct kqid qid,struct qc_dqblk * di)282374a8a103SEric W. Biederman int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
282414bf61ffSJan Kara struct qc_dqblk *di)
2825884d179dSJan Kara {
2826884d179dSJan Kara struct dquot *dquot;
2827884d179dSJan Kara int rc;
2828884d179dSJan Kara
2829aca645a6SEric W. Biederman dquot = dqget(sb, qid);
28306184fc0bSJan Kara if (IS_ERR(dquot)) {
28316184fc0bSJan Kara rc = PTR_ERR(dquot);
2832884d179dSJan Kara goto out;
2833884d179dSJan Kara }
2834884d179dSJan Kara rc = do_set_dqblk(dquot, di);
2835884d179dSJan Kara dqput(dquot);
2836884d179dSJan Kara out:
2837884d179dSJan Kara return rc;
2838884d179dSJan Kara }
2839287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqblk);
2840884d179dSJan Kara
2841884d179dSJan Kara /* Generic routine for getting common part of quota file information */
dquot_get_state(struct super_block * sb,struct qc_state * state)28420a240339SJan Kara int dquot_get_state(struct super_block *sb, struct qc_state *state)
2843884d179dSJan Kara {
2844884d179dSJan Kara struct mem_dqinfo *mi;
28450a240339SJan Kara struct qc_type_state *tstate;
28460a240339SJan Kara struct quota_info *dqopt = sb_dqopt(sb);
28470a240339SJan Kara int type;
2848884d179dSJan Kara
28490a240339SJan Kara memset(state, 0, sizeof(*state));
28500a240339SJan Kara for (type = 0; type < MAXQUOTAS; type++) {
28510a240339SJan Kara if (!sb_has_quota_active(sb, type))
28520a240339SJan Kara continue;
28530a240339SJan Kara tstate = state->s_state + type;
2854884d179dSJan Kara mi = sb_dqopt(sb)->info + type;
28550a240339SJan Kara tstate->flags = QCI_ACCT_ENABLED;
2856884d179dSJan Kara spin_lock(&dq_data_lock);
28570a240339SJan Kara if (mi->dqi_flags & DQF_SYS_FILE)
28580a240339SJan Kara tstate->flags |= QCI_SYSFILE;
28590a240339SJan Kara if (mi->dqi_flags & DQF_ROOT_SQUASH)
28600a240339SJan Kara tstate->flags |= QCI_ROOT_SQUASH;
28610a240339SJan Kara if (sb_has_quota_limits_enabled(sb, type))
28620a240339SJan Kara tstate->flags |= QCI_LIMITS_ENFORCED;
28630a240339SJan Kara tstate->spc_timelimit = mi->dqi_bgrace;
28640a240339SJan Kara tstate->ino_timelimit = mi->dqi_igrace;
2865a0828b6cSJan Kara if (dqopt->files[type]) {
28660a240339SJan Kara tstate->ino = dqopt->files[type]->i_ino;
28670a240339SJan Kara tstate->blocks = dqopt->files[type]->i_blocks;
2868a0828b6cSJan Kara }
28690a240339SJan Kara tstate->nextents = 1; /* We don't know... */
2870884d179dSJan Kara spin_unlock(&dq_data_lock);
28710a240339SJan Kara }
2872884d179dSJan Kara return 0;
2873884d179dSJan Kara }
28740a240339SJan Kara EXPORT_SYMBOL(dquot_get_state);
2875884d179dSJan Kara
2876884d179dSJan Kara /* Generic routine for setting common part of quota file information */
dquot_set_dqinfo(struct super_block * sb,int type,struct qc_info * ii)28775eacb2acSJan Kara int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii)
2878884d179dSJan Kara {
2879884d179dSJan Kara struct mem_dqinfo *mi;
2880884d179dSJan Kara
28815eacb2acSJan Kara if ((ii->i_fieldmask & QC_WARNS_MASK) ||
28825eacb2acSJan Kara (ii->i_fieldmask & QC_RT_SPC_TIMER))
28835eacb2acSJan Kara return -EINVAL;
28849d1ccbe7SJan Kara if (!sb_has_quota_active(sb, type))
28859d1ccbe7SJan Kara return -ESRCH;
2886884d179dSJan Kara mi = sb_dqopt(sb)->info + type;
28875eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) {
28885eacb2acSJan Kara if ((ii->i_flags & QCI_ROOT_SQUASH &&
28899d1ccbe7SJan Kara mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD))
28909d1ccbe7SJan Kara return -EINVAL;
2891ca6cb091SJan Kara }
2892884d179dSJan Kara spin_lock(&dq_data_lock);
28935eacb2acSJan Kara if (ii->i_fieldmask & QC_SPC_TIMER)
28945eacb2acSJan Kara mi->dqi_bgrace = ii->i_spc_timelimit;
28955eacb2acSJan Kara if (ii->i_fieldmask & QC_INO_TIMER)
28965eacb2acSJan Kara mi->dqi_igrace = ii->i_ino_timelimit;
28975eacb2acSJan Kara if (ii->i_fieldmask & QC_FLAGS) {
28985eacb2acSJan Kara if (ii->i_flags & QCI_ROOT_SQUASH)
28995eacb2acSJan Kara mi->dqi_flags |= DQF_ROOT_SQUASH;
29005eacb2acSJan Kara else
29015eacb2acSJan Kara mi->dqi_flags &= ~DQF_ROOT_SQUASH;
29025eacb2acSJan Kara }
2903884d179dSJan Kara spin_unlock(&dq_data_lock);
2904884d179dSJan Kara mark_info_dirty(sb, type);
2905884d179dSJan Kara /* Force write to disk */
2906c87d175dSYangtao Li return sb->dq_op->write_info(sb, type);
2907884d179dSJan Kara }
2908287a8095SChristoph Hellwig EXPORT_SYMBOL(dquot_set_dqinfo);
2909884d179dSJan Kara
29103e2af67eSJan Kara const struct quotactl_ops dquot_quotactl_sysfile_ops = {
29113e2af67eSJan Kara .quota_enable = dquot_quota_enable,
29123e2af67eSJan Kara .quota_disable = dquot_quota_disable,
29133e2af67eSJan Kara .quota_sync = dquot_quota_sync,
29140a240339SJan Kara .get_state = dquot_get_state,
29153e2af67eSJan Kara .set_info = dquot_set_dqinfo,
29163e2af67eSJan Kara .get_dqblk = dquot_get_dqblk,
2917be6257b2SJan Kara .get_nextdqblk = dquot_get_next_dqblk,
29183e2af67eSJan Kara .set_dqblk = dquot_set_dqblk
29193e2af67eSJan Kara };
29203e2af67eSJan Kara EXPORT_SYMBOL(dquot_quotactl_sysfile_ops);
29213e2af67eSJan Kara
do_proc_dqstats(struct ctl_table * table,int write,void * buffer,size_t * lenp,loff_t * ppos)2922dde95888SDmitry Monakhov static int do_proc_dqstats(struct ctl_table *table, int write,
292332927393SChristoph Hellwig void *buffer, size_t *lenp, loff_t *ppos)
2924dde95888SDmitry Monakhov {
29256fcbcec9SKonstantin Khlebnikov unsigned int type = (unsigned long *)table->data - dqstats.stat;
29266fcbcec9SKonstantin Khlebnikov s64 value = percpu_counter_sum(&dqstats.counter[type]);
29276fcbcec9SKonstantin Khlebnikov
29286fcbcec9SKonstantin Khlebnikov /* Filter negative values for non-monotonic counters */
29296fcbcec9SKonstantin Khlebnikov if (value < 0 && (type == DQST_ALLOC_DQUOTS ||
29306fcbcec9SKonstantin Khlebnikov type == DQST_FREE_DQUOTS))
29316fcbcec9SKonstantin Khlebnikov value = 0;
2932f32764bdSDmitry Monakhov
2933f32764bdSDmitry Monakhov /* Update global table */
29346fcbcec9SKonstantin Khlebnikov dqstats.stat[type] = value;
29356fcbcec9SKonstantin Khlebnikov return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
2936dde95888SDmitry Monakhov }
2937dde95888SDmitry Monakhov
2938e628753bSJoe Perches static struct ctl_table fs_dqstats_table[] = {
2939884d179dSJan Kara {
2940884d179dSJan Kara .procname = "lookups",
2941dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_LOOKUPS],
29426fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2943884d179dSJan Kara .mode = 0444,
2944dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2945884d179dSJan Kara },
2946884d179dSJan Kara {
2947884d179dSJan Kara .procname = "drops",
2948dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_DROPS],
29496fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2950884d179dSJan Kara .mode = 0444,
2951dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2952884d179dSJan Kara },
2953884d179dSJan Kara {
2954884d179dSJan Kara .procname = "reads",
2955dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_READS],
29566fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2957884d179dSJan Kara .mode = 0444,
2958dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2959884d179dSJan Kara },
2960884d179dSJan Kara {
2961884d179dSJan Kara .procname = "writes",
2962dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_WRITES],
29636fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2964884d179dSJan Kara .mode = 0444,
2965dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2966884d179dSJan Kara },
2967884d179dSJan Kara {
2968884d179dSJan Kara .procname = "cache_hits",
2969dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_CACHE_HITS],
29706fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2971884d179dSJan Kara .mode = 0444,
2972dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2973884d179dSJan Kara },
2974884d179dSJan Kara {
2975884d179dSJan Kara .procname = "allocated_dquots",
2976dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
29776fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2978884d179dSJan Kara .mode = 0444,
2979dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2980884d179dSJan Kara },
2981884d179dSJan Kara {
2982884d179dSJan Kara .procname = "free_dquots",
2983dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_FREE_DQUOTS],
29846fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2985884d179dSJan Kara .mode = 0444,
2986dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2987884d179dSJan Kara },
2988884d179dSJan Kara {
2989884d179dSJan Kara .procname = "syncs",
2990dde95888SDmitry Monakhov .data = &dqstats.stat[DQST_SYNCS],
29916fcbcec9SKonstantin Khlebnikov .maxlen = sizeof(unsigned long),
2992884d179dSJan Kara .mode = 0444,
2993dde95888SDmitry Monakhov .proc_handler = do_proc_dqstats,
2994884d179dSJan Kara },
2995884d179dSJan Kara #ifdef CONFIG_PRINT_QUOTA_WARNING
2996884d179dSJan Kara {
2997884d179dSJan Kara .procname = "warnings",
2998884d179dSJan Kara .data = &flag_print_warnings,
2999884d179dSJan Kara .maxlen = sizeof(int),
3000884d179dSJan Kara .mode = 0644,
30016d456111SEric W. Biederman .proc_handler = proc_dointvec,
3002884d179dSJan Kara },
3003884d179dSJan Kara #endif
3004ab09203eSEric W. Biederman { },
3005884d179dSJan Kara };
3006884d179dSJan Kara
dquot_init(void)3007884d179dSJan Kara static int __init dquot_init(void)
3008884d179dSJan Kara {
3009f32764bdSDmitry Monakhov int i, ret;
3010884d179dSJan Kara unsigned long nr_hash, order;
3011884d179dSJan Kara
3012884d179dSJan Kara printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
3013884d179dSJan Kara
30149e1fb91bSJan Kara register_sysctl_init("fs/quota", fs_dqstats_table);
3015884d179dSJan Kara
3016884d179dSJan Kara dquot_cachep = kmem_cache_create("dquot",
3017884d179dSJan Kara sizeof(struct dquot), sizeof(unsigned long) * 4,
3018884d179dSJan Kara (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
3019884d179dSJan Kara SLAB_MEM_SPREAD|SLAB_PANIC),
3020884d179dSJan Kara NULL);
3021884d179dSJan Kara
3022884d179dSJan Kara order = 0;
30231aa3b3e0SJia-Ju Bai dquot_hash = (struct hlist_head *)__get_free_pages(GFP_KERNEL, order);
3024884d179dSJan Kara if (!dquot_hash)
3025884d179dSJan Kara panic("Cannot create dquot hash table");
3026884d179dSJan Kara
3027f32764bdSDmitry Monakhov for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
3028908c7f19STejun Heo ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL);
3029f32764bdSDmitry Monakhov if (ret)
3030f32764bdSDmitry Monakhov panic("Cannot create dquot stat counters");
3031f32764bdSDmitry Monakhov }
3032dde95888SDmitry Monakhov
3033884d179dSJan Kara /* Find power-of-two hlist_heads which can fit into allocation */
3034884d179dSJan Kara nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
303524fc755fSChengguang Xu dq_hash_bits = ilog2(nr_hash);
3036884d179dSJan Kara
3037884d179dSJan Kara nr_hash = 1UL << dq_hash_bits;
3038884d179dSJan Kara dq_hash_mask = nr_hash - 1;
3039884d179dSJan Kara for (i = 0; i < nr_hash; i++)
3040884d179dSJan Kara INIT_HLIST_HEAD(dquot_hash + i);
3041884d179dSJan Kara
304219858e7bSAnton Blanchard pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld,"
304319858e7bSAnton Blanchard " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order));
3044884d179dSJan Kara
3045e33c267aSRoman Gushchin if (register_shrinker(&dqcache_shrinker, "dquota-cache"))
304688bc0edeSTetsuo Handa panic("Cannot register dquot shrinker");
3047884d179dSJan Kara
3048884d179dSJan Kara return 0;
3049884d179dSJan Kara }
3050331221faSPaul Gortmaker fs_initcall(dquot_init);
3051