blob: b6a4f692d3457e18f281cf2cc9ebf8a3215a1ef5 [file] [log] [blame]
Greg Kroah-Hartmanb2441312017-11-01 15:07:57 +01001// SPDX-License-Identifier: GPL-2.0
Linus Torvalds1da177e2005-04-16 15:20:36 -07002/*
3 * Implementation of the diskquota system for the LINUX operating system. QUOTA
4 * is implemented using the BSD system call interface as the means of
5 * communication with the user level. This file contains the generic routines
6 * called by the different filesystems on allocation of an inode or block.
7 * These routines take care of the administration needed to have a consistent
8 * diskquota tracking system. The ideas of both user and group quotas are based
9 * on the Melbourne quota system as used on BSD derived systems. The internal
10 * implementation is based on one of the several variants of the LINUX
11 * inode-subsystem with added complexity of the diskquota system.
Sascha Hauer27942ef2019-03-26 08:54:31 +010012 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070013 * Author: Marco van Wieringen <mvw@planets.elm.net>
14 *
15 * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
16 *
17 * Revised list management to avoid races
18 * -- Bill Hawes, <whawes@star.net>, 9/98
19 *
20 * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...().
21 * As the consequence the locking was moved from dquot_decr_...(),
22 * dquot_incr_...() to calling functions.
23 * invalidate_dquots() now writes modified dquots.
24 * Serialized quota_off() and quota_on() for mount point.
25 * Fixed a few bugs in grow_dquots().
26 * Fixed deadlock in write_dquot() - we no longer account quotas on
27 * quota files
28 * remove_dquot_ref() moved to inode.c - it now traverses through inodes
29 * add_dquot_ref() restarts after blocking
30 * Added check for bogus uid and fixed check for group in quotactl.
31 * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99
32 *
33 * Used struct list_head instead of own list struct
34 * Invalidation of referenced dquots is no longer possible
35 * Improved free_dquots list management
36 * Quota and i_blocks are now updated in one place to avoid races
37 * Warnings are now delayed so we won't block in critical section
38 * Write updated not to require dquot lock
39 * Jan Kara, <jack@suse.cz>, 9/2000
40 *
41 * Added dynamic quota structure allocation
42 * Jan Kara <jack@suse.cz> 12/2000
43 *
44 * Rewritten quota interface. Implemented new quota format and
45 * formats registering.
46 * Jan Kara, <jack@suse.cz>, 2001,2002
47 *
48 * New SMP locking.
49 * Jan Kara, <jack@suse.cz>, 10/2002
50 *
51 * Added journalled quota support, fix lock inversion problems
52 * Jan Kara, <jack@suse.cz>, 2003,2004
53 *
Sascha Hauer27942ef2019-03-26 08:54:31 +010054 * (C) Copyright 1994 - 1997 Marco van Wieringen
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 */
56
57#include <linux/errno.h>
58#include <linux/kernel.h>
59#include <linux/fs.h>
60#include <linux/mount.h>
61#include <linux/mm.h>
62#include <linux/time.h>
63#include <linux/types.h>
64#include <linux/string.h>
65#include <linux/fcntl.h>
66#include <linux/stat.h>
67#include <linux/tty.h>
68#include <linux/file.h>
69#include <linux/slab.h>
70#include <linux/sysctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070071#include <linux/init.h>
72#include <linux/module.h>
73#include <linux/proc_fs.h>
74#include <linux/security.h>
Al Viro40401532012-02-13 03:58:52 +000075#include <linux/sched.h>
Ingo Molnar5b825c32017-02-02 17:54:15 +010076#include <linux/cred.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070077#include <linux/kmod.h>
78#include <linux/namei.h>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080079#include <linux/capability.h>
Adrian Bunkbe586ba2005-11-07 00:59:35 -080080#include <linux/quotaops.h>
Dave Chinner55fa6092011-03-22 22:23:40 +110081#include "../internal.h" /* ugh */
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
Jeff Liuf3da9312012-05-28 23:40:17 +080083#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070084
Linus Torvalds1da177e2005-04-16 15:20:36 -070085/*
Jan Kara7b9ca4c2017-08-07 13:19:50 +020086 * There are five quota SMP locks:
87 * * dq_list_lock protects all lists with quotas and quota formats.
88 * * dquot->dq_dqb_lock protects data from dq_dqb
89 * * inode->i_lock protects inode->i_blocks, i_bytes and also guards
90 * consistency of dquot->dq_dqb with inode->i_blocks, i_bytes so that
91 * dquot_transfer() can stabilize amount it transfers
92 * * dq_data_lock protects mem_dqinfo structures and modifications of dquot
93 * pointers in the inode
94 * * dq_state_lock protects modifications of quota state (on quotaon and
95 * quotaoff) and readers who care about latest values take it as well.
Linus Torvalds1da177e2005-04-16 15:20:36 -070096 *
Jan Kara7b9ca4c2017-08-07 13:19:50 +020097 * The spinlock ordering is hence:
98 * dq_data_lock > dq_list_lock > i_lock > dquot->dq_dqb_lock,
Jan Karacc334122009-01-12 17:23:05 +010099 * dq_list_lock > dq_state_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100 *
101 * Note that some things (eg. sb pointer, type, id) doesn't change during
102 * the life of the dquot structure and so needn't to be protected by a lock
103 *
Niu Yaweib9ba6f92014-06-04 12:23:19 +0800104 * Operation accessing dquots via inode pointers are protected by dquot_srcu.
105 * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and
106 * synchronize_srcu(&dquot_srcu) is called after clearing pointers from
107 * inode and before dropping dquot references to avoid use of dquots after
108 * they are freed. dq_data_lock is used to serialize the pointer setting and
109 * clearing operations.
Jan Kara26245c92010-01-06 17:20:35 +0100110 * Special care needs to be taken about S_NOQUOTA inode flag (marking that
111 * inode is a quota file). Functions adding pointers from inode to dquots have
Niu Yaweib9ba6f92014-06-04 12:23:19 +0800112 * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they
113 * have to do all pointer modifications before dropping dq_data_lock. This makes
Jan Kara26245c92010-01-06 17:20:35 +0100114 * sure they cannot race with quotaon which first sets S_NOQUOTA flag and
115 * then drops all pointers to dquots from an inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 *
Jan Kara5e8cb9b2017-06-08 15:16:41 +0200117 * Each dquot has its dq_lock mutex. Dquot is locked when it is being read to
118 * memory (or space for it is being allocated) on the first dqget(), when it is
119 * being written out, and when it is being released on the last dqput(). The
120 * allocation and release operations are serialized by the dq_lock and by
121 * checking the use count in dquot_release().
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 *
123 * Lock ordering (including related VFS locks) is the following:
Jan Karabc8230e2017-06-08 14:39:48 +0200124 * s_umount > i_mutex > journal_lock > dquot->dq_lock > dqio_sem
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 */
126
Jan Karac5166102009-01-26 15:32:46 +0100127static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock);
128static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
129__cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
Mingming Cao08d03502009-01-14 16:19:32 +0100130EXPORT_SYMBOL(dq_data_lock);
Niu Yaweib9ba6f92014-06-04 12:23:19 +0800131DEFINE_STATIC_SRCU(dquot_srcu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132
Jan Kara503330f2017-08-02 17:18:50 +0200133static DECLARE_WAIT_QUEUE_HEAD(dquot_ref_wq);
134
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200135void __quota_error(struct super_block *sb, const char *func,
Joe Perches055adcb2010-11-23 18:49:54 -0800136 const char *fmt, ...)
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200137{
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200138 if (printk_ratelimit()) {
Joe Perches055adcb2010-11-23 18:49:54 -0800139 va_list args;
140 struct va_format vaf;
141
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200142 va_start(args, fmt);
Joe Perches055adcb2010-11-23 18:49:54 -0800143
144 vaf.fmt = fmt;
145 vaf.va = &args;
146
147 printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
148 sb->s_id, func, &vaf);
149
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200150 va_end(args);
151 }
152}
153EXPORT_SYMBOL(__quota_error);
154
Sergey Senozhatskyda8d1ba2010-04-26 12:09:26 +0200155#if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156static char *quotatypes[] = INITQFNAMES;
Sergey Senozhatskyda8d1ba2010-04-26 12:09:26 +0200157#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158static struct quota_format_type *quota_formats; /* List of registered formats */
159static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
160
161/* SLAB cache for dquot structures */
Christoph Lametere18b8902006-12-06 20:33:20 -0800162static struct kmem_cache *dquot_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164int register_quota_format(struct quota_format_type *fmt)
165{
166 spin_lock(&dq_list_lock);
167 fmt->qf_next = quota_formats;
168 quota_formats = fmt;
169 spin_unlock(&dq_list_lock);
170 return 0;
171}
Mingming Cao08d03502009-01-14 16:19:32 +0100172EXPORT_SYMBOL(register_quota_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
174void unregister_quota_format(struct quota_format_type *fmt)
175{
176 struct quota_format_type **actqf;
177
178 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100179 for (actqf = &quota_formats; *actqf && *actqf != fmt;
180 actqf = &(*actqf)->qf_next)
181 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 if (*actqf)
183 *actqf = (*actqf)->qf_next;
184 spin_unlock(&dq_list_lock);
185}
Mingming Cao08d03502009-01-14 16:19:32 +0100186EXPORT_SYMBOL(unregister_quota_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188static struct quota_format_type *find_quota_format(int id)
189{
190 struct quota_format_type *actqf;
191
192 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100193 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
194 actqf = actqf->qf_next)
195 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 if (!actqf || !try_module_get(actqf->qf_owner)) {
197 int qm;
198
199 spin_unlock(&dq_list_lock);
Sascha Hauer27942ef2019-03-26 08:54:31 +0100200
Jan Kara268157b2009-01-27 15:47:22 +0100201 for (qm = 0; module_names[qm].qm_fmt_id &&
202 module_names[qm].qm_fmt_id != id; qm++)
203 ;
204 if (!module_names[qm].qm_fmt_id ||
205 request_module(module_names[qm].qm_mod_name))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 return NULL;
207
208 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100209 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
210 actqf = actqf->qf_next)
211 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 if (actqf && !try_module_get(actqf->qf_owner))
213 actqf = NULL;
214 }
215 spin_unlock(&dq_list_lock);
216 return actqf;
217}
218
219static void put_quota_format(struct quota_format_type *fmt)
220{
221 module_put(fmt->qf_owner);
222}
223
224/*
225 * Dquot List Management:
Chengguang Xuf44840a2019-05-06 09:39:03 +0800226 * The quota code uses four lists for dquot management: the inuse_list,
227 * free_dquots, dqi_dirty_list, and dquot_hash[] array. A single dquot
228 * structure may be on some of those lists, depending on its current state.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229 *
230 * All dquots are placed to the end of inuse_list when first created, and this
231 * list is used for invalidate operation, which must look at every dquot.
232 *
233 * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
234 * and this list is searched whenever we need an available dquot. Dquots are
235 * removed from the list as soon as they are used again, and
236 * dqstats.free_dquots gives the number of dquots on the list. When
237 * dquot is invalidated it's completely released from memory.
238 *
Chengguang Xuf44840a2019-05-06 09:39:03 +0800239 * Dirty dquots are added to the dqi_dirty_list of quota_info when mark
240 * dirtied, and this list is searched when writing dirty dquots back to
241 * quota file. Note that some filesystems do dirty dquot tracking on their
242 * own (e.g. in a journal) and thus don't use dqi_dirty_list.
243 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 * Dquots with a specific identity (device, type and id) are placed on
245 * one of the dquot_hash[] hash chains. The provides an efficient search
246 * mechanism to locate a specific dquot.
247 */
248
249static LIST_HEAD(inuse_list);
250static LIST_HEAD(free_dquots);
251static unsigned int dq_hash_bits, dq_hash_mask;
252static struct hlist_head *dquot_hash;
253
254struct dqstats dqstats;
Mingming Cao08d03502009-01-14 16:19:32 +0100255EXPORT_SYMBOL(dqstats);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256
Jan Kara0a5a9c72010-02-09 18:20:39 +0100257static qsize_t inode_get_rsv_space(struct inode *inode);
Jan Kara7b9ca4c2017-08-07 13:19:50 +0200258static qsize_t __inode_get_rsv_space(struct inode *inode);
Jan Kara6184fc02015-06-24 18:07:02 +0200259static int __dquot_initialize(struct inode *inode, int type);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100260
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261static inline unsigned int
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700262hashfn(const struct super_block *sb, struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263{
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700264 unsigned int id = from_kqid(&init_user_ns, qid);
265 int type = qid.type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 unsigned long tmp;
267
268 tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
269 return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
270}
271
272/*
273 * Following list functions expect dq_list_lock to be held
274 */
275static inline void insert_dquot_hash(struct dquot *dquot)
276{
Jan Kara268157b2009-01-27 15:47:22 +0100277 struct hlist_head *head;
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700278 head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 hlist_add_head(&dquot->dq_hash, head);
280}
281
282static inline void remove_dquot_hash(struct dquot *dquot)
283{
284 hlist_del_init(&dquot->dq_hash);
285}
286
Jan Kara7a2435d2009-01-27 01:47:11 +0100287static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700288 struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289{
290 struct hlist_node *node;
291 struct dquot *dquot;
292
293 hlist_for_each (node, dquot_hash+hashent) {
294 dquot = hlist_entry(node, struct dquot, dq_hash);
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700295 if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 return dquot;
297 }
Jan Karadd6f3c62009-01-26 16:01:43 +0100298 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
301/* Add a dquot to the tail of the free list */
302static inline void put_dquot_last(struct dquot *dquot)
303{
Akinobu Mita8e130592006-06-26 00:24:37 -0700304 list_add_tail(&dquot->dq_free, &free_dquots);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400305 dqstats_inc(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306}
307
308static inline void remove_free_dquot(struct dquot *dquot)
309{
310 if (list_empty(&dquot->dq_free))
311 return;
312 list_del_init(&dquot->dq_free);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400313 dqstats_dec(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314}
315
316static inline void put_inuse(struct dquot *dquot)
317{
318 /* We add to the back of inuse list so we don't have to restart
319 * when traversing this list and we block */
Akinobu Mita8e130592006-06-26 00:24:37 -0700320 list_add_tail(&dquot->dq_inuse, &inuse_list);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400321 dqstats_inc(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322}
323
324static inline void remove_inuse(struct dquot *dquot)
325{
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400326 dqstats_dec(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700327 list_del(&dquot->dq_inuse);
328}
329/*
330 * End of list functions needing dq_list_lock
331 */
332
333static void wait_on_dquot(struct dquot *dquot)
334{
Ingo Molnard3be9152006-03-23 03:00:29 -0800335 mutex_lock(&dquot->dq_lock);
336 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337}
338
Jan Kara03f6e922008-04-28 02:14:32 -0700339static inline int dquot_dirty(struct dquot *dquot)
340{
341 return test_bit(DQ_MOD_B, &dquot->dq_flags);
342}
343
344static inline int mark_dquot_dirty(struct dquot *dquot)
345{
346 return dquot->dq_sb->dq_op->mark_dirty(dquot);
347}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300349/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350int dquot_mark_dquot_dirty(struct dquot *dquot)
351{
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300352 int ret = 1;
353
Jan Kara4580b30e2017-08-02 11:44:38 +0200354 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
355 return 0;
356
Jan Kara834057b2017-08-03 11:18:23 +0200357 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
358 return test_and_set_bit(DQ_MOD_B, &dquot->dq_flags);
359
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300360 /* If quota is dirty already, we don't have to acquire dq_list_lock */
361 if (test_bit(DQ_MOD_B, &dquot->dq_flags))
362 return 1;
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 spin_lock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300365 if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700367 info[dquot->dq_id.type].dqi_dirty_list);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300368 ret = 0;
369 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370 spin_unlock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300371 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372}
Mingming Cao08d03502009-01-14 16:19:32 +0100373EXPORT_SYMBOL(dquot_mark_dquot_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +0300375/* Dirtify all the dquots - this can block when journalling */
376static inline int mark_all_dquot_dirty(struct dquot * const *dquot)
377{
378 int ret, err, cnt;
379
380 ret = err = 0;
381 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
382 if (dquot[cnt])
383 /* Even in case of error we have to continue */
384 ret = mark_dquot_dirty(dquot[cnt]);
385 if (!err)
386 err = ret;
387 }
388 return err;
389}
390
391static inline void dqput_all(struct dquot **dquot)
392{
393 unsigned int cnt;
394
395 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
396 dqput(dquot[cnt]);
397}
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399static inline int clear_dquot_dirty(struct dquot *dquot)
400{
Jan Kara834057b2017-08-03 11:18:23 +0200401 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
402 return test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags);
403
Jan Kara1e0b7cb2017-08-02 11:54:26 +0200404 spin_lock(&dq_list_lock);
405 if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) {
406 spin_unlock(&dq_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 return 0;
Jan Kara1e0b7cb2017-08-02 11:54:26 +0200408 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700409 list_del_init(&dquot->dq_dirty);
Jan Kara1e0b7cb2017-08-02 11:54:26 +0200410 spin_unlock(&dq_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 return 1;
412}
413
414void mark_info_dirty(struct super_block *sb, int type)
415{
Jan Kara15512372017-06-09 11:56:06 +0200416 spin_lock(&dq_data_lock);
417 sb_dqopt(sb)->info[type].dqi_flags |= DQF_INFO_DIRTY;
418 spin_unlock(&dq_data_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419}
420EXPORT_SYMBOL(mark_info_dirty);
421
422/*
423 * Read dquot from disk and alloc space for it
424 */
425
426int dquot_acquire(struct dquot *dquot)
427{
428 int ret = 0, ret2 = 0;
429 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
430
Ingo Molnard3be9152006-03-23 03:00:29 -0800431 mutex_lock(&dquot->dq_lock);
Chengguang Xu3ef177e2019-04-19 13:46:01 +0800432 if (!test_bit(DQ_READ_B, &dquot->dq_flags)) {
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700433 ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot);
Chengguang Xu3ef177e2019-04-19 13:46:01 +0800434 if (ret < 0)
435 goto out_iolock;
436 }
Jan Kara044c9b62016-02-18 13:20:20 +0100437 /* Make sure flags update is visible after dquot has been filled */
438 smp_mb__before_atomic();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 set_bit(DQ_READ_B, &dquot->dq_flags);
440 /* Instantiate dquot if needed */
441 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700442 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 /* Write the info if needed */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700444 if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
445 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
446 dquot->dq_sb, dquot->dq_id.type);
Jan Kara268157b2009-01-27 15:47:22 +0100447 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 if (ret < 0)
449 goto out_iolock;
450 if (ret2 < 0) {
451 ret = ret2;
452 goto out_iolock;
453 }
454 }
Jan Kara044c9b62016-02-18 13:20:20 +0100455 /*
456 * Make sure flags update is visible after on-disk struct has been
457 * allocated. Paired with smp_rmb() in dqget().
458 */
459 smp_mb__before_atomic();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
461out_iolock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800462 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return ret;
464}
Mingming Cao08d03502009-01-14 16:19:32 +0100465EXPORT_SYMBOL(dquot_acquire);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
467/*
468 * Write dquot to disk
469 */
470int dquot_commit(struct dquot *dquot)
471{
Jan Karab03f2452011-03-31 18:36:52 +0200472 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
474
Jan Kara5e8cb9b2017-06-08 15:16:41 +0200475 mutex_lock(&dquot->dq_lock);
Jan Kara1e0b7cb2017-08-02 11:54:26 +0200476 if (!clear_dquot_dirty(dquot))
Jan Kara5e8cb9b2017-06-08 15:16:41 +0200477 goto out_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 /* Inactive dquot can be only if there was error during read/init
479 * => we have better not writing it */
Jan Karab03f2452011-03-31 18:36:52 +0200480 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700481 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
Jan Karab03f2452011-03-31 18:36:52 +0200482 else
483 ret = -EIO;
Jan Kara5e8cb9b2017-06-08 15:16:41 +0200484out_lock:
485 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 return ret;
487}
Mingming Cao08d03502009-01-14 16:19:32 +0100488EXPORT_SYMBOL(dquot_commit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490/*
491 * Release dquot
492 */
493int dquot_release(struct dquot *dquot)
494{
495 int ret = 0, ret2 = 0;
496 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
497
Ingo Molnard3be9152006-03-23 03:00:29 -0800498 mutex_lock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 /* Check whether we are not racing with some other dqget() */
Dmitry Monakhovdf4bb5d2019-10-31 10:39:20 +0000500 if (dquot_is_busy(dquot))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 goto out_dqlock;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700502 if (dqopt->ops[dquot->dq_id.type]->release_dqblk) {
503 ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 /* Write the info */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700505 if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
506 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
507 dquot->dq_sb, dquot->dq_id.type);
Jan Kara268157b2009-01-27 15:47:22 +0100508 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 if (ret >= 0)
510 ret = ret2;
511 }
512 clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513out_dqlock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800514 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515 return ret;
516}
Mingming Cao08d03502009-01-14 16:19:32 +0100517EXPORT_SYMBOL(dquot_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Jan Kara7d9056b2008-11-25 15:31:32 +0100519void dquot_destroy(struct dquot *dquot)
Jan Kara74f783a2008-08-19 14:51:22 +0200520{
521 kmem_cache_free(dquot_cachep, dquot);
522}
Jan Kara7d9056b2008-11-25 15:31:32 +0100523EXPORT_SYMBOL(dquot_destroy);
Jan Kara74f783a2008-08-19 14:51:22 +0200524
525static inline void do_destroy_dquot(struct dquot *dquot)
526{
527 dquot->dq_sb->dq_op->destroy_dquot(dquot);
528}
529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530/* Invalidate all dquots on the list. Note that this function is called after
531 * quota is disabled and pointers from inodes removed so there cannot be new
Jan Kara6362e4d2006-03-23 03:00:17 -0800532 * quota users. There can still be some users of quotas due to inodes being
533 * just deleted or pruned by prune_icache() (those are not attached to any
Jan Karacc334122009-01-12 17:23:05 +0100534 * list) or parallel quotactl call. We have to wait for such users.
Jan Kara6362e4d2006-03-23 03:00:17 -0800535 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536static void invalidate_dquots(struct super_block *sb, int type)
537{
Domen Puncerc33ed272005-06-25 14:59:36 -0700538 struct dquot *dquot, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539
Jan Kara6362e4d2006-03-23 03:00:17 -0800540restart:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 spin_lock(&dq_list_lock);
Domen Puncerc33ed272005-06-25 14:59:36 -0700542 list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 if (dquot->dq_sb != sb)
544 continue;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700545 if (dquot->dq_id.type != type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546 continue;
Jan Kara6362e4d2006-03-23 03:00:17 -0800547 /* Wait for dquot users */
548 if (atomic_read(&dquot->dq_count)) {
Jan Kara9f985cb2014-04-03 14:46:55 -0700549 dqgrab(dquot);
Jan Kara6362e4d2006-03-23 03:00:17 -0800550 spin_unlock(&dq_list_lock);
Jan Kara503330f2017-08-02 17:18:50 +0200551 /*
552 * Once dqput() wakes us up, we know it's time to free
Jan Kara6362e4d2006-03-23 03:00:17 -0800553 * the dquot.
554 * IMPORTANT: we rely on the fact that there is always
555 * at most one process waiting for dquot to free.
556 * Otherwise dq_count would be > 1 and we would never
557 * wake up.
558 */
Jan Kara503330f2017-08-02 17:18:50 +0200559 wait_event(dquot_ref_wq,
560 atomic_read(&dquot->dq_count) == 1);
Jan Kara6362e4d2006-03-23 03:00:17 -0800561 dqput(dquot);
562 /* At this moment dquot() need not exist (it could be
563 * reclaimed by prune_dqcache(). Hence we must
564 * restart. */
565 goto restart;
566 }
567 /*
568 * Quota now has no users and it has been written on last
569 * dqput()
570 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700571 remove_dquot_hash(dquot);
572 remove_free_dquot(dquot);
573 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200574 do_destroy_dquot(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700575 }
576 spin_unlock(&dq_list_lock);
577}
578
Jan Kara12c77522008-10-20 17:05:00 +0200579/* Call callback for every active dquot on given filesystem */
580int dquot_scan_active(struct super_block *sb,
581 int (*fn)(struct dquot *dquot, unsigned long priv),
582 unsigned long priv)
583{
584 struct dquot *dquot, *old_dquot = NULL;
585 int ret = 0;
586
Jan Karaee1ac542016-11-23 13:52:19 +0100587 WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));
588
Jan Kara12c77522008-10-20 17:05:00 +0200589 spin_lock(&dq_list_lock);
590 list_for_each_entry(dquot, &inuse_list, dq_inuse) {
591 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
592 continue;
593 if (dquot->dq_sb != sb)
594 continue;
595 /* Now we have active dquot so we can just increase use count */
596 atomic_inc(&dquot->dq_count);
Jan Kara12c77522008-10-20 17:05:00 +0200597 spin_unlock(&dq_list_lock);
598 dqput(old_dquot);
599 old_dquot = dquot;
Jan Kara1362f4e2014-02-20 17:02:27 +0100600 /*
601 * ->release_dquot() can be racing with us. Our reference
602 * protects us from new calls to it so just wait for any
603 * outstanding call and recheck the DQ_ACTIVE_B after that.
604 */
605 wait_on_dquot(dquot);
606 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
607 ret = fn(dquot, priv);
608 if (ret < 0)
609 goto out;
610 }
Jan Kara12c77522008-10-20 17:05:00 +0200611 spin_lock(&dq_list_lock);
612 /* We are safe to continue now because our dquot could not
613 * be moved out of the inuse list while we hold the reference */
614 }
615 spin_unlock(&dq_list_lock);
616out:
617 dqput(old_dquot);
Jan Kara12c77522008-10-20 17:05:00 +0200618 return ret;
619}
Mingming Cao08d03502009-01-14 16:19:32 +0100620EXPORT_SYMBOL(dquot_scan_active);
Jan Kara12c77522008-10-20 17:05:00 +0200621
Jan Karaceed1722012-07-03 16:45:28 +0200622/* Write all dquot structures to quota files */
623int dquot_writeback_dquots(struct super_block *sb, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624{
Dmitry Monakhov6ff33d92019-10-31 10:39:19 +0000625 struct list_head dirty;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 struct dquot *dquot;
627 struct quota_info *dqopt = sb_dqopt(sb);
628 int cnt;
Jan Karaceed1722012-07-03 16:45:28 +0200629 int err, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630
Jan Kara9d1ccbe2016-11-23 13:35:14 +0100631 WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));
632
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
634 if (type != -1 && cnt != type)
635 continue;
Jan Karaf55abc02008-08-20 17:50:32 +0200636 if (!sb_has_quota_active(sb, cnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 continue;
638 spin_lock(&dq_list_lock);
Dmitry Monakhov6ff33d92019-10-31 10:39:19 +0000639 /* Move list away to avoid livelock. */
640 list_replace_init(&dqopt->info[cnt].dqi_dirty_list, &dirty);
641 while (!list_empty(&dirty)) {
642 dquot = list_first_entry(&dirty, struct dquot,
Jan Kara268157b2009-01-27 15:47:22 +0100643 dq_dirty);
Jan Kara4580b30e2017-08-02 11:44:38 +0200644
645 WARN_ON(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));
646
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 /* Now we have active dquot from which someone is
648 * holding reference so we can safely just increase
649 * use count */
Jan Kara9f985cb2014-04-03 14:46:55 -0700650 dqgrab(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 spin_unlock(&dq_list_lock);
Jan Karaceed1722012-07-03 16:45:28 +0200652 err = sb->dq_op->write_dquot(dquot);
zhangyi (F)dd5f6272017-11-01 18:40:45 +0800653 if (err) {
654 /*
655 * Clear dirty bit anyway to avoid infinite
656 * loop here.
657 */
658 clear_dquot_dirty(dquot);
659 if (!ret)
660 ret = err;
661 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 dqput(dquot);
663 spin_lock(&dq_list_lock);
664 }
665 spin_unlock(&dq_list_lock);
666 }
667
668 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karaf55abc02008-08-20 17:50:32 +0200669 if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
670 && info_dirty(&dqopt->info[cnt]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671 sb->dq_op->write_info(sb, cnt);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400672 dqstats_inc(DQST_SYNCS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673
Jan Karaceed1722012-07-03 16:45:28 +0200674 return ret;
675}
676EXPORT_SYMBOL(dquot_writeback_dquots);
677
678/* Write all dquot structures to disk and make them visible from userspace */
679int dquot_quota_sync(struct super_block *sb, int type)
680{
681 struct quota_info *dqopt = sb_dqopt(sb);
682 int cnt;
683 int ret;
684
685 ret = dquot_writeback_dquots(sb, type);
686 if (ret)
687 return ret;
688 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500689 return 0;
690
691 /* This is not very clever (and fast) but currently I don't know about
692 * any other simple way of getting quota data to disk and we must get
693 * them there for userspace to be visible... */
694 if (sb->s_op->sync_fs)
695 sb->s_op->sync_fs(sb, 1);
696 sync_blockdev(sb->s_bdev);
697
698 /*
699 * Now when everything is written we can discard the pagecache so
700 * that userspace sees the changes.
701 */
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500702 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
703 if (type != -1 && cnt != type)
704 continue;
705 if (!sb_has_quota_active(sb, cnt))
706 continue;
Al Viro59551022016-01-22 15:40:57 -0500707 inode_lock(dqopt->files[cnt]);
Jan Karaf9ef1782012-04-25 21:10:31 +0200708 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
Al Viro59551022016-01-22 15:40:57 -0500709 inode_unlock(dqopt->files[cnt]);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500710 }
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712 return 0;
713}
Christoph Hellwig287a8092010-05-19 07:16:45 -0400714EXPORT_SYMBOL(dquot_quota_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715
Dave Chinner1ab6c492013-08-28 10:18:09 +1000716static unsigned long
717dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 struct dquot *dquot;
Dave Chinner1ab6c492013-08-28 10:18:09 +1000720 unsigned long freed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721
Niu Yaweid68aab6b2014-06-04 12:22:13 +0800722 spin_lock(&dq_list_lock);
Jan Kara18221932018-06-11 12:14:45 +0200723 while (!list_empty(&free_dquots) && sc->nr_to_scan) {
724 dquot = list_first_entry(&free_dquots, struct dquot, dq_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 remove_dquot_hash(dquot);
726 remove_free_dquot(dquot);
727 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200728 do_destroy_dquot(dquot);
Dave Chinner1ab6c492013-08-28 10:18:09 +1000729 sc->nr_to_scan--;
730 freed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 }
Niu Yaweid68aab6b2014-06-04 12:22:13 +0800732 spin_unlock(&dq_list_lock);
Dave Chinner1ab6c492013-08-28 10:18:09 +1000733 return freed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734}
735
Dave Chinner1ab6c492013-08-28 10:18:09 +1000736static unsigned long
737dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Glauber Costa55f841c2013-08-28 10:17:53 +1000739 return vfs_pressure_ratio(
740 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741}
742
Rusty Russell8e1f9362007-07-17 04:03:17 -0700743static struct shrinker dqcache_shrinker = {
Dave Chinner1ab6c492013-08-28 10:18:09 +1000744 .count_objects = dqcache_shrink_count,
745 .scan_objects = dqcache_shrink_scan,
Rusty Russell8e1f9362007-07-17 04:03:17 -0700746 .seeks = DEFAULT_SEEKS,
747};
748
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749/*
750 * Put reference to dquot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200752void dqput(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753{
Jan Karab48d3802008-07-25 01:46:49 -0700754 int ret;
755
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 if (!dquot)
757 return;
Jan Kara62af9b52010-04-19 16:47:20 +0200758#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 if (!atomic_read(&dquot->dq_count)) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200760 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700761 quotatypes[dquot->dq_id.type],
762 from_kqid(&init_user_ns, dquot->dq_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763 BUG();
764 }
765#endif
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400766 dqstats_inc(DQST_DROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700767we_slept:
768 spin_lock(&dq_list_lock);
769 if (atomic_read(&dquot->dq_count) > 1) {
770 /* We have more than one user... nothing to do */
771 atomic_dec(&dquot->dq_count);
Jan Kara6362e4d2006-03-23 03:00:17 -0800772 /* Releasing dquot during quotaoff phase? */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700773 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) &&
Jan Kara6362e4d2006-03-23 03:00:17 -0800774 atomic_read(&dquot->dq_count) == 1)
Jan Kara503330f2017-08-02 17:18:50 +0200775 wake_up(&dquot_ref_wq);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700776 spin_unlock(&dq_list_lock);
777 return;
778 }
779 /* Need to release dquot? */
Jan Kara4580b30e2017-08-02 11:44:38 +0200780 if (dquot_dirty(dquot)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 spin_unlock(&dq_list_lock);
782 /* Commit dquot before releasing */
Jan Karab48d3802008-07-25 01:46:49 -0700783 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
784 if (ret < 0) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200785 quota_error(dquot->dq_sb, "Can't write quota structure"
786 " (error %d). Quota may get out of sync!",
787 ret);
Jan Karab48d3802008-07-25 01:46:49 -0700788 /*
789 * We clear dirty bit anyway, so that we avoid
790 * infinite loop here
791 */
Jan Karab48d3802008-07-25 01:46:49 -0700792 clear_dquot_dirty(dquot);
Jan Karab48d3802008-07-25 01:46:49 -0700793 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 goto we_slept;
795 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
797 spin_unlock(&dq_list_lock);
798 dquot->dq_sb->dq_op->release_dquot(dquot);
799 goto we_slept;
800 }
801 atomic_dec(&dquot->dq_count);
Jan Kara62af9b52010-04-19 16:47:20 +0200802#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803 /* sanity check */
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200804 BUG_ON(!list_empty(&dquot->dq_free));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700805#endif
806 put_dquot_last(dquot);
807 spin_unlock(&dq_list_lock);
808}
Mingming Cao08d03502009-01-14 16:19:32 +0100809EXPORT_SYMBOL(dqput);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Jan Kara7d9056b2008-11-25 15:31:32 +0100811struct dquot *dquot_alloc(struct super_block *sb, int type)
Jan Kara74f783a2008-08-19 14:51:22 +0200812{
813 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
814}
Jan Kara7d9056b2008-11-25 15:31:32 +0100815EXPORT_SYMBOL(dquot_alloc);
Jan Kara74f783a2008-08-19 14:51:22 +0200816
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817static struct dquot *get_empty_dquot(struct super_block *sb, int type)
818{
819 struct dquot *dquot;
820
Jan Kara74f783a2008-08-19 14:51:22 +0200821 dquot = sb->dq_op->alloc_dquot(sb, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 if(!dquot)
Jan Karadd6f3c62009-01-26 16:01:43 +0100823 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700824
Ingo Molnard3be9152006-03-23 03:00:29 -0800825 mutex_init(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700826 INIT_LIST_HEAD(&dquot->dq_free);
827 INIT_LIST_HEAD(&dquot->dq_inuse);
828 INIT_HLIST_NODE(&dquot->dq_hash);
829 INIT_LIST_HEAD(&dquot->dq_dirty);
830 dquot->dq_sb = sb;
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700831 dquot->dq_id = make_kqid_invalid(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832 atomic_set(&dquot->dq_count, 1);
Jan Kara7b9ca4c2017-08-07 13:19:50 +0200833 spin_lock_init(&dquot->dq_dqb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834
835 return dquot;
836}
837
838/*
839 * Get reference to dquot
Jan Karacc334122009-01-12 17:23:05 +0100840 *
841 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
842 * destroying our dquot by:
843 * a) checking for quota flags under dq_list_lock and
844 * b) getting a reference to dquot before we release dq_list_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700845 */
Eric W. Biedermanaca645a2012-09-16 03:11:50 -0700846struct dquot *dqget(struct super_block *sb, struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847{
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700848 unsigned int hashent = hashfn(sb, qid);
Jan Kara6184fc02015-06-24 18:07:02 +0200849 struct dquot *dquot, *empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850
Eric W. Biedermand49d3762016-06-30 16:31:01 -0500851 if (!qid_has_mapping(sb->s_user_ns, qid))
852 return ERR_PTR(-EINVAL);
853
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700854 if (!sb_has_quota_active(sb, qid.type))
Jan Kara6184fc02015-06-24 18:07:02 +0200855 return ERR_PTR(-ESRCH);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856we_slept:
857 spin_lock(&dq_list_lock);
Jan Karacc334122009-01-12 17:23:05 +0100858 spin_lock(&dq_state_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700859 if (!sb_has_quota_active(sb, qid.type)) {
Jan Karacc334122009-01-12 17:23:05 +0100860 spin_unlock(&dq_state_lock);
861 spin_unlock(&dq_list_lock);
Jan Kara6184fc02015-06-24 18:07:02 +0200862 dquot = ERR_PTR(-ESRCH);
Jan Karacc334122009-01-12 17:23:05 +0100863 goto out;
864 }
865 spin_unlock(&dq_state_lock);
866
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700867 dquot = find_dquot(hashent, sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +0100868 if (!dquot) {
869 if (!empty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 spin_unlock(&dq_list_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700871 empty = get_empty_dquot(sb, qid.type);
Jan Karadd6f3c62009-01-26 16:01:43 +0100872 if (!empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700873 schedule(); /* Try to wait for a moment... */
874 goto we_slept;
875 }
876 dquot = empty;
Jan Karadd6f3c62009-01-26 16:01:43 +0100877 empty = NULL;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700878 dquot->dq_id = qid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 /* all dquots go on the inuse_list */
880 put_inuse(dquot);
881 /* hash it first so it can be found */
882 insert_dquot_hash(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400884 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 } else {
886 if (!atomic_read(&dquot->dq_count))
887 remove_free_dquot(dquot);
888 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400890 dqstats_inc(DQST_CACHE_HITS);
891 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892 }
Jan Kara268157b2009-01-27 15:47:22 +0100893 /* Wait for dq_lock - after this we know that either dquot_release() is
894 * already finished or it will be canceled due to dq_count > 1 test */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 wait_on_dquot(dquot);
Jan Kara268157b2009-01-27 15:47:22 +0100896 /* Read the dquot / allocate space in quota file */
Jan Kara6184fc02015-06-24 18:07:02 +0200897 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
898 int err;
899
900 err = sb->dq_op->acquire_dquot(dquot);
901 if (err < 0) {
902 dqput(dquot);
903 dquot = ERR_PTR(err);
904 goto out;
905 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 }
Jan Kara044c9b62016-02-18 13:20:20 +0100907 /*
908 * Make sure following reads see filled structure - paired with
909 * smp_mb__before_atomic() in dquot_acquire().
910 */
911 smp_rmb();
Jan Kara62af9b52010-04-19 16:47:20 +0200912#ifdef CONFIG_QUOTA_DEBUG
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200913 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914#endif
Jan Karacc334122009-01-12 17:23:05 +0100915out:
916 if (empty)
917 do_destroy_dquot(empty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700918
919 return dquot;
920}
Mingming Cao08d03502009-01-14 16:19:32 +0100921EXPORT_SYMBOL(dqget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
Jan Kara2d0fa462014-09-25 16:36:14 +0200923static inline struct dquot **i_dquot(struct inode *inode)
924{
Jan Kara2d0fa462014-09-25 16:36:14 +0200925 return inode->i_sb->s_op->get_dquots(inode);
926}
927
Linus Torvalds1da177e2005-04-16 15:20:36 -0700928static int dqinit_needed(struct inode *inode, int type)
929{
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +0300930 struct dquot * const *dquots;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700931 int cnt;
932
933 if (IS_NOQUOTA(inode))
934 return 0;
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +0300935
936 dquots = i_dquot(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700937 if (type != -1)
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +0300938 return !dquots[type];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700939 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +0300940 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941 return 1;
942 return 0;
943}
944
Jan Karac3b00442016-11-23 14:04:55 +0100945/* This routine is guarded by s_umount semaphore */
Chao Yu1a6152d2017-11-28 23:01:44 +0800946static int add_dquot_ref(struct super_block *sb, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947{
Jan Kara941d2382008-02-06 01:37:36 -0800948 struct inode *inode, *old_inode = NULL;
Jan Kara62af9b52010-04-19 16:47:20 +0200949#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100950 int reserved = 0;
Jan Kara4c5e6c02010-04-06 18:52:47 +0200951#endif
Chao Yu1a6152d2017-11-28 23:01:44 +0800952 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953
Dave Chinner74278da2015-03-04 12:37:22 -0500954 spin_lock(&sb->s_inode_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800955 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Dave Chinner250df6e2011-03-22 22:23:36 +1100956 spin_lock(&inode->i_lock);
957 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
958 !atomic_read(&inode->i_writecount) ||
959 !dqinit_needed(inode, type)) {
960 spin_unlock(&inode->i_lock);
Nick Pigginaabb8fd2009-03-11 13:17:36 -0700961 continue;
Dave Chinner250df6e2011-03-22 22:23:36 +1100962 }
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800963 __iget(inode);
Dave Chinner250df6e2011-03-22 22:23:36 +1100964 spin_unlock(&inode->i_lock);
Dave Chinner74278da2015-03-04 12:37:22 -0500965 spin_unlock(&sb->s_inode_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800966
Jan Karad7e97112012-04-24 17:08:41 +0200967#ifdef CONFIG_QUOTA_DEBUG
968 if (unlikely(inode_get_rsv_space(inode) > 0))
969 reserved = 1;
970#endif
Jan Kara941d2382008-02-06 01:37:36 -0800971 iput(old_inode);
Chao Yu1a6152d2017-11-28 23:01:44 +0800972 err = __dquot_initialize(inode, type);
973 if (err) {
974 iput(inode);
975 goto out;
976 }
Dave Chinner55fa6092011-03-22 22:23:40 +1100977
978 /*
979 * We hold a reference to 'inode' so it couldn't have been
980 * removed from s_inodes list while we dropped the
Dave Chinner74278da2015-03-04 12:37:22 -0500981 * s_inode_list_lock. We cannot iput the inode now as we can be
Dave Chinner55fa6092011-03-22 22:23:40 +1100982 * holding the last reference and we cannot iput it under
Dave Chinner74278da2015-03-04 12:37:22 -0500983 * s_inode_list_lock. So we keep the reference and iput it
Dave Chinner55fa6092011-03-22 22:23:40 +1100984 * later.
985 */
Jan Kara941d2382008-02-06 01:37:36 -0800986 old_inode = inode;
Eric Sandeen04646ae2019-12-06 10:54:23 -0600987 cond_resched();
Dave Chinner74278da2015-03-04 12:37:22 -0500988 spin_lock(&sb->s_inode_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 }
Dave Chinner74278da2015-03-04 12:37:22 -0500990 spin_unlock(&sb->s_inode_list_lock);
Jan Kara941d2382008-02-06 01:37:36 -0800991 iput(old_inode);
Chao Yu1a6152d2017-11-28 23:01:44 +0800992out:
Jan Kara62af9b52010-04-19 16:47:20 +0200993#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100994 if (reserved) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200995 quota_error(sb, "Writes happened before quota was turned on "
996 "thus quota information is probably inconsistent. "
997 "Please run quotacheck(8)");
Jan Kara0a5a9c72010-02-09 18:20:39 +0100998 }
Jan Kara4c5e6c02010-04-06 18:52:47 +0200999#endif
Chao Yu1a6152d2017-11-28 23:01:44 +08001000 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001}
1002
Jan Kara268157b2009-01-27 15:47:22 +01001003/*
Jan Kara268157b2009-01-27 15:47:22 +01001004 * Remove references to dquots from inode and add dquot to list for freeing
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001005 * if we have the last reference to dquot
Jan Kara268157b2009-01-27 15:47:22 +01001006 */
Niu Yawei9eb64632014-06-04 12:21:30 +08001007static void remove_inode_dquot_ref(struct inode *inode, int type,
1008 struct list_head *tofree_head)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009{
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001010 struct dquot **dquots = i_dquot(inode);
1011 struct dquot *dquot = dquots[type];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001012
Niu Yawei9eb64632014-06-04 12:21:30 +08001013 if (!dquot)
1014 return;
1015
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001016 dquots[type] = NULL;
Niu Yawei9eb64632014-06-04 12:21:30 +08001017 if (list_empty(&dquot->dq_free)) {
1018 /*
1019 * The inode still has reference to dquot so it can't be in the
1020 * free list
1021 */
1022 spin_lock(&dq_list_lock);
1023 list_add(&dquot->dq_free, tofree_head);
1024 spin_unlock(&dq_list_lock);
1025 } else {
1026 /*
1027 * Dquot is already in a list to put so we won't drop the last
1028 * reference here.
1029 */
1030 dqput(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001032}
1033
Jan Kara268157b2009-01-27 15:47:22 +01001034/*
1035 * Free list of dquots
1036 * Dquots are removed from inodes and no new references can be got so we are
1037 * the only ones holding reference
1038 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039static void put_dquot_list(struct list_head *tofree_head)
1040{
1041 struct list_head *act_head;
1042 struct dquot *dquot;
1043
1044 act_head = tofree_head->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045 while (act_head != tofree_head) {
1046 dquot = list_entry(act_head, struct dquot, dq_free);
1047 act_head = act_head->next;
Jan Kara268157b2009-01-27 15:47:22 +01001048 /* Remove dquot from the list so we won't have problems... */
1049 list_del_init(&dquot->dq_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 dqput(dquot);
1051 }
1052}
1053
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001054static void remove_dquot_ref(struct super_block *sb, int type,
1055 struct list_head *tofree_head)
1056{
1057 struct inode *inode;
Jiang Biao78bc3332019-04-24 08:58:57 +08001058#ifdef CONFIG_QUOTA_DEBUG
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001059 int reserved = 0;
Jiang Biao78bc3332019-04-24 08:58:57 +08001060#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001061
Dave Chinner74278da2015-03-04 12:37:22 -05001062 spin_lock(&sb->s_inode_list_lock);
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001063 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Nick Pigginaabb8fd2009-03-11 13:17:36 -07001064 /*
1065 * We have to scan also I_NEW inodes because they can already
1066 * have quota pointer initialized. Luckily, we need to touch
1067 * only quota pointers and these have separate locking
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001068 * (dq_data_lock).
Nick Pigginaabb8fd2009-03-11 13:17:36 -07001069 */
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001070 spin_lock(&dq_data_lock);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001071 if (!IS_NOQUOTA(inode)) {
Jiang Biao78bc3332019-04-24 08:58:57 +08001072#ifdef CONFIG_QUOTA_DEBUG
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001073 if (unlikely(inode_get_rsv_space(inode) > 0))
1074 reserved = 1;
Jiang Biao78bc3332019-04-24 08:58:57 +08001075#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001076 remove_inode_dquot_ref(inode, type, tofree_head);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001077 }
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001078 spin_unlock(&dq_data_lock);
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001079 }
Dave Chinner74278da2015-03-04 12:37:22 -05001080 spin_unlock(&sb->s_inode_list_lock);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001081#ifdef CONFIG_QUOTA_DEBUG
1082 if (reserved) {
1083 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1084 " was disabled thus quota information is probably "
1085 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1086 }
1087#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001088}
1089
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090/* Gather all references from inodes and drop them */
1091static void drop_dquot_ref(struct super_block *sb, int type)
1092{
1093 LIST_HEAD(tofree_head);
1094
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001095 if (sb->dq_op) {
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001096 remove_dquot_ref(sb, type, &tofree_head);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001097 synchronize_srcu(&dquot_srcu);
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001098 put_dquot_list(&tofree_head);
1099 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001100}
1101
Mingming Cao740d9dc2009-01-13 16:43:14 +01001102static inline
1103void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1104{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001105 if (dquot->dq_dqb.dqb_rsvspace >= number)
1106 dquot->dq_dqb.dqb_rsvspace -= number;
1107 else {
1108 WARN_ON_ONCE(1);
1109 dquot->dq_dqb.dqb_rsvspace = 0;
1110 }
zhangyi (F)41e327b2017-08-07 21:35:05 +08001111 if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <=
1112 dquot->dq_dqb.dqb_bsoftlimit)
1113 dquot->dq_dqb.dqb_btime = (time64_t) 0;
1114 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001115}
1116
Jan Kara7a2435d2009-01-27 01:47:11 +01001117static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118{
Jan Karadb49d2d2008-10-01 18:21:39 +02001119 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1120 dquot->dq_dqb.dqb_curinodes >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 dquot->dq_dqb.dqb_curinodes -= number;
1122 else
1123 dquot->dq_dqb.dqb_curinodes = 0;
1124 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
Arnd Bergmanne008bb62016-06-17 22:03:16 +02001125 dquot->dq_dqb.dqb_itime = (time64_t) 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 clear_bit(DQ_INODES_B, &dquot->dq_flags);
1127}
1128
Jan Kara7a2435d2009-01-27 01:47:11 +01001129static void dquot_decr_space(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130{
Jan Karadb49d2d2008-10-01 18:21:39 +02001131 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1132 dquot->dq_dqb.dqb_curspace >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001133 dquot->dq_dqb.dqb_curspace -= number;
1134 else
1135 dquot->dq_dqb.dqb_curspace = 0;
zhangyi (F)41e327b2017-08-07 21:35:05 +08001136 if (dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace <=
1137 dquot->dq_dqb.dqb_bsoftlimit)
Arnd Bergmanne008bb62016-06-17 22:03:16 +02001138 dquot->dq_dqb.dqb_btime = (time64_t) 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001139 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1140}
1141
Jan Karabf097aa2012-02-14 13:28:01 +01001142struct dquot_warn {
1143 struct super_block *w_sb;
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001144 struct kqid w_dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001145 short w_type;
1146};
1147
Jan Karac5254602007-12-22 14:03:25 -08001148static int warning_issued(struct dquot *dquot, const int warntype)
1149{
1150 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1151 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1152 ((warntype == QUOTA_NL_IHARDWARN ||
1153 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1154
1155 if (!flag)
1156 return 0;
1157 return test_and_set_bit(flag, &dquot->dq_flags);
1158}
1159
Jan Kara8e893462007-10-16 23:29:31 -07001160#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161static int flag_print_warnings = 1;
1162
Jan Karabf097aa2012-02-14 13:28:01 +01001163static int need_print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164{
1165 if (!flag_print_warnings)
1166 return 0;
1167
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001168 switch (warn->w_dq_id.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 case USRQUOTA:
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001170 return uid_eq(current_fsuid(), warn->w_dq_id.uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 case GRPQUOTA:
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001172 return in_group_p(warn->w_dq_id.gid);
Li Xi847aac62015-03-19 04:04:53 +09001173 case PRJQUOTA:
1174 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
1176 return 0;
1177}
1178
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179/* Print warning to user which exceeded quota */
Jan Karabf097aa2012-02-14 13:28:01 +01001180static void print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181{
1182 char *msg = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001183 struct tty_struct *tty;
Jan Karabf097aa2012-02-14 13:28:01 +01001184 int warntype = warn->w_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
Jan Kara657d3bf2008-07-25 01:46:52 -07001186 if (warntype == QUOTA_NL_IHARDBELOW ||
1187 warntype == QUOTA_NL_ISOFTBELOW ||
1188 warntype == QUOTA_NL_BHARDBELOW ||
Jan Karabf097aa2012-02-14 13:28:01 +01001189 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 return;
1191
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001192 tty = get_current_tty();
1193 if (!tty)
Alan Cox452a00d2008-10-13 10:39:13 +01001194 return;
Jan Karabf097aa2012-02-14 13:28:01 +01001195 tty_write_message(tty, warn->w_sb->s_id);
Jan Kara8e893462007-10-16 23:29:31 -07001196 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001197 tty_write_message(tty, ": warning, ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 else
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001199 tty_write_message(tty, ": write failed, ");
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001200 tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 switch (warntype) {
Jan Kara8e893462007-10-16 23:29:31 -07001202 case QUOTA_NL_IHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 msg = " file limit reached.\r\n";
1204 break;
Jan Kara8e893462007-10-16 23:29:31 -07001205 case QUOTA_NL_ISOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 msg = " file quota exceeded too long.\r\n";
1207 break;
Jan Kara8e893462007-10-16 23:29:31 -07001208 case QUOTA_NL_ISOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 msg = " file quota exceeded.\r\n";
1210 break;
Jan Kara8e893462007-10-16 23:29:31 -07001211 case QUOTA_NL_BHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 msg = " block limit reached.\r\n";
1213 break;
Jan Kara8e893462007-10-16 23:29:31 -07001214 case QUOTA_NL_BSOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 msg = " block quota exceeded too long.\r\n";
1216 break;
Jan Kara8e893462007-10-16 23:29:31 -07001217 case QUOTA_NL_BSOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 msg = " block quota exceeded.\r\n";
1219 break;
1220 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001221 tty_write_message(tty, msg);
Alan Cox452a00d2008-10-13 10:39:13 +01001222 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223}
Jan Kara8e893462007-10-16 23:29:31 -07001224#endif
1225
Jan Karabf097aa2012-02-14 13:28:01 +01001226static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1227 int warntype)
1228{
1229 if (warning_issued(dquot, warntype))
1230 return;
1231 warn->w_type = warntype;
1232 warn->w_sb = dquot->dq_sb;
1233 warn->w_dq_id = dquot->dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001234}
1235
Mingming Caof18df222009-01-13 16:43:09 +01001236/*
1237 * Write warnings to the console and send warning messages over netlink.
1238 *
Jan Karabf097aa2012-02-14 13:28:01 +01001239 * Note that this function can call into tty and networking code.
Mingming Caof18df222009-01-13 16:43:09 +01001240 */
Jan Karabf097aa2012-02-14 13:28:01 +01001241static void flush_warnings(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242{
1243 int i;
1244
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001245 for (i = 0; i < MAXQUOTAS; i++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001246 if (warn[i].w_type == QUOTA_NL_NOWARN)
1247 continue;
Jan Kara8e893462007-10-16 23:29:31 -07001248#ifdef CONFIG_PRINT_QUOTA_WARNING
Jan Karabf097aa2012-02-14 13:28:01 +01001249 print_warning(&warn[i]);
Jan Kara8e893462007-10-16 23:29:31 -07001250#endif
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001251 quota_send_warning(warn[i].w_dq_id,
Jan Karabf097aa2012-02-14 13:28:01 +01001252 warn[i].w_sb->s_dev, warn[i].w_type);
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001253 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254}
1255
Jan Kara7a2435d2009-01-27 01:47:11 +01001256static int ignore_hardlimit(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257{
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001258 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
1260 return capable(CAP_SYS_RESOURCE) &&
Jan Kara268157b2009-01-27 15:47:22 +01001261 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
Jan Kara9c451012014-11-19 09:21:58 +01001262 !(info->dqi_flags & DQF_ROOT_SQUASH));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263}
1264
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001265static int dquot_add_inodes(struct dquot *dquot, qsize_t inodes,
1266 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267{
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001268 qsize_t newinodes;
1269 int ret = 0;
Jan Kara268157b2009-01-27 15:47:22 +01001270
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001271 spin_lock(&dquot->dq_dqb_lock);
1272 newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001273 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001274 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001275 goto add;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276
1277 if (dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001278 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001280 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001281 ret = -EDQUOT;
1282 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 }
1284
1285 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001286 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1287 dquot->dq_dqb.dqb_itime &&
Arnd Bergmanne008bb62016-06-17 22:03:16 +02001288 ktime_get_real_seconds() >= dquot->dq_dqb.dqb_itime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001290 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001291 ret = -EDQUOT;
1292 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 }
1294
1295 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001296 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 dquot->dq_dqb.dqb_itime == 0) {
Jan Karabf097aa2012-02-14 13:28:01 +01001298 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
Arnd Bergmanne008bb62016-06-17 22:03:16 +02001299 dquot->dq_dqb.dqb_itime = ktime_get_real_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001300 sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 }
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001302add:
1303 dquot->dq_dqb.dqb_curinodes = newinodes;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001305out:
1306 spin_unlock(&dquot->dq_dqb_lock);
1307 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308}
1309
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001310static int dquot_add_space(struct dquot *dquot, qsize_t space,
1311 qsize_t rsv_space, unsigned int flags,
1312 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313{
Mingming Caof18df222009-01-13 16:43:09 +01001314 qsize_t tspace;
Jan Kara268157b2009-01-27 15:47:22 +01001315 struct super_block *sb = dquot->dq_sb;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001316 int ret = 0;
Mingming Caof18df222009-01-13 16:43:09 +01001317
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001318 spin_lock(&dquot->dq_dqb_lock);
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001319 if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001320 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Jan Karaac3d79392017-10-10 14:40:42 +02001321 goto finish;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322
Mingming Caof18df222009-01-13 16:43:09 +01001323 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001324 + space + rsv_space;
1325
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 if (dquot->dq_dqb.dqb_bhardlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001327 tspace > dquot->dq_dqb.dqb_bhardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 !ignore_hardlimit(dquot)) {
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001329 if (flags & DQUOT_SPACE_WARN)
Jan Karabf097aa2012-02-14 13:28:01 +01001330 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001331 ret = -EDQUOT;
Jan Karaac3d79392017-10-10 14:40:42 +02001332 goto finish;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 }
1334
1335 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001336 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001337 dquot->dq_dqb.dqb_btime &&
Arnd Bergmanne008bb62016-06-17 22:03:16 +02001338 ktime_get_real_seconds() >= dquot->dq_dqb.dqb_btime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339 !ignore_hardlimit(dquot)) {
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001340 if (flags & DQUOT_SPACE_WARN)
Jan Karabf097aa2012-02-14 13:28:01 +01001341 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001342 ret = -EDQUOT;
Jan Karaac3d79392017-10-10 14:40:42 +02001343 goto finish;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001344 }
1345
1346 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001347 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 dquot->dq_dqb.dqb_btime == 0) {
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001349 if (flags & DQUOT_SPACE_WARN) {
Jan Karabf097aa2012-02-14 13:28:01 +01001350 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
Arnd Bergmanne008bb62016-06-17 22:03:16 +02001351 dquot->dq_dqb.dqb_btime = ktime_get_real_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001352 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001353 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 /*
1355 * We don't allow preallocation to exceed softlimit so exceeding will
1356 * be always printed
1357 */
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001358 ret = -EDQUOT;
Jan Karaac3d79392017-10-10 14:40:42 +02001359 goto finish;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001360 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001361 }
Jan Karaac3d79392017-10-10 14:40:42 +02001362finish:
1363 /*
1364 * We have to be careful and go through warning generation & grace time
1365 * setting even if DQUOT_SPACE_NOFAIL is set. That's why we check it
1366 * only here...
1367 */
1368 if (flags & DQUOT_SPACE_NOFAIL)
1369 ret = 0;
1370 if (!ret) {
1371 dquot->dq_dqb.dqb_rsvspace += rsv_space;
1372 dquot->dq_dqb.dqb_curspace += space;
1373 }
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001374 spin_unlock(&dquot->dq_dqb_lock);
1375 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001376}
1377
Jan Kara12095462008-08-20 14:45:12 +02001378static int info_idq_free(struct dquot *dquot, qsize_t inodes)
Jan Kara657d3bf2008-07-25 01:46:52 -07001379{
Jan Kara268157b2009-01-27 15:47:22 +01001380 qsize_t newinodes;
1381
Jan Kara657d3bf2008-07-25 01:46:52 -07001382 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001383 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001384 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type))
Jan Kara657d3bf2008-07-25 01:46:52 -07001385 return QUOTA_NL_NOWARN;
1386
Jan Kara268157b2009-01-27 15:47:22 +01001387 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1388 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001389 return QUOTA_NL_ISOFTBELOW;
1390 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001391 newinodes < dquot->dq_dqb.dqb_ihardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001392 return QUOTA_NL_IHARDBELOW;
1393 return QUOTA_NL_NOWARN;
1394}
1395
1396static int info_bdq_free(struct dquot *dquot, qsize_t space)
1397{
zhangyi (F)41e327b2017-08-07 21:35:05 +08001398 qsize_t tspace;
1399
1400 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace;
1401
Jan Kara657d3bf2008-07-25 01:46:52 -07001402 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
zhangyi (F)41e327b2017-08-07 21:35:05 +08001403 tspace <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001404 return QUOTA_NL_NOWARN;
1405
zhangyi (F)41e327b2017-08-07 21:35:05 +08001406 if (tspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001407 return QUOTA_NL_BSOFTBELOW;
zhangyi (F)41e327b2017-08-07 21:35:05 +08001408 if (tspace >= dquot->dq_dqb.dqb_bhardlimit &&
1409 tspace - space < dquot->dq_dqb.dqb_bhardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001410 return QUOTA_NL_BHARDBELOW;
1411 return QUOTA_NL_NOWARN;
1412}
Jan Kara0a5a9c72010-02-09 18:20:39 +01001413
Christoph Hellwig189eef52010-06-04 10:56:29 +02001414static int dquot_active(const struct inode *inode)
1415{
1416 struct super_block *sb = inode->i_sb;
1417
1418 if (IS_NOQUOTA(inode))
1419 return 0;
1420 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1421}
1422
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423/*
Christoph Hellwig871a2932010-03-03 09:05:07 -05001424 * Initialize quota pointers in inode
1425 *
Christoph Hellwig871a2932010-03-03 09:05:07 -05001426 * It is better to call this function outside of any transaction as it
1427 * might need a lot of space in journal for dquot structure allocation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001428 */
Jan Kara6184fc02015-06-24 18:07:02 +02001429static int __dquot_initialize(struct inode *inode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430{
Niu Yawei1ea06be2014-06-04 12:20:30 +08001431 int cnt, init_needed = 0;
Nikolay Borisovab73ef42016-03-03 10:54:57 +01001432 struct dquot **dquots, *got[MAXQUOTAS] = {};
Jan Karacc334122009-01-12 17:23:05 +01001433 struct super_block *sb = inode->i_sb;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001434 qsize_t rsv;
Jan Kara6184fc02015-06-24 18:07:02 +02001435 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
Christoph Hellwig189eef52010-06-04 10:56:29 +02001437 if (!dquot_active(inode))
Jan Kara6184fc02015-06-24 18:07:02 +02001438 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001439
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001440 dquots = i_dquot(inode);
1441
Jan Karacc334122009-01-12 17:23:05 +01001442 /* First get references to structures we might need. */
1443 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001444 struct kqid qid;
Li Xi847aac62015-03-19 04:04:53 +09001445 kprojid_t projid;
1446 int rc;
Jan Kara6184fc02015-06-24 18:07:02 +02001447 struct dquot *dquot;
Li Xi847aac62015-03-19 04:04:53 +09001448
Jan Karacc334122009-01-12 17:23:05 +01001449 if (type != -1 && cnt != type)
1450 continue;
Niu Yawei1ea06be2014-06-04 12:20:30 +08001451 /*
1452 * The i_dquot should have been initialized in most cases,
1453 * we check it without locking here to avoid unnecessary
1454 * dqget()/dqput() calls.
1455 */
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001456 if (dquots[cnt])
Niu Yawei1ea06be2014-06-04 12:20:30 +08001457 continue;
Li Xi847aac62015-03-19 04:04:53 +09001458
1459 if (!sb_has_quota_active(sb, cnt))
1460 continue;
1461
Niu Yawei1ea06be2014-06-04 12:20:30 +08001462 init_needed = 1;
1463
Jan Karacc334122009-01-12 17:23:05 +01001464 switch (cnt) {
1465 case USRQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001466 qid = make_kqid_uid(inode->i_uid);
Jan Karacc334122009-01-12 17:23:05 +01001467 break;
1468 case GRPQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001469 qid = make_kqid_gid(inode->i_gid);
Jan Karacc334122009-01-12 17:23:05 +01001470 break;
Li Xi847aac62015-03-19 04:04:53 +09001471 case PRJQUOTA:
1472 rc = inode->i_sb->dq_op->get_projid(inode, &projid);
1473 if (rc)
1474 continue;
1475 qid = make_kqid_projid(projid);
1476 break;
Jan Karacc334122009-01-12 17:23:05 +01001477 }
Jan Kara6184fc02015-06-24 18:07:02 +02001478 dquot = dqget(sb, qid);
1479 if (IS_ERR(dquot)) {
1480 /* We raced with somebody turning quotas off... */
1481 if (PTR_ERR(dquot) != -ESRCH) {
1482 ret = PTR_ERR(dquot);
1483 goto out_put;
1484 }
1485 dquot = NULL;
1486 }
1487 got[cnt] = dquot;
Jan Karacc334122009-01-12 17:23:05 +01001488 }
1489
Niu Yawei1ea06be2014-06-04 12:20:30 +08001490 /* All required i_dquot has been initialized */
1491 if (!init_needed)
Jan Kara6184fc02015-06-24 18:07:02 +02001492 return 0;
Niu Yawei1ea06be2014-06-04 12:20:30 +08001493
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001494 spin_lock(&dq_data_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 if (IS_NOQUOTA(inode))
Jan Kara6184fc02015-06-24 18:07:02 +02001496 goto out_lock;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1498 if (type != -1 && cnt != type)
1499 continue;
Jan Karacc334122009-01-12 17:23:05 +01001500 /* Avoid races with quotaoff() */
1501 if (!sb_has_quota_active(sb, cnt))
1502 continue;
Jan Kara4408ea42010-10-19 00:24:21 +02001503 /* We could race with quotaon or dqget() could have failed */
1504 if (!got[cnt])
1505 continue;
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001506 if (!dquots[cnt]) {
1507 dquots[cnt] = got[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001508 got[cnt] = NULL;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001509 /*
1510 * Make quota reservation system happy if someone
1511 * did a write before quota was turned on
1512 */
1513 rsv = inode_get_rsv_space(inode);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001514 if (unlikely(rsv)) {
1515 spin_lock(&inode->i_lock);
1516 /* Get reservation again under proper lock */
1517 rsv = __inode_get_rsv_space(inode);
1518 spin_lock(&dquots[cnt]->dq_dqb_lock);
1519 dquots[cnt]->dq_dqb.dqb_rsvspace += rsv;
1520 spin_unlock(&dquots[cnt]->dq_dqb_lock);
1521 spin_unlock(&inode->i_lock);
1522 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 }
1524 }
Jan Kara6184fc02015-06-24 18:07:02 +02001525out_lock:
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001526 spin_unlock(&dq_data_lock);
Jan Kara6184fc02015-06-24 18:07:02 +02001527out_put:
Jan Karacc334122009-01-12 17:23:05 +01001528 /* Drop unused references */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001529 dqput_all(got);
Jan Kara6184fc02015-06-24 18:07:02 +02001530
1531 return ret;
Christoph Hellwig871a2932010-03-03 09:05:07 -05001532}
1533
Jan Kara6184fc02015-06-24 18:07:02 +02001534int dquot_initialize(struct inode *inode)
Christoph Hellwig871a2932010-03-03 09:05:07 -05001535{
Jan Kara6184fc02015-06-24 18:07:02 +02001536 return __dquot_initialize(inode, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537}
Mingming Cao08d03502009-01-14 16:19:32 +01001538EXPORT_SYMBOL(dquot_initialize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001539
Tahsin Erdoganb8cb5a52017-05-24 18:24:07 -04001540bool dquot_initialize_needed(struct inode *inode)
1541{
1542 struct dquot **dquots;
1543 int i;
1544
1545 if (!dquot_active(inode))
1546 return false;
1547
1548 dquots = i_dquot(inode);
1549 for (i = 0; i < MAXQUOTAS; i++)
1550 if (!dquots[i] && sb_has_quota_active(inode->i_sb, i))
1551 return true;
1552 return false;
1553}
1554EXPORT_SYMBOL(dquot_initialize_needed);
1555
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556/*
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001557 * Release all quotas referenced by inode.
1558 *
1559 * This function only be called on inode free or converting
1560 * a file to quota file, no other users for the i_dquot in
1561 * both cases, so we needn't call synchronize_srcu() after
1562 * clearing i_dquot.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05001564static void __dquot_drop(struct inode *inode)
Jan Kara3d9ea252008-10-10 16:12:23 +02001565{
Jan Karacc334122009-01-12 17:23:05 +01001566 int cnt;
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001567 struct dquot **dquots = i_dquot(inode);
Jan Karacc334122009-01-12 17:23:05 +01001568 struct dquot *put[MAXQUOTAS];
1569
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001570 spin_lock(&dq_data_lock);
Jan Karacc334122009-01-12 17:23:05 +01001571 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001572 put[cnt] = dquots[cnt];
1573 dquots[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001574 }
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001575 spin_unlock(&dq_data_lock);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001576 dqput_all(put);
Christoph Hellwig9f754752010-03-03 09:05:05 -05001577}
1578
1579void dquot_drop(struct inode *inode)
1580{
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001581 struct dquot * const *dquots;
Christoph Hellwig9f754752010-03-03 09:05:05 -05001582 int cnt;
1583
1584 if (IS_NOQUOTA(inode))
1585 return;
1586
1587 /*
1588 * Test before calling to rule out calls from proc and such
1589 * where we are not allowed to block. Note that this is
1590 * actually reliable test even without the lock - the caller
1591 * must assure that nobody can come after the DQUOT_DROP and
1592 * add quota pointers back anyway.
1593 */
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001594 dquots = i_dquot(inode);
Christoph Hellwig9f754752010-03-03 09:05:05 -05001595 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001596 if (dquots[cnt])
Christoph Hellwig9f754752010-03-03 09:05:05 -05001597 break;
1598 }
1599
1600 if (cnt < MAXQUOTAS)
1601 __dquot_drop(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602}
Mingming Cao08d03502009-01-14 16:19:32 +01001603EXPORT_SYMBOL(dquot_drop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001604
1605/*
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001606 * inode_reserved_space is managed internally by quota, and protected by
1607 * i_lock similar to i_blocks+i_bytes.
1608 */
1609static qsize_t *inode_reserved_space(struct inode * inode)
1610{
1611 /* Filesystem must explicitly define it's own method in order to use
1612 * quota reservation interface */
1613 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1614 return inode->i_sb->dq_op->get_reserved_space(inode);
1615}
1616
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001617static qsize_t __inode_get_rsv_space(struct inode *inode)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001618{
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001619 if (!inode->i_sb->dq_op->get_reserved_space)
1620 return 0;
1621 return *inode_reserved_space(inode);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001622}
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001623
1624static qsize_t inode_get_rsv_space(struct inode *inode)
1625{
1626 qsize_t ret;
Jan Kara05b5d892010-01-06 18:03:36 +01001627
1628 if (!inode->i_sb->dq_op->get_reserved_space)
1629 return 0;
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001630 spin_lock(&inode->i_lock);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001631 ret = __inode_get_rsv_space(inode);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001632 spin_unlock(&inode->i_lock);
1633 return ret;
1634}
1635
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001636/*
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001637 * This functions updates i_blocks+i_bytes fields and quota information
1638 * (together with appropriate checks).
1639 *
1640 * NOTE: We absolutely rely on the fact that caller dirties the inode
1641 * (usually helpers in quotaops.h care about this) and holds a handle for
1642 * the current transaction so that dquot write and inode write go into the
1643 * same transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 */
1645
1646/*
1647 * This operation can block, but only after everything is updated
1648 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001649int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650{
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001651 int cnt, ret = 0, index;
Jan Karabf097aa2012-02-14 13:28:01 +01001652 struct dquot_warn warn[MAXQUOTAS];
Eric Sandeen56246f92010-05-16 09:00:00 -04001653 int reserve = flags & DQUOT_SPACE_RESERVE;
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001654 struct dquot **dquots;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Christoph Hellwig189eef52010-06-04 10:56:29 +02001656 if (!dquot_active(inode)) {
Jan Karaa478e522017-08-07 17:17:10 +02001657 if (reserve) {
1658 spin_lock(&inode->i_lock);
1659 *inode_reserved_space(inode) += number;
1660 spin_unlock(&inode->i_lock);
1661 } else {
1662 inode_add_bytes(inode, number);
1663 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001664 goto out;
1665 }
1666
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001668 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001670 dquots = i_dquot(inode);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001671 index = srcu_read_lock(&dquot_srcu);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001672 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001674 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 continue;
Chengguang Xudf15a2a2019-03-20 13:03:59 +08001676 if (reserve) {
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001677 ret = dquot_add_space(dquots[cnt], 0, number, flags,
1678 &warn[cnt]);
1679 } else {
1680 ret = dquot_add_space(dquots[cnt], number, 0, flags,
1681 &warn[cnt]);
1682 }
1683 if (ret) {
1684 /* Back out changes we already did */
1685 for (cnt--; cnt >= 0; cnt--) {
1686 if (!dquots[cnt])
1687 continue;
1688 spin_lock(&dquots[cnt]->dq_dqb_lock);
Chengguang Xu632a9f32019-04-30 14:40:10 +08001689 if (reserve)
1690 dquot_free_reserved_space(dquots[cnt],
1691 number);
1692 else
1693 dquot_decr_space(dquots[cnt], number);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001694 spin_unlock(&dquots[cnt]->dq_dqb_lock);
1695 }
1696 spin_unlock(&inode->i_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001697 goto out_flush_warn;
Mingming Caof18df222009-01-13 16:43:09 +01001698 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699 }
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001700 if (reserve)
Jan Karaa478e522017-08-07 17:17:10 +02001701 *inode_reserved_space(inode) += number;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001702 else
1703 __inode_add_bytes(inode, number);
1704 spin_unlock(&inode->i_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001705
1706 if (reserve)
1707 goto out_flush_warn;
Jan Karabf097aa2012-02-14 13:28:01 +01001708 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001709out_flush_warn:
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001710 srcu_read_unlock(&dquot_srcu, index);
Jan Karabf097aa2012-02-14 13:28:01 +01001711 flush_warnings(warn);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001712out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713 return ret;
1714}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001715EXPORT_SYMBOL(__dquot_alloc_space);
Mingming Caof18df222009-01-13 16:43:09 +01001716
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717/*
1718 * This operation can block, but only after everything is updated
1719 */
Jan Kara6bab3592014-10-20 16:01:33 +02001720int dquot_alloc_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721{
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001722 int cnt, ret = 0, index;
Jan Karabf097aa2012-02-14 13:28:01 +01001723 struct dquot_warn warn[MAXQUOTAS];
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001724 struct dquot * const *dquots;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
Christoph Hellwig189eef52010-06-04 10:56:29 +02001726 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001727 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001729 warn[cnt].w_type = QUOTA_NL_NOWARN;
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001730
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001731 dquots = i_dquot(inode);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001732 index = srcu_read_lock(&dquot_srcu);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001733 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001735 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001736 continue;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001737 ret = dquot_add_inodes(dquots[cnt], 1, &warn[cnt]);
1738 if (ret) {
1739 for (cnt--; cnt >= 0; cnt--) {
1740 if (!dquots[cnt])
1741 continue;
1742 /* Back out changes we already did */
1743 spin_lock(&dquots[cnt]->dq_dqb_lock);
Chengguang Xu632a9f32019-04-30 14:40:10 +08001744 dquot_decr_inodes(dquots[cnt], 1);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001745 spin_unlock(&dquots[cnt]->dq_dqb_lock);
1746 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 goto warn_put_all;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001748 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001749 }
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001750
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751warn_put_all:
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001752 spin_unlock(&inode->i_lock);
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001753 if (ret == 0)
Jan Karabf097aa2012-02-14 13:28:01 +01001754 mark_all_dquot_dirty(dquots);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001755 srcu_read_unlock(&dquot_srcu, index);
Jan Karabf097aa2012-02-14 13:28:01 +01001756 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 return ret;
1758}
Mingming Cao08d03502009-01-14 16:19:32 +01001759EXPORT_SYMBOL(dquot_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001761/*
1762 * Convert in-memory reserved quotas to real consumed quotas
1763 */
1764int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001765{
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001766 struct dquot **dquots;
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001767 int cnt, index;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001768
Christoph Hellwig189eef52010-06-04 10:56:29 +02001769 if (!dquot_active(inode)) {
Jan Kara0ed60de2017-08-07 17:07:28 +02001770 spin_lock(&inode->i_lock);
1771 *inode_reserved_space(inode) -= number;
1772 __inode_add_bytes(inode, number);
1773 spin_unlock(&inode->i_lock);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001774 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001775 }
1776
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001777 dquots = i_dquot(inode);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001778 index = srcu_read_lock(&dquot_srcu);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001779 spin_lock(&inode->i_lock);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001780 /* Claim reserved quotas to allocated quotas */
1781 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Kara3ab167d2017-08-07 17:37:03 +02001782 if (dquots[cnt]) {
1783 struct dquot *dquot = dquots[cnt];
1784
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001785 spin_lock(&dquot->dq_dqb_lock);
Jan Kara3ab167d2017-08-07 17:37:03 +02001786 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_rsvspace < number))
1787 number = dquot->dq_dqb.dqb_rsvspace;
1788 dquot->dq_dqb.dqb_curspace += number;
1789 dquot->dq_dqb.dqb_rsvspace -= number;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001790 spin_unlock(&dquot->dq_dqb_lock);
Jan Kara3ab167d2017-08-07 17:37:03 +02001791 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001792 }
1793 /* Update inode bytes */
Jan Kara0ed60de2017-08-07 17:07:28 +02001794 *inode_reserved_space(inode) -= number;
1795 __inode_add_bytes(inode, number);
1796 spin_unlock(&inode->i_lock);
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001797 mark_all_dquot_dirty(dquots);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001798 srcu_read_unlock(&dquot_srcu, index);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001799 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001800}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001801EXPORT_SYMBOL(dquot_claim_space_nodirty);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001802
1803/*
Jan Kara1c8924e2013-08-17 09:32:32 -04001804 * Convert allocated space back to in-memory reserved quotas
1805 */
1806void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
1807{
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001808 struct dquot **dquots;
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001809 int cnt, index;
Jan Kara1c8924e2013-08-17 09:32:32 -04001810
1811 if (!dquot_active(inode)) {
Jan Kara0ed60de2017-08-07 17:07:28 +02001812 spin_lock(&inode->i_lock);
1813 *inode_reserved_space(inode) += number;
1814 __inode_sub_bytes(inode, number);
1815 spin_unlock(&inode->i_lock);
Jan Kara1c8924e2013-08-17 09:32:32 -04001816 return;
1817 }
1818
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001819 dquots = i_dquot(inode);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001820 index = srcu_read_lock(&dquot_srcu);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001821 spin_lock(&inode->i_lock);
Jan Kara1c8924e2013-08-17 09:32:32 -04001822 /* Claim reserved quotas to allocated quotas */
1823 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Kara3ab167d2017-08-07 17:37:03 +02001824 if (dquots[cnt]) {
1825 struct dquot *dquot = dquots[cnt];
1826
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001827 spin_lock(&dquot->dq_dqb_lock);
Jan Kara3ab167d2017-08-07 17:37:03 +02001828 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
1829 number = dquot->dq_dqb.dqb_curspace;
1830 dquot->dq_dqb.dqb_rsvspace += number;
1831 dquot->dq_dqb.dqb_curspace -= number;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001832 spin_unlock(&dquot->dq_dqb_lock);
Jan Kara3ab167d2017-08-07 17:37:03 +02001833 }
Jan Kara1c8924e2013-08-17 09:32:32 -04001834 }
1835 /* Update inode bytes */
Jan Kara0ed60de2017-08-07 17:07:28 +02001836 *inode_reserved_space(inode) += number;
1837 __inode_sub_bytes(inode, number);
1838 spin_unlock(&inode->i_lock);
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001839 mark_all_dquot_dirty(dquots);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001840 srcu_read_unlock(&dquot_srcu, index);
Jan Kara1c8924e2013-08-17 09:32:32 -04001841 return;
1842}
1843EXPORT_SYMBOL(dquot_reclaim_space_nodirty);
1844
1845/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 * This operation can block, but only after everything is updated
1847 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001848void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849{
1850 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001851 struct dquot_warn warn[MAXQUOTAS];
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001852 struct dquot **dquots;
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001853 int reserve = flags & DQUOT_SPACE_RESERVE, index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854
Christoph Hellwig189eef52010-06-04 10:56:29 +02001855 if (!dquot_active(inode)) {
Jan Karaa478e522017-08-07 17:17:10 +02001856 if (reserve) {
1857 spin_lock(&inode->i_lock);
1858 *inode_reserved_space(inode) -= number;
1859 spin_unlock(&inode->i_lock);
1860 } else {
1861 inode_sub_bytes(inode, number);
1862 }
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001863 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 }
Jan Kara657d3bf2008-07-25 01:46:52 -07001865
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001866 dquots = i_dquot(inode);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001867 index = srcu_read_lock(&dquot_srcu);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001868 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001870 int wtype;
1871
1872 warn[cnt].w_type = QUOTA_NL_NOWARN;
1873 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 continue;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001875 spin_lock(&dquots[cnt]->dq_dqb_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01001876 wtype = info_bdq_free(dquots[cnt], number);
1877 if (wtype != QUOTA_NL_NOWARN)
1878 prepare_warning(&warn[cnt], dquots[cnt], wtype);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001879 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001880 dquot_free_reserved_space(dquots[cnt], number);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001881 else
Jan Karabf097aa2012-02-14 13:28:01 +01001882 dquot_decr_space(dquots[cnt], number);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001883 spin_unlock(&dquots[cnt]->dq_dqb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 }
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001885 if (reserve)
Jan Karaa478e522017-08-07 17:17:10 +02001886 *inode_reserved_space(inode) -= number;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001887 else
1888 __inode_sub_bytes(inode, number);
1889 spin_unlock(&inode->i_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001890
1891 if (reserve)
1892 goto out_unlock;
Jan Karabf097aa2012-02-14 13:28:01 +01001893 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001894out_unlock:
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001895 srcu_read_unlock(&dquot_srcu, index);
Jan Karabf097aa2012-02-14 13:28:01 +01001896 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001898EXPORT_SYMBOL(__dquot_free_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001899
1900/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 * This operation can block, but only after everything is updated
1902 */
Jan Kara6bab3592014-10-20 16:01:33 +02001903void dquot_free_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904{
1905 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001906 struct dquot_warn warn[MAXQUOTAS];
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001907 struct dquot * const *dquots;
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001908 int index;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909
Christoph Hellwig189eef52010-06-04 10:56:29 +02001910 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001911 return;
Jan Kara657d3bf2008-07-25 01:46:52 -07001912
Konstantin Khlebnikov5bcd3b62015-02-12 12:36:37 +03001913 dquots = i_dquot(inode);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001914 index = srcu_read_lock(&dquot_srcu);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001915 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001917 int wtype;
1918
1919 warn[cnt].w_type = QUOTA_NL_NOWARN;
1920 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 continue;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001922 spin_lock(&dquots[cnt]->dq_dqb_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01001923 wtype = info_idq_free(dquots[cnt], 1);
1924 if (wtype != QUOTA_NL_NOWARN)
1925 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1926 dquot_decr_inodes(dquots[cnt], 1);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001927 spin_unlock(&dquots[cnt]->dq_dqb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 }
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001929 spin_unlock(&inode->i_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01001930 mark_all_dquot_dirty(dquots);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001931 srcu_read_unlock(&dquot_srcu, index);
Jan Karabf097aa2012-02-14 13:28:01 +01001932 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933}
Mingming Cao08d03502009-01-14 16:19:32 +01001934EXPORT_SYMBOL(dquot_free_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001935
1936/*
1937 * Transfer the number of inode and blocks from one diskquota to an other.
Jan Karabc8e5f02010-05-13 19:58:50 +02001938 * On success, dquot references in transfer_to are consumed and references
1939 * to original dquots that need to be released are placed there. On failure,
1940 * references are kept untouched.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001941 *
1942 * This operation can block, but only after everything is updated
1943 * A transaction must be started when entering this function.
Jan Karabc8e5f02010-05-13 19:58:50 +02001944 *
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001945 * We are holding reference on transfer_from & transfer_to, no need to
1946 * protect them by srcu_read_lock().
Linus Torvalds1da177e2005-04-16 15:20:36 -07001947 */
Jan Karabc8e5f02010-05-13 19:58:50 +02001948int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001949{
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001950 qsize_t cur_space;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001951 qsize_t rsv_space = 0;
Tahsin Erdogan7a9ca532017-06-22 11:46:48 -04001952 qsize_t inode_usage = 1;
Jan Karabc8e5f02010-05-13 19:58:50 +02001953 struct dquot *transfer_from[MAXQUOTAS] = {};
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001954 int cnt, ret = 0;
Dmitry9e327842010-10-09 23:15:30 +04001955 char is_valid[MAXQUOTAS] = {};
Jan Karabf097aa2012-02-14 13:28:01 +01001956 struct dquot_warn warn_to[MAXQUOTAS];
1957 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1958 struct dquot_warn warn_from_space[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 if (IS_NOQUOTA(inode))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001961 return 0;
Tahsin Erdogan7a9ca532017-06-22 11:46:48 -04001962
1963 if (inode->i_sb->dq_op->get_inode_usage) {
1964 ret = inode->i_sb->dq_op->get_inode_usage(inode, &inode_usage);
1965 if (ret)
1966 return ret;
1967 }
1968
Jan Karacc334122009-01-12 17:23:05 +01001969 /* Initialize the arrays */
Jan Karabf097aa2012-02-14 13:28:01 +01001970 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1971 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1972 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1973 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1974 }
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001975
1976 spin_lock(&dq_data_lock);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001977 spin_lock(&inode->i_lock);
Jan Karacc334122009-01-12 17:23:05 +01001978 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001979 spin_unlock(&inode->i_lock);
Niu Yaweib9ba6f92014-06-04 12:23:19 +08001980 spin_unlock(&dq_data_lock);
Jan Karabc8e5f02010-05-13 19:58:50 +02001981 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001982 }
Jan Kara7b9ca4c2017-08-07 13:19:50 +02001983 cur_space = __inode_get_bytes(inode);
1984 rsv_space = __inode_get_rsv_space(inode);
1985 /*
1986 * Build the transfer_from list, check limits, and update usage in
1987 * the target structures.
1988 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001990 /*
1991 * Skip changes for same uid or gid or for turned off quota-type.
1992 */
Jan Karadd6f3c62009-01-26 16:01:43 +01001993 if (!transfer_to[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001994 continue;
Dmitry9e327842010-10-09 23:15:30 +04001995 /* Avoid races with quotaoff() */
1996 if (!sb_has_quota_active(inode->i_sb, cnt))
1997 continue;
1998 is_valid[cnt] = 1;
Jan Kara2d0fa462014-09-25 16:36:14 +02001999 transfer_from[cnt] = i_dquot(inode)[cnt];
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002000 ret = dquot_add_inodes(transfer_to[cnt], inode_usage,
2001 &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05002002 if (ret)
2003 goto over_quota;
yangerkunc6d9c352019-03-26 22:00:02 +08002004 ret = dquot_add_space(transfer_to[cnt], cur_space, rsv_space,
2005 DQUOT_SPACE_WARN, &warn_to[cnt]);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002006 if (ret) {
Konstantin Khlebnikov0a51fb72017-09-09 12:19:22 +03002007 spin_lock(&transfer_to[cnt]->dq_dqb_lock);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002008 dquot_decr_inodes(transfer_to[cnt], inode_usage);
Konstantin Khlebnikov0a51fb72017-09-09 12:19:22 +03002009 spin_unlock(&transfer_to[cnt]->dq_dqb_lock);
Jan Karacc334122009-01-12 17:23:05 +01002010 goto over_quota;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002011 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 }
2013
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002014 /* Decrease usage for source structures and update quota pointers */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04002016 if (!is_valid[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002018 /* Due to IO error we might not have transfer_from[] structure */
2019 if (transfer_from[cnt]) {
Jan Karabf097aa2012-02-14 13:28:01 +01002020 int wtype;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002021
2022 spin_lock(&transfer_from[cnt]->dq_dqb_lock);
Tahsin Erdogan7a9ca532017-06-22 11:46:48 -04002023 wtype = info_idq_free(transfer_from[cnt], inode_usage);
Jan Karabf097aa2012-02-14 13:28:01 +01002024 if (wtype != QUOTA_NL_NOWARN)
2025 prepare_warning(&warn_from_inodes[cnt],
2026 transfer_from[cnt], wtype);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002027 wtype = info_bdq_free(transfer_from[cnt],
2028 cur_space + rsv_space);
Jan Karabf097aa2012-02-14 13:28:01 +01002029 if (wtype != QUOTA_NL_NOWARN)
2030 prepare_warning(&warn_from_space[cnt],
2031 transfer_from[cnt], wtype);
Tahsin Erdogan7a9ca532017-06-22 11:46:48 -04002032 dquot_decr_inodes(transfer_from[cnt], inode_usage);
Mingming Cao740d9dc2009-01-13 16:43:14 +01002033 dquot_decr_space(transfer_from[cnt], cur_space);
2034 dquot_free_reserved_space(transfer_from[cnt],
2035 rsv_space);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002036 spin_unlock(&transfer_from[cnt]->dq_dqb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 }
Jan Kara2d0fa462014-09-25 16:36:14 +02002038 i_dquot(inode)[cnt] = transfer_to[cnt];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002039 }
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002040 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 spin_unlock(&dq_data_lock);
Jan Karacc334122009-01-12 17:23:05 +01002042
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03002043 mark_all_dquot_dirty(transfer_from);
2044 mark_all_dquot_dirty(transfer_to);
Jan Karabf097aa2012-02-14 13:28:01 +01002045 flush_warnings(warn_to);
2046 flush_warnings(warn_from_inodes);
2047 flush_warnings(warn_from_space);
Jan Karabc8e5f02010-05-13 19:58:50 +02002048 /* Pass back references to put */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03002049 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Dmitry9e327842010-10-09 23:15:30 +04002050 if (is_valid[cnt])
2051 transfer_to[cnt] = transfer_from[cnt];
Jan Kara86f3cbe2010-10-11 15:22:21 +02002052 return 0;
Jan Karacc334122009-01-12 17:23:05 +01002053over_quota:
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002054 /* Back out changes we already did */
2055 for (cnt--; cnt >= 0; cnt--) {
2056 if (!is_valid[cnt])
2057 continue;
2058 spin_lock(&transfer_to[cnt]->dq_dqb_lock);
2059 dquot_decr_inodes(transfer_to[cnt], inode_usage);
2060 dquot_decr_space(transfer_to[cnt], cur_space);
2061 dquot_free_reserved_space(transfer_to[cnt], rsv_space);
2062 spin_unlock(&transfer_to[cnt]->dq_dqb_lock);
2063 }
2064 spin_unlock(&inode->i_lock);
Jan Karacc334122009-01-12 17:23:05 +01002065 spin_unlock(&dq_data_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01002066 flush_warnings(warn_to);
Jan Kara86f3cbe2010-10-11 15:22:21 +02002067 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002068}
Jan Karabc8e5f02010-05-13 19:58:50 +02002069EXPORT_SYMBOL(__dquot_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002070
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03002071/* Wrapper for transferring ownership of an inode for uid/gid only
2072 * Called from FSXXX_setattr()
2073 */
Christoph Hellwigb43fa822010-03-03 09:05:03 -05002074int dquot_transfer(struct inode *inode, struct iattr *iattr)
Jan Karab85f4b82008-07-25 01:46:50 -07002075{
Jan Karabc8e5f02010-05-13 19:58:50 +02002076 struct dquot *transfer_to[MAXQUOTAS] = {};
Jan Kara6184fc02015-06-24 18:07:02 +02002077 struct dquot *dquot;
Jan Karabc8e5f02010-05-13 19:58:50 +02002078 struct super_block *sb = inode->i_sb;
2079 int ret;
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03002080
Christoph Hellwig189eef52010-06-04 10:56:29 +02002081 if (!dquot_active(inode))
Jan Karabc8e5f02010-05-13 19:58:50 +02002082 return 0;
Dmitry Monakhov12755622010-04-08 22:04:20 +04002083
Jan Kara6184fc02015-06-24 18:07:02 +02002084 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)){
2085 dquot = dqget(sb, make_kqid_uid(iattr->ia_uid));
2086 if (IS_ERR(dquot)) {
2087 if (PTR_ERR(dquot) != -ESRCH) {
2088 ret = PTR_ERR(dquot);
2089 goto out_put;
2090 }
2091 dquot = NULL;
2092 }
2093 transfer_to[USRQUOTA] = dquot;
2094 }
2095 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid)){
2096 dquot = dqget(sb, make_kqid_gid(iattr->ia_gid));
2097 if (IS_ERR(dquot)) {
2098 if (PTR_ERR(dquot) != -ESRCH) {
2099 ret = PTR_ERR(dquot);
2100 goto out_put;
2101 }
2102 dquot = NULL;
2103 }
2104 transfer_to[GRPQUOTA] = dquot;
2105 }
Jan Karabc8e5f02010-05-13 19:58:50 +02002106 ret = __dquot_transfer(inode, transfer_to);
Jan Kara6184fc02015-06-24 18:07:02 +02002107out_put:
Jan Karabc8e5f02010-05-13 19:58:50 +02002108 dqput_all(transfer_to);
2109 return ret;
Jan Karab85f4b82008-07-25 01:46:50 -07002110}
Christoph Hellwigb43fa822010-03-03 09:05:03 -05002111EXPORT_SYMBOL(dquot_transfer);
Jan Karab85f4b82008-07-25 01:46:50 -07002112
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113/*
2114 * Write info of quota file to disk
2115 */
2116int dquot_commit_info(struct super_block *sb, int type)
2117{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118 struct quota_info *dqopt = sb_dqopt(sb);
2119
Jan Kara9a8ae302017-06-09 08:45:43 +02002120 return dqopt->ops[type]->write_file_info(sb, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121}
Mingming Cao08d03502009-01-14 16:19:32 +01002122EXPORT_SYMBOL(dquot_commit_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002123
Jan Karabe6257b2016-01-25 19:24:50 +01002124int dquot_get_next_id(struct super_block *sb, struct kqid *qid)
2125{
2126 struct quota_info *dqopt = sb_dqopt(sb);
Jan Karabe6257b2016-01-25 19:24:50 +01002127
Jan Kara9d1ccbe2016-11-23 13:35:14 +01002128 if (!sb_has_quota_active(sb, qid->type))
2129 return -ESRCH;
2130 if (!dqopt->ops[qid->type]->get_next_id)
2131 return -ENOSYS;
Jan Karaf14618c2017-06-09 08:36:16 +02002132 return dqopt->ops[qid->type]->get_next_id(sb, qid);
Jan Karabe6257b2016-01-25 19:24:50 +01002133}
2134EXPORT_SYMBOL(dquot_get_next_id);
2135
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136/*
2137 * Definitions of diskquota operations.
2138 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -07002139const struct dquot_operations dquot_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140 .write_dquot = dquot_commit,
2141 .acquire_dquot = dquot_acquire,
2142 .release_dquot = dquot_release,
2143 .mark_dirty = dquot_mark_dquot_dirty,
Jan Kara74f783a2008-08-19 14:51:22 +02002144 .write_info = dquot_commit_info,
2145 .alloc_dquot = dquot_alloc,
2146 .destroy_dquot = dquot_destroy,
Jan Karabe6257b2016-01-25 19:24:50 +01002147 .get_next_id = dquot_get_next_id,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148};
Christoph Hellwig123e9ca2010-05-19 07:16:44 -04002149EXPORT_SYMBOL(dquot_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151/*
Christoph Hellwig907f4552010-03-03 09:05:06 -05002152 * Generic helper for ->open on filesystems supporting disk quotas.
2153 */
2154int dquot_file_open(struct inode *inode, struct file *file)
2155{
2156 int error;
2157
2158 error = generic_file_open(inode, file);
2159 if (!error && (file->f_mode & FMODE_WRITE))
Chao Yu88d8ff92017-11-13 11:31:48 +08002160 error = dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -05002161 return error;
2162}
2163EXPORT_SYMBOL(dquot_file_open);
2164
Jan Kara2ec1f302019-11-04 11:12:44 +01002165static void vfs_cleanup_quota_inode(struct super_block *sb, int type)
2166{
2167 struct quota_info *dqopt = sb_dqopt(sb);
2168 struct inode *inode = dqopt->files[type];
2169
2170 if (!inode)
2171 return;
2172 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2173 inode_lock(inode);
2174 inode->i_flags &= ~S_NOQUOTA;
2175 inode_unlock(inode);
2176 }
2177 dqopt->files[type] = NULL;
2178 iput(inode);
2179}
2180
Christoph Hellwig907f4552010-03-03 09:05:06 -05002181/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002182 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
2183 */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002184int dquot_disable(struct super_block *sb, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185{
Jan Kara2ec1f302019-11-04 11:12:44 +01002186 int cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 struct quota_info *dqopt = sb_dqopt(sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
Jan Kara7d6cd732016-11-23 13:16:10 +01002189 /* s_umount should be held in exclusive mode */
2190 if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
2191 up_read(&sb->s_umount);
2192
Jan Karaf55abc02008-08-20 17:50:32 +02002193 /* Cannot turn off usage accounting without turning off limits, or
2194 * suspend quotas and simultaneously turn quotas off. */
2195 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
2196 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
2197 DQUOT_USAGE_ENABLED)))
2198 return -EINVAL;
2199
Jan Kara9377abd2008-05-12 14:02:08 -07002200 /*
2201 * Skip everything if there's nothing to do. We have to do this because
2202 * sometimes we are called when fill_super() failed and calling
2203 * sync_fs() in such cases does no good.
2204 */
Jan Karac3b00442016-11-23 14:04:55 +01002205 if (!sb_any_quota_loaded(sb))
Jan Kara9377abd2008-05-12 14:02:08 -07002206 return 0;
Jan Karac3b00442016-11-23 14:04:55 +01002207
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209 if (type != -1 && cnt != type)
2210 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002211 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002212 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002213
2214 if (flags & DQUOT_SUSPENDED) {
Jan Karacc334122009-01-12 17:23:05 +01002215 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002216 dqopt->flags |=
2217 dquot_state_flag(DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002218 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002219 } else {
Jan Karacc334122009-01-12 17:23:05 +01002220 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002221 dqopt->flags &= ~dquot_state_flag(flags, cnt);
2222 /* Turning off suspended quotas? */
2223 if (!sb_has_quota_loaded(sb, cnt) &&
2224 sb_has_quota_suspended(sb, cnt)) {
2225 dqopt->flags &= ~dquot_state_flag(
2226 DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002227 spin_unlock(&dq_state_lock);
Jan Kara2ec1f302019-11-04 11:12:44 +01002228 vfs_cleanup_quota_inode(sb, cnt);
Jan Karaf55abc02008-08-20 17:50:32 +02002229 continue;
2230 }
Jan Karacc334122009-01-12 17:23:05 +01002231 spin_unlock(&dq_state_lock);
Jan Kara0ff5af82008-04-28 02:14:33 -07002232 }
Jan Karaf55abc02008-08-20 17:50:32 +02002233
2234 /* We still have to keep quota loaded? */
2235 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237
2238 /* Note: these are blocking operations */
2239 drop_dquot_ref(sb, cnt);
2240 invalidate_dquots(sb, cnt);
2241 /*
Jan Kara268157b2009-01-27 15:47:22 +01002242 * Now all dquots should be invalidated, all writes done so we
2243 * should be only users of the info. No locks needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 */
2245 if (info_dirty(&dqopt->info[cnt]))
2246 sb->dq_op->write_info(sb, cnt);
2247 if (dqopt->ops[cnt]->free_file_info)
2248 dqopt->ops[cnt]->free_file_info(sb, cnt);
2249 put_quota_format(dqopt->info[cnt].dqi_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250 dqopt->info[cnt].dqi_flags = 0;
2251 dqopt->info[cnt].dqi_igrace = 0;
2252 dqopt->info[cnt].dqi_bgrace = 0;
2253 dqopt->ops[cnt] = NULL;
2254 }
Jan Karaca785ec2008-09-30 17:53:37 +02002255
2256 /* Skip syncing and setting flags if quota files are hidden */
2257 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2258 goto put_inodes;
2259
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 /* Sync the superblock so that buffers with quota data are written to
Al Viro7b7b1ac2005-11-07 17:13:39 -05002261 * disk (and so userspace sees correct data afterwards). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 if (sb->s_op->sync_fs)
2263 sb->s_op->sync_fs(sb, 1);
2264 sync_blockdev(sb->s_bdev);
2265 /* Now the quota files are just ordinary files and we can set the
2266 * inode flags back. Moreover we discard the pagecache so that
2267 * userspace sees the writes we did bypassing the pagecache. We
2268 * must also discard the blockdev buffers so that we see the
2269 * changes done by userspace on the next quotaon() */
2270 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Kara2ec1f302019-11-04 11:12:44 +01002271 if (!sb_has_quota_loaded(sb, cnt) && dqopt->files[cnt]) {
2272 inode_lock(dqopt->files[cnt]);
2273 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
2274 inode_unlock(dqopt->files[cnt]);
Jan Karaca785ec2008-09-30 17:53:37 +02002275 }
2276 if (sb->s_bdev)
2277 invalidate_bdev(sb->s_bdev);
2278put_inodes:
Jan Kara2ec1f302019-11-04 11:12:44 +01002279 /* We are done when suspending quotas */
2280 if (flags & DQUOT_SUSPENDED)
2281 return 0;
2282
Jan Karaca785ec2008-09-30 17:53:37 +02002283 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Kara2ec1f302019-11-04 11:12:44 +01002284 if (!sb_has_quota_loaded(sb, cnt))
2285 vfs_cleanup_quota_inode(sb, cnt);
2286 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002288EXPORT_SYMBOL(dquot_disable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289
Christoph Hellwig287a8092010-05-19 07:16:45 -04002290int dquot_quota_off(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +02002291{
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002292 return dquot_disable(sb, type,
2293 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Jan Karaf55abc02008-08-20 17:50:32 +02002294}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002295EXPORT_SYMBOL(dquot_quota_off);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002296
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297/*
2298 * Turn quotas on on a device
2299 */
2300
Jan Karac7d3d282019-11-01 17:45:31 +01002301static int vfs_setup_quota_inode(struct inode *inode, int type)
2302{
2303 struct super_block *sb = inode->i_sb;
2304 struct quota_info *dqopt = sb_dqopt(sb);
2305
2306 if (!S_ISREG(inode->i_mode))
2307 return -EACCES;
2308 if (IS_RDONLY(inode))
2309 return -EROFS;
2310 if (sb_has_quota_loaded(sb, type))
2311 return -EBUSY;
2312
2313 dqopt->files[type] = igrab(inode);
2314 if (!dqopt->files[type])
2315 return -EIO;
2316 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2317 /* We don't want quota and atime on quota files (deadlocks
2318 * possible) Also nobody should write to the file - we use
2319 * special IO operations which ignore the immutable bit. */
2320 inode_lock(inode);
2321 inode->i_flags |= S_NOQUOTA;
2322 inode_unlock(inode);
2323 /*
2324 * When S_NOQUOTA is set, remove dquot references as no more
2325 * references can be added
2326 */
2327 __dquot_drop(inode);
2328 }
2329 return 0;
2330}
2331
Jan Karac7d3d282019-11-01 17:45:31 +01002332int dquot_load_quota_sb(struct super_block *sb, int type, int format_id,
Jan Karaf55abc02008-08-20 17:50:32 +02002333 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334{
2335 struct quota_format_type *fmt = find_quota_format(format_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336 struct quota_info *dqopt = sb_dqopt(sb);
2337 int error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338
Jan Karadc19432a2019-11-01 18:37:44 +01002339 /* Just unsuspend quotas? */
2340 BUG_ON(flags & DQUOT_SUSPENDED);
2341 /* s_umount should be held in exclusive mode */
2342 if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
2343 up_read(&sb->s_umount);
2344
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 if (!fmt)
2346 return -ESRCH;
Li Xi847aac62015-03-19 04:04:53 +09002347 if (!sb->s_op->quota_write || !sb->s_op->quota_read ||
2348 (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002349 error = -EINVAL;
2350 goto out_fmt;
2351 }
Eric W. Biederman5c004822016-07-05 10:41:57 -05002352 /* Filesystems outside of init_user_ns not yet supported */
2353 if (sb->s_user_ns != &init_user_ns) {
2354 error = -EINVAL;
2355 goto out_fmt;
2356 }
Jan Karaf55abc02008-08-20 17:50:32 +02002357 /* Usage always has to be set... */
2358 if (!(flags & DQUOT_USAGE_ENABLED)) {
2359 error = -EINVAL;
2360 goto out_fmt;
2361 }
Jan Karac3b00442016-11-23 14:04:55 +01002362 if (sb_has_quota_loaded(sb, type)) {
2363 error = -EBUSY;
2364 goto out_fmt;
2365 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366
Jan Karaca785ec2008-09-30 17:53:37 +02002367 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
Jan Karaab94c392010-02-22 21:07:17 +01002368 /* As we bypass the pagecache we must now flush all the
2369 * dirty data and invalidate caches so that kernel sees
2370 * changes from userspace. It is not enough to just flush
2371 * the quota file since if blocksize < pagesize, invalidation
2372 * of the cache could fail because of other unrelated dirty
2373 * data */
2374 sync_filesystem(sb);
Jan Karaca785ec2008-09-30 17:53:37 +02002375 invalidate_bdev(sb->s_bdev);
2376 }
Jan Karaca785ec2008-09-30 17:53:37 +02002377
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 error = -EINVAL;
2379 if (!fmt->qf_ops->check_quota_file(sb, type))
Jan Karac7d3d282019-11-01 17:45:31 +01002380 goto out_fmt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381
2382 dqopt->ops[type] = fmt->qf_ops;
2383 dqopt->info[type].dqi_format = fmt;
Jan Kara0ff5af82008-04-28 02:14:33 -07002384 dqopt->info[type].dqi_fmt_id = format_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002385 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
Jan Kara268157b2009-01-27 15:47:22 +01002386 error = dqopt->ops[type]->read_file_info(sb, type);
Jan Kara42fdb852017-06-09 08:59:46 +02002387 if (error < 0)
Jan Karac7d3d282019-11-01 17:45:31 +01002388 goto out_fmt;
Jan Kara15512372017-06-09 11:56:06 +02002389 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) {
2390 spin_lock(&dq_data_lock);
Jan Kara46fe44c2011-11-16 15:03:59 +01002391 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
Jan Kara15512372017-06-09 11:56:06 +02002392 spin_unlock(&dq_data_lock);
2393 }
Jan Karacc334122009-01-12 17:23:05 +01002394 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002395 dqopt->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002396 spin_unlock(&dq_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002397
Chao Yu1a6152d2017-11-28 23:01:44 +08002398 error = add_dquot_ref(sb, type);
2399 if (error)
2400 dquot_disable(sb, type, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401
Chao Yu1a6152d2017-11-28 23:01:44 +08002402 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002403out_fmt:
2404 put_quota_format(fmt);
2405
Sascha Hauer27942ef2019-03-26 08:54:31 +01002406 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002407}
Jan Karac7d3d282019-11-01 17:45:31 +01002408EXPORT_SYMBOL(dquot_load_quota_sb);
2409
2410/*
Jan Karadc19432a2019-11-01 18:37:44 +01002411 * More powerful function for turning on quotas on given quota inode allowing
2412 * setting of individual quota flags
Jan Karac7d3d282019-11-01 17:45:31 +01002413 */
Jan Karadc19432a2019-11-01 18:37:44 +01002414int dquot_load_quota_inode(struct inode *inode, int type, int format_id,
Jan Karac7d3d282019-11-01 17:45:31 +01002415 unsigned int flags)
2416{
2417 int err;
2418
2419 err = vfs_setup_quota_inode(inode, type);
2420 if (err < 0)
2421 return err;
2422 err = dquot_load_quota_sb(inode->i_sb, type, format_id, flags);
2423 if (err < 0)
2424 vfs_cleanup_quota_inode(inode->i_sb, type);
2425 return err;
2426}
Jan Karadc19432a2019-11-01 18:37:44 +01002427EXPORT_SYMBOL(dquot_load_quota_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002428
Jan Kara0ff5af82008-04-28 02:14:33 -07002429/* Reenable quotas on remount RW */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002430int dquot_resume(struct super_block *sb, int type)
Jan Kara0ff5af82008-04-28 02:14:33 -07002431{
2432 struct quota_info *dqopt = sb_dqopt(sb);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002433 int ret = 0, cnt;
Jan Karaf55abc02008-08-20 17:50:32 +02002434 unsigned int flags;
Jan Kara0ff5af82008-04-28 02:14:33 -07002435
Jan Kara7d6cd732016-11-23 13:16:10 +01002436 /* s_umount should be held in exclusive mode */
2437 if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
2438 up_read(&sb->s_umount);
2439
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002440 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2441 if (type != -1 && cnt != type)
2442 continue;
Jan Karac3b00442016-11-23 14:04:55 +01002443 if (!sb_has_quota_suspended(sb, cnt))
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002444 continue;
Jan Karac3b00442016-11-23 14:04:55 +01002445
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002446 spin_lock(&dq_state_lock);
2447 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2448 DQUOT_LIMITS_ENABLED,
2449 cnt);
2450 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2451 spin_unlock(&dq_state_lock);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002452
2453 flags = dquot_generic_flag(flags, cnt);
Jan Karaae45f072019-11-01 17:51:05 +01002454 ret = dquot_load_quota_sb(sb, cnt, dqopt->info[cnt].dqi_fmt_id,
2455 flags);
2456 if (ret < 0)
2457 vfs_cleanup_quota_inode(sb, type);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002458 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002459
2460 return ret;
2461}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002462EXPORT_SYMBOL(dquot_resume);
Jan Kara0ff5af82008-04-28 02:14:33 -07002463
Jan Karaf00c9e42010-09-15 17:38:58 +02002464int dquot_quota_on(struct super_block *sb, int type, int format_id,
Al Viro8c54ca92016-11-20 19:49:34 -05002465 const struct path *path)
Al Viro77e69da2008-08-01 04:29:18 -04002466{
2467 int error = security_quota_on(path->dentry);
2468 if (error)
2469 return error;
2470 /* Quota file not on the same filesystem? */
Al Virod8c95842011-12-07 18:16:57 -05002471 if (path->dentry->d_sb != sb)
Al Viro77e69da2008-08-01 04:29:18 -04002472 error = -EXDEV;
2473 else
Jan Karadc19432a2019-11-01 18:37:44 +01002474 error = dquot_load_quota_inode(d_inode(path->dentry), type,
Jan Karaf55abc02008-08-20 17:50:32 +02002475 format_id, DQUOT_USAGE_ENABLED |
2476 DQUOT_LIMITS_ENABLED);
Al Viro77e69da2008-08-01 04:29:18 -04002477 return error;
2478}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002479EXPORT_SYMBOL(dquot_quota_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480
2481/*
2482 * This function is used when filesystem needs to initialize quotas
2483 * during mount time.
2484 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002485int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Christoph Hellwig84de8562005-06-23 00:09:16 -07002486 int format_id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002487{
Christoph Hellwig84de8562005-06-23 00:09:16 -07002488 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 int error;
2490
Al Viro6c2d47982019-10-31 01:21:58 -04002491 dentry = lookup_positive_unlocked(qf_name, sb->s_root, strlen(qf_name));
Christoph Hellwig84de8562005-06-23 00:09:16 -07002492 if (IS_ERR(dentry))
2493 return PTR_ERR(dentry);
2494
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 error = security_quota_on(dentry);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002496 if (!error)
Jan Karadc19432a2019-11-01 18:37:44 +01002497 error = dquot_load_quota_inode(d_inode(dentry), type, format_id,
Jan Karaf55abc02008-08-20 17:50:32 +02002498 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002499
Christoph Hellwig84de8562005-06-23 00:09:16 -07002500 dput(dentry);
2501 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002503EXPORT_SYMBOL(dquot_quota_on_mount);
Jan Karab85f4b82008-07-25 01:46:50 -07002504
Jan Kara3e2af672014-10-06 18:40:51 +02002505static int dquot_quota_enable(struct super_block *sb, unsigned int flags)
2506{
2507 int ret;
2508 int type;
2509 struct quota_info *dqopt = sb_dqopt(sb);
2510
2511 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
2512 return -ENOSYS;
2513 /* Accounting cannot be turned on while fs is mounted */
2514 flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT);
2515 if (!flags)
2516 return -EINVAL;
2517 for (type = 0; type < MAXQUOTAS; type++) {
2518 if (!(flags & qtype_enforce_flag(type)))
2519 continue;
2520 /* Can't enforce without accounting */
Jan Kara069a9162019-11-01 18:57:56 +01002521 if (!sb_has_quota_usage_enabled(sb, type)) {
2522 ret = -EINVAL;
Jan Kara3e2af672014-10-06 18:40:51 +02002523 goto out_err;
Jan Kara069a9162019-11-01 18:57:56 +01002524 }
2525 if (sb_has_quota_limits_enabled(sb, type)) {
2526 ret = -EBUSY;
2527 goto out_err;
2528 }
2529 spin_lock(&dq_state_lock);
2530 dqopt->flags |= dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
2531 spin_unlock(&dq_state_lock);
Jan Kara3e2af672014-10-06 18:40:51 +02002532 }
2533 return 0;
2534out_err:
2535 /* Backout enforcement enablement we already did */
2536 for (type--; type >= 0; type--) {
2537 if (flags & qtype_enforce_flag(type))
2538 dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
2539 }
2540 /* Error code translation for better compatibility with XFS */
2541 if (ret == -EBUSY)
2542 ret = -EEXIST;
2543 return ret;
2544}
2545
2546static int dquot_quota_disable(struct super_block *sb, unsigned int flags)
2547{
2548 int ret;
2549 int type;
2550 struct quota_info *dqopt = sb_dqopt(sb);
2551
2552 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
2553 return -ENOSYS;
2554 /*
2555 * We don't support turning off accounting via quotactl. In principle
2556 * quota infrastructure can do this but filesystems don't expect
2557 * userspace to be able to do it.
2558 */
2559 if (flags &
2560 (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT))
2561 return -EOPNOTSUPP;
2562
2563 /* Filter out limits not enabled */
2564 for (type = 0; type < MAXQUOTAS; type++)
2565 if (!sb_has_quota_limits_enabled(sb, type))
2566 flags &= ~qtype_enforce_flag(type);
2567 /* Nothing left? */
2568 if (!flags)
2569 return -EEXIST;
2570 for (type = 0; type < MAXQUOTAS; type++) {
2571 if (flags & qtype_enforce_flag(type)) {
2572 ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
2573 if (ret < 0)
2574 goto out_err;
2575 }
2576 }
2577 return 0;
2578out_err:
2579 /* Backout enforcement disabling we already did */
2580 for (type--; type >= 0; type--) {
Jan Kara069a9162019-11-01 18:57:56 +01002581 if (flags & qtype_enforce_flag(type)) {
2582 spin_lock(&dq_state_lock);
2583 dqopt->flags |=
2584 dquot_state_flag(DQUOT_LIMITS_ENABLED, type);
2585 spin_unlock(&dq_state_lock);
2586 }
Jan Kara3e2af672014-10-06 18:40:51 +02002587 }
2588 return ret;
2589}
2590
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591/* Generic routine for getting common part of quota structure */
Jan Kara14bf61f2014-10-09 16:03:13 +02002592static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593{
2594 struct mem_dqblk *dm = &dquot->dq_dqb;
2595
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002596 memset(di, 0, sizeof(*di));
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002597 spin_lock(&dquot->dq_dqb_lock);
Jan Kara14bf61f2014-10-09 16:03:13 +02002598 di->d_spc_hardlimit = dm->dqb_bhardlimit;
2599 di->d_spc_softlimit = dm->dqb_bsoftlimit;
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002600 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2601 di->d_ino_softlimit = dm->dqb_isoftlimit;
Jan Kara14bf61f2014-10-09 16:03:13 +02002602 di->d_space = dm->dqb_curspace + dm->dqb_rsvspace;
2603 di->d_ino_count = dm->dqb_curinodes;
2604 di->d_spc_timer = dm->dqb_btime;
2605 di->d_ino_timer = dm->dqb_itime;
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002606 spin_unlock(&dquot->dq_dqb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607}
2608
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002609int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
Jan Kara14bf61f2014-10-09 16:03:13 +02002610 struct qc_dqblk *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611{
2612 struct dquot *dquot;
2613
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002614 dquot = dqget(sb, qid);
Jan Kara6184fc02015-06-24 18:07:02 +02002615 if (IS_ERR(dquot))
2616 return PTR_ERR(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 do_get_dqblk(dquot, di);
2618 dqput(dquot);
Jan Karacc334122009-01-12 17:23:05 +01002619
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 return 0;
2621}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002622EXPORT_SYMBOL(dquot_get_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623
Jan Karabe6257b2016-01-25 19:24:50 +01002624int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid,
2625 struct qc_dqblk *di)
2626{
2627 struct dquot *dquot;
2628 int err;
2629
2630 if (!sb->dq_op->get_next_id)
2631 return -ENOSYS;
2632 err = sb->dq_op->get_next_id(sb, qid);
2633 if (err < 0)
2634 return err;
2635 dquot = dqget(sb, *qid);
2636 if (IS_ERR(dquot))
2637 return PTR_ERR(dquot);
2638 do_get_dqblk(dquot, di);
2639 dqput(dquot);
2640
2641 return 0;
2642}
2643EXPORT_SYMBOL(dquot_get_next_dqblk);
2644
Jan Kara14bf61f2014-10-09 16:03:13 +02002645#define VFS_QC_MASK \
2646 (QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \
2647 QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \
2648 QC_SPC_TIMER | QC_INO_TIMER)
Christoph Hellwigc472b432010-05-06 17:05:17 -04002649
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650/* Generic routine for setting common part of quota structure */
Jan Kara14bf61f2014-10-09 16:03:13 +02002651static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652{
2653 struct mem_dqblk *dm = &dquot->dq_dqb;
2654 int check_blim = 0, check_ilim = 0;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002655 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002656
Jan Kara14bf61f2014-10-09 16:03:13 +02002657 if (di->d_fieldmask & ~VFS_QC_MASK)
Christoph Hellwigc472b432010-05-06 17:05:17 -04002658 return -EINVAL;
2659
Jan Kara14bf61f2014-10-09 16:03:13 +02002660 if (((di->d_fieldmask & QC_SPC_SOFT) &&
Jan Karab10a0812014-10-09 16:54:13 +02002661 di->d_spc_softlimit > dqi->dqi_max_spc_limit) ||
Jan Kara14bf61f2014-10-09 16:03:13 +02002662 ((di->d_fieldmask & QC_SPC_HARD) &&
Jan Karab10a0812014-10-09 16:54:13 +02002663 di->d_spc_hardlimit > dqi->dqi_max_spc_limit) ||
Jan Kara14bf61f2014-10-09 16:03:13 +02002664 ((di->d_fieldmask & QC_INO_SOFT) &&
Jan Karab10a0812014-10-09 16:54:13 +02002665 (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) ||
Jan Kara14bf61f2014-10-09 16:03:13 +02002666 ((di->d_fieldmask & QC_INO_HARD) &&
Jan Karab10a0812014-10-09 16:54:13 +02002667 (di->d_ino_hardlimit > dqi->dqi_max_ino_limit)))
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002668 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002669
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002670 spin_lock(&dquot->dq_dqb_lock);
Jan Kara14bf61f2014-10-09 16:03:13 +02002671 if (di->d_fieldmask & QC_SPACE) {
2672 dm->dqb_curspace = di->d_space - dm->dqb_rsvspace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002674 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002676
Jan Kara14bf61f2014-10-09 16:03:13 +02002677 if (di->d_fieldmask & QC_SPC_SOFT)
2678 dm->dqb_bsoftlimit = di->d_spc_softlimit;
2679 if (di->d_fieldmask & QC_SPC_HARD)
2680 dm->dqb_bhardlimit = di->d_spc_hardlimit;
2681 if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002683 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002685
Jan Kara14bf61f2014-10-09 16:03:13 +02002686 if (di->d_fieldmask & QC_INO_COUNT) {
2687 dm->dqb_curinodes = di->d_ino_count;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002688 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002689 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002691
Jan Kara14bf61f2014-10-09 16:03:13 +02002692 if (di->d_fieldmask & QC_INO_SOFT)
Christoph Hellwigc472b432010-05-06 17:05:17 -04002693 dm->dqb_isoftlimit = di->d_ino_softlimit;
Jan Kara14bf61f2014-10-09 16:03:13 +02002694 if (di->d_fieldmask & QC_INO_HARD)
Christoph Hellwigc472b432010-05-06 17:05:17 -04002695 dm->dqb_ihardlimit = di->d_ino_hardlimit;
Jan Kara14bf61f2014-10-09 16:03:13 +02002696 if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002698 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002699 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002700
Jan Kara14bf61f2014-10-09 16:03:13 +02002701 if (di->d_fieldmask & QC_SPC_TIMER) {
2702 dm->dqb_btime = di->d_spc_timer;
Jan Karae04a88a92009-01-07 18:07:29 -08002703 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002704 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002705 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002706
Jan Kara14bf61f2014-10-09 16:03:13 +02002707 if (di->d_fieldmask & QC_INO_TIMER) {
2708 dm->dqb_itime = di->d_ino_timer;
Jan Karae04a88a92009-01-07 18:07:29 -08002709 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002710 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002711 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712
2713 if (check_blim) {
Jan Kara268157b2009-01-27 15:47:22 +01002714 if (!dm->dqb_bsoftlimit ||
Chengguang Xu4b8e1102019-07-24 13:32:16 +08002715 dm->dqb_curspace + dm->dqb_rsvspace <= dm->dqb_bsoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 dm->dqb_btime = 0;
2717 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
Jan Kara14bf61f2014-10-09 16:03:13 +02002718 } else if (!(di->d_fieldmask & QC_SPC_TIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002719 /* Set grace only if user hasn't provided his own... */
Arnd Bergmanne008bb62016-06-17 22:03:16 +02002720 dm->dqb_btime = ktime_get_real_seconds() + dqi->dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721 }
2722 if (check_ilim) {
Jan Kara268157b2009-01-27 15:47:22 +01002723 if (!dm->dqb_isoftlimit ||
Chengguang Xu4b8e1102019-07-24 13:32:16 +08002724 dm->dqb_curinodes <= dm->dqb_isoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725 dm->dqb_itime = 0;
2726 clear_bit(DQ_INODES_B, &dquot->dq_flags);
Jan Kara14bf61f2014-10-09 16:03:13 +02002727 } else if (!(di->d_fieldmask & QC_INO_TIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002728 /* Set grace only if user hasn't provided his own... */
Arnd Bergmanne008bb62016-06-17 22:03:16 +02002729 dm->dqb_itime = ktime_get_real_seconds() + dqi->dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730 }
Jan Kara268157b2009-01-27 15:47:22 +01002731 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2732 dm->dqb_isoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2734 else
2735 set_bit(DQ_FAKE_B, &dquot->dq_flags);
Jan Kara7b9ca4c2017-08-07 13:19:50 +02002736 spin_unlock(&dquot->dq_dqb_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737 mark_dquot_dirty(dquot);
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002738
2739 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002740}
2741
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002742int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
Jan Kara14bf61f2014-10-09 16:03:13 +02002743 struct qc_dqblk *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744{
2745 struct dquot *dquot;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002746 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002748 dquot = dqget(sb, qid);
Jan Kara6184fc02015-06-24 18:07:02 +02002749 if (IS_ERR(dquot)) {
2750 rc = PTR_ERR(dquot);
Jan Karaf55abc02008-08-20 17:50:32 +02002751 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002752 }
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002753 rc = do_set_dqblk(dquot, di);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002754 dqput(dquot);
Jan Karaf55abc02008-08-20 17:50:32 +02002755out:
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002756 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002758EXPORT_SYMBOL(dquot_set_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002759
2760/* Generic routine for getting common part of quota file information */
Jan Kara0a2403392014-11-19 00:42:09 +01002761int dquot_get_state(struct super_block *sb, struct qc_state *state)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762{
2763 struct mem_dqinfo *mi;
Jan Kara0a2403392014-11-19 00:42:09 +01002764 struct qc_type_state *tstate;
2765 struct quota_info *dqopt = sb_dqopt(sb);
2766 int type;
Sascha Hauer27942ef2019-03-26 08:54:31 +01002767
Jan Kara0a2403392014-11-19 00:42:09 +01002768 memset(state, 0, sizeof(*state));
2769 for (type = 0; type < MAXQUOTAS; type++) {
2770 if (!sb_has_quota_active(sb, type))
2771 continue;
2772 tstate = state->s_state + type;
2773 mi = sb_dqopt(sb)->info + type;
2774 tstate->flags = QCI_ACCT_ENABLED;
2775 spin_lock(&dq_data_lock);
2776 if (mi->dqi_flags & DQF_SYS_FILE)
2777 tstate->flags |= QCI_SYSFILE;
2778 if (mi->dqi_flags & DQF_ROOT_SQUASH)
2779 tstate->flags |= QCI_ROOT_SQUASH;
2780 if (sb_has_quota_limits_enabled(sb, type))
2781 tstate->flags |= QCI_LIMITS_ENFORCED;
2782 tstate->spc_timelimit = mi->dqi_bgrace;
2783 tstate->ino_timelimit = mi->dqi_igrace;
Jan Karaa0828b62019-11-04 11:18:17 +01002784 if (dqopt->files[type]) {
2785 tstate->ino = dqopt->files[type]->i_ino;
2786 tstate->blocks = dqopt->files[type]->i_blocks;
2787 }
Jan Kara0a2403392014-11-19 00:42:09 +01002788 tstate->nextents = 1; /* We don't know... */
2789 spin_unlock(&dq_data_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002790 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002791 return 0;
2792}
Jan Kara0a2403392014-11-19 00:42:09 +01002793EXPORT_SYMBOL(dquot_get_state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002794
2795/* Generic routine for setting common part of quota file information */
Jan Kara5eacb2a2014-12-16 12:03:51 +01002796int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002797{
2798 struct mem_dqinfo *mi;
Jan Karaf55abc02008-08-20 17:50:32 +02002799 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002800
Jan Kara5eacb2a2014-12-16 12:03:51 +01002801 if ((ii->i_fieldmask & QC_WARNS_MASK) ||
2802 (ii->i_fieldmask & QC_RT_SPC_TIMER))
2803 return -EINVAL;
Jan Kara9d1ccbe2016-11-23 13:35:14 +01002804 if (!sb_has_quota_active(sb, type))
2805 return -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002806 mi = sb_dqopt(sb)->info + type;
Jan Kara5eacb2a2014-12-16 12:03:51 +01002807 if (ii->i_fieldmask & QC_FLAGS) {
2808 if ((ii->i_flags & QCI_ROOT_SQUASH &&
Jan Kara9d1ccbe2016-11-23 13:35:14 +01002809 mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD))
2810 return -EINVAL;
Jan Karaca6cb0912014-11-19 09:32:39 +01002811 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812 spin_lock(&dq_data_lock);
Jan Kara5eacb2a2014-12-16 12:03:51 +01002813 if (ii->i_fieldmask & QC_SPC_TIMER)
2814 mi->dqi_bgrace = ii->i_spc_timelimit;
2815 if (ii->i_fieldmask & QC_INO_TIMER)
2816 mi->dqi_igrace = ii->i_ino_timelimit;
2817 if (ii->i_fieldmask & QC_FLAGS) {
2818 if (ii->i_flags & QCI_ROOT_SQUASH)
2819 mi->dqi_flags |= DQF_ROOT_SQUASH;
2820 else
2821 mi->dqi_flags &= ~DQF_ROOT_SQUASH;
2822 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 spin_unlock(&dq_data_lock);
2824 mark_info_dirty(sb, type);
2825 /* Force write to disk */
2826 sb->dq_op->write_info(sb, type);
Jan Karaf55abc02008-08-20 17:50:32 +02002827 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002828}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002829EXPORT_SYMBOL(dquot_set_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002830
Jan Kara3e2af672014-10-06 18:40:51 +02002831const struct quotactl_ops dquot_quotactl_sysfile_ops = {
2832 .quota_enable = dquot_quota_enable,
2833 .quota_disable = dquot_quota_disable,
2834 .quota_sync = dquot_quota_sync,
Jan Kara0a2403392014-11-19 00:42:09 +01002835 .get_state = dquot_get_state,
Jan Kara3e2af672014-10-06 18:40:51 +02002836 .set_info = dquot_set_dqinfo,
2837 .get_dqblk = dquot_get_dqblk,
Jan Karabe6257b2016-01-25 19:24:50 +01002838 .get_nextdqblk = dquot_get_next_dqblk,
Jan Kara3e2af672014-10-06 18:40:51 +02002839 .set_dqblk = dquot_set_dqblk
2840};
2841EXPORT_SYMBOL(dquot_quotactl_sysfile_ops);
2842
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002843static int do_proc_dqstats(struct ctl_table *table, int write,
2844 void __user *buffer, size_t *lenp, loff_t *ppos)
2845{
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002846 unsigned int type = (unsigned long *)table->data - dqstats.stat;
2847 s64 value = percpu_counter_sum(&dqstats.counter[type]);
2848
2849 /* Filter negative values for non-monotonic counters */
2850 if (value < 0 && (type == DQST_ALLOC_DQUOTS ||
2851 type == DQST_FREE_DQUOTS))
2852 value = 0;
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002853
2854 /* Update global table */
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002855 dqstats.stat[type] = value;
2856 return proc_doulongvec_minmax(table, write, buffer, lenp, ppos);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002857}
2858
Joe Perchese6287532013-06-13 19:37:49 -07002859static struct ctl_table fs_dqstats_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 .procname = "lookups",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002862 .data = &dqstats.stat[DQST_LOOKUPS],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002863 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002864 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002865 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002866 },
2867 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002868 .procname = "drops",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002869 .data = &dqstats.stat[DQST_DROPS],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002870 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002871 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002872 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002873 },
2874 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002875 .procname = "reads",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002876 .data = &dqstats.stat[DQST_READS],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002877 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002878 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002879 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002880 },
2881 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002882 .procname = "writes",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002883 .data = &dqstats.stat[DQST_WRITES],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002884 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002885 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002886 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002887 },
2888 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 .procname = "cache_hits",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002890 .data = &dqstats.stat[DQST_CACHE_HITS],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002891 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002892 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002893 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 },
2895 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 .procname = "allocated_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002897 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002898 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002899 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002900 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002901 },
2902 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002903 .procname = "free_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002904 .data = &dqstats.stat[DQST_FREE_DQUOTS],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002905 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002906 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002907 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002908 },
2909 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002910 .procname = "syncs",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002911 .data = &dqstats.stat[DQST_SYNCS],
Konstantin Khlebnikov6fcbcec2019-11-10 12:49:06 +03002912 .maxlen = sizeof(unsigned long),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002913 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002914 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002915 },
Jan Kara8e893462007-10-16 23:29:31 -07002916#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07002917 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002918 .procname = "warnings",
2919 .data = &flag_print_warnings,
2920 .maxlen = sizeof(int),
2921 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08002922 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002923 },
Jan Kara8e893462007-10-16 23:29:31 -07002924#endif
Eric W. Biedermanab092032009-11-05 14:25:10 -08002925 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002926};
2927
Joe Perchese6287532013-06-13 19:37:49 -07002928static struct ctl_table fs_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002930 .procname = "quota",
2931 .mode = 0555,
2932 .child = fs_dqstats_table,
2933 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002934 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935};
2936
Joe Perchese6287532013-06-13 19:37:49 -07002937static struct ctl_table sys_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002938 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939 .procname = "fs",
2940 .mode = 0555,
2941 .child = fs_table,
2942 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002943 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002944};
2945
2946static int __init dquot_init(void)
2947{
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002948 int i, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002949 unsigned long nr_hash, order;
2950
2951 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2952
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08002953 register_sysctl_table(sys_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002954
Paul Mundt20c2df82007-07-20 10:11:58 +09002955 dquot_cachep = kmem_cache_create("dquot",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002956 sizeof(struct dquot), sizeof(unsigned long) * 4,
Paul Jacksonfffb60f2006-03-24 03:16:06 -08002957 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2958 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +09002959 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002960
2961 order = 0;
Jia-Ju Bai1aa3b3e2018-04-09 22:31:19 +08002962 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_KERNEL, order);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002963 if (!dquot_hash)
2964 panic("Cannot create dquot hash table");
2965
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002966 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
Tejun Heo908c7f12014-09-08 09:51:29 +09002967 ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL);
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002968 if (ret)
2969 panic("Cannot create dquot stat counters");
2970 }
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002971
Linus Torvalds1da177e2005-04-16 15:20:36 -07002972 /* Find power-of-two hlist_heads which can fit into allocation */
2973 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
Chengguang Xu24fc7552019-09-23 21:52:23 +08002974 dq_hash_bits = ilog2(nr_hash);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002975
2976 nr_hash = 1UL << dq_hash_bits;
2977 dq_hash_mask = nr_hash - 1;
2978 for (i = 0; i < nr_hash; i++)
2979 INIT_HLIST_HEAD(dquot_hash + i);
2980
Anton Blanchard19858e72014-11-04 12:05:01 +11002981 pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld,"
2982 " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983
Tetsuo Handa88bc0ed2017-11-29 22:34:50 +09002984 if (register_shrinker(&dqcache_shrinker))
2985 panic("Cannot register dquot shrinker");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 return 0;
2988}
Paul Gortmaker331221f2015-12-12 16:30:12 -05002989fs_initcall(dquot_init);