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