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