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