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