Merge branch 'next' into for-linus
[pandora-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  *   i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock >
120  *   dqio_mutex
121  * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem >
122  * dqptr_sem. But filesystem has to count with the fact that functions such as
123  * dquot_alloc_space() acquire dqptr_sem and they usually have to be called
124  * from inside a transaction to keep filesystem consistency after a crash. Also
125  * filesystems usually want to do some IO on dquot from ->mark_dirty which is
126  * called with dqptr_sem held.
127  * i_mutex on quota files is special (it's below dqio_mutex)
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 || (sb_dqopt(sb)->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(&sb_dqopt(sb)->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_nested(&sb_dqopt(sb)->files[cnt]->i_mutex,
662                                   I_MUTEX_QUOTA);
663                 truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0);
664                 mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex);
665         }
666         mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
667
668         return 0;
669 }
670 EXPORT_SYMBOL(dquot_quota_sync);
671
672 /* Free unused dquots from cache */
673 static void prune_dqcache(int count)
674 {
675         struct list_head *head;
676         struct dquot *dquot;
677
678         head = free_dquots.prev;
679         while (head != &free_dquots && count) {
680                 dquot = list_entry(head, struct dquot, dq_free);
681                 remove_dquot_hash(dquot);
682                 remove_free_dquot(dquot);
683                 remove_inuse(dquot);
684                 do_destroy_dquot(dquot);
685                 count--;
686                 head = free_dquots.prev;
687         }
688 }
689
690 /*
691  * This is called from kswapd when we think we need some
692  * more memory
693  */
694 static int shrink_dqcache_memory(struct shrinker *shrink,
695                                  struct shrink_control *sc)
696 {
697         int nr = sc->nr_to_scan;
698
699         if (nr) {
700                 spin_lock(&dq_list_lock);
701                 prune_dqcache(nr);
702                 spin_unlock(&dq_list_lock);
703         }
704         return ((unsigned)
705                 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])
706                 /100) * sysctl_vfs_cache_pressure;
707 }
708
709 static struct shrinker dqcache_shrinker = {
710         .shrink = shrink_dqcache_memory,
711         .seeks = DEFAULT_SEEKS,
712 };
713
714 /*
715  * Put reference to dquot
716  * NOTE: If you change this function please check whether dqput_blocks() works right...
717  */
718 void dqput(struct dquot *dquot)
719 {
720         int ret;
721
722         if (!dquot)
723                 return;
724 #ifdef CONFIG_QUOTA_DEBUG
725         if (!atomic_read(&dquot->dq_count)) {
726                 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
727                             quotatypes[dquot->dq_type], dquot->dq_id);
728                 BUG();
729         }
730 #endif
731         dqstats_inc(DQST_DROPS);
732 we_slept:
733         spin_lock(&dq_list_lock);
734         if (atomic_read(&dquot->dq_count) > 1) {
735                 /* We have more than one user... nothing to do */
736                 atomic_dec(&dquot->dq_count);
737                 /* Releasing dquot during quotaoff phase? */
738                 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) &&
739                     atomic_read(&dquot->dq_count) == 1)
740                         wake_up(&dquot->dq_wait_unused);
741                 spin_unlock(&dq_list_lock);
742                 return;
743         }
744         /* Need to release dquot? */
745         if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
746                 spin_unlock(&dq_list_lock);
747                 /* Commit dquot before releasing */
748                 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
749                 if (ret < 0) {
750                         quota_error(dquot->dq_sb, "Can't write quota structure"
751                                     " (error %d). Quota may get out of sync!",
752                                     ret);
753                         /*
754                          * We clear dirty bit anyway, so that we avoid
755                          * infinite loop here
756                          */
757                         spin_lock(&dq_list_lock);
758                         clear_dquot_dirty(dquot);
759                         spin_unlock(&dq_list_lock);
760                 }
761                 goto we_slept;
762         }
763         /* Clear flag in case dquot was inactive (something bad happened) */
764         clear_dquot_dirty(dquot);
765         if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
766                 spin_unlock(&dq_list_lock);
767                 dquot->dq_sb->dq_op->release_dquot(dquot);
768                 goto we_slept;
769         }
770         atomic_dec(&dquot->dq_count);
771 #ifdef CONFIG_QUOTA_DEBUG
772         /* sanity check */
773         BUG_ON(!list_empty(&dquot->dq_free));
774 #endif
775         put_dquot_last(dquot);
776         spin_unlock(&dq_list_lock);
777 }
778 EXPORT_SYMBOL(dqput);
779
780 struct dquot *dquot_alloc(struct super_block *sb, int type)
781 {
782         return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
783 }
784 EXPORT_SYMBOL(dquot_alloc);
785
786 static struct dquot *get_empty_dquot(struct super_block *sb, int type)
787 {
788         struct dquot *dquot;
789
790         dquot = sb->dq_op->alloc_dquot(sb, type);
791         if(!dquot)
792                 return NULL;
793
794         mutex_init(&dquot->dq_lock);
795         INIT_LIST_HEAD(&dquot->dq_free);
796         INIT_LIST_HEAD(&dquot->dq_inuse);
797         INIT_HLIST_NODE(&dquot->dq_hash);
798         INIT_LIST_HEAD(&dquot->dq_dirty);
799         init_waitqueue_head(&dquot->dq_wait_unused);
800         dquot->dq_sb = sb;
801         dquot->dq_type = type;
802         atomic_set(&dquot->dq_count, 1);
803
804         return dquot;
805 }
806
807 /*
808  * Get reference to dquot
809  *
810  * Locking is slightly tricky here. We are guarded from parallel quotaoff()
811  * destroying our dquot by:
812  *   a) checking for quota flags under dq_list_lock and
813  *   b) getting a reference to dquot before we release dq_list_lock
814  */
815 struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
816 {
817         unsigned int hashent = hashfn(sb, id, type);
818         struct dquot *dquot = NULL, *empty = NULL;
819
820         if (!sb_has_quota_active(sb, type))
821                 return NULL;
822 we_slept:
823         spin_lock(&dq_list_lock);
824         spin_lock(&dq_state_lock);
825         if (!sb_has_quota_active(sb, type)) {
826                 spin_unlock(&dq_state_lock);
827                 spin_unlock(&dq_list_lock);
828                 goto out;
829         }
830         spin_unlock(&dq_state_lock);
831
832         dquot = find_dquot(hashent, sb, id, type);
833         if (!dquot) {
834                 if (!empty) {
835                         spin_unlock(&dq_list_lock);
836                         empty = get_empty_dquot(sb, type);
837                         if (!empty)
838                                 schedule();     /* Try to wait for a moment... */
839                         goto we_slept;
840                 }
841                 dquot = empty;
842                 empty = NULL;
843                 dquot->dq_id = id;
844                 /* all dquots go on the inuse_list */
845                 put_inuse(dquot);
846                 /* hash it first so it can be found */
847                 insert_dquot_hash(dquot);
848                 spin_unlock(&dq_list_lock);
849                 dqstats_inc(DQST_LOOKUPS);
850         } else {
851                 if (!atomic_read(&dquot->dq_count))
852                         remove_free_dquot(dquot);
853                 atomic_inc(&dquot->dq_count);
854                 spin_unlock(&dq_list_lock);
855                 dqstats_inc(DQST_CACHE_HITS);
856                 dqstats_inc(DQST_LOOKUPS);
857         }
858         /* Wait for dq_lock - after this we know that either dquot_release() is
859          * already finished or it will be canceled due to dq_count > 1 test */
860         wait_on_dquot(dquot);
861         /* Read the dquot / allocate space in quota file */
862         if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
863             sb->dq_op->acquire_dquot(dquot) < 0) {
864                 dqput(dquot);
865                 dquot = NULL;
866                 goto out;
867         }
868 #ifdef CONFIG_QUOTA_DEBUG
869         BUG_ON(!dquot->dq_sb);  /* Has somebody invalidated entry under us? */
870 #endif
871 out:
872         if (empty)
873                 do_destroy_dquot(empty);
874
875         return dquot;
876 }
877 EXPORT_SYMBOL(dqget);
878
879 static int dqinit_needed(struct inode *inode, int type)
880 {
881         int cnt;
882
883         if (IS_NOQUOTA(inode))
884                 return 0;
885         if (type != -1)
886                 return !inode->i_dquot[type];
887         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
888                 if (!inode->i_dquot[cnt])
889                         return 1;
890         return 0;
891 }
892
893 /* This routine is guarded by dqonoff_mutex mutex */
894 static void add_dquot_ref(struct super_block *sb, int type)
895 {
896         struct inode *inode, *old_inode = NULL;
897 #ifdef CONFIG_QUOTA_DEBUG
898         int reserved = 0;
899 #endif
900
901         spin_lock(&inode_sb_list_lock);
902         list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
903                 spin_lock(&inode->i_lock);
904                 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
905                     !atomic_read(&inode->i_writecount) ||
906                     !dqinit_needed(inode, type)) {
907                         spin_unlock(&inode->i_lock);
908                         continue;
909                 }
910 #ifdef CONFIG_QUOTA_DEBUG
911                 if (unlikely(inode_get_rsv_space(inode) > 0))
912                         reserved = 1;
913 #endif
914                 __iget(inode);
915                 spin_unlock(&inode->i_lock);
916                 spin_unlock(&inode_sb_list_lock);
917
918                 iput(old_inode);
919                 __dquot_initialize(inode, type);
920
921                 /*
922                  * We hold a reference to 'inode' so it couldn't have been
923                  * removed from s_inodes list while we dropped the
924                  * inode_sb_list_lock We cannot iput the inode now as we can be
925                  * holding the last reference and we cannot iput it under
926                  * inode_sb_list_lock. So we keep the reference and iput it
927                  * later.
928                  */
929                 old_inode = inode;
930                 spin_lock(&inode_sb_list_lock);
931         }
932         spin_unlock(&inode_sb_list_lock);
933         iput(old_inode);
934
935 #ifdef CONFIG_QUOTA_DEBUG
936         if (reserved) {
937                 quota_error(sb, "Writes happened before quota was turned on "
938                         "thus quota information is probably inconsistent. "
939                         "Please run quotacheck(8)");
940         }
941 #endif
942 }
943
944 /*
945  * Return 0 if dqput() won't block.
946  * (note that 1 doesn't necessarily mean blocking)
947  */
948 static inline int dqput_blocks(struct dquot *dquot)
949 {
950         if (atomic_read(&dquot->dq_count) <= 1)
951                 return 1;
952         return 0;
953 }
954
955 /*
956  * Remove references to dquots from inode and add dquot to list for freeing
957  * if we have the last reference to dquot
958  * We can't race with anybody because we hold dqptr_sem for writing...
959  */
960 static int remove_inode_dquot_ref(struct inode *inode, int type,
961                                   struct list_head *tofree_head)
962 {
963         struct dquot *dquot = inode->i_dquot[type];
964
965         inode->i_dquot[type] = NULL;
966         if (dquot) {
967                 if (dqput_blocks(dquot)) {
968 #ifdef CONFIG_QUOTA_DEBUG
969                         if (atomic_read(&dquot->dq_count) != 1)
970                                 quota_error(inode->i_sb, "Adding dquot with "
971                                             "dq_count %d to dispose list",
972                                             atomic_read(&dquot->dq_count));
973 #endif
974                         spin_lock(&dq_list_lock);
975                         /* As dquot must have currently users it can't be on
976                          * the free list... */
977                         list_add(&dquot->dq_free, tofree_head);
978                         spin_unlock(&dq_list_lock);
979                         return 1;
980                 }
981                 else
982                         dqput(dquot);   /* We have guaranteed we won't block */
983         }
984         return 0;
985 }
986
987 /*
988  * Free list of dquots
989  * Dquots are removed from inodes and no new references can be got so we are
990  * the only ones holding reference
991  */
992 static void put_dquot_list(struct list_head *tofree_head)
993 {
994         struct list_head *act_head;
995         struct dquot *dquot;
996
997         act_head = tofree_head->next;
998         while (act_head != tofree_head) {
999                 dquot = list_entry(act_head, struct dquot, dq_free);
1000                 act_head = act_head->next;
1001                 /* Remove dquot from the list so we won't have problems... */
1002                 list_del_init(&dquot->dq_free);
1003                 dqput(dquot);
1004         }
1005 }
1006
1007 static void remove_dquot_ref(struct super_block *sb, int type,
1008                 struct list_head *tofree_head)
1009 {
1010         struct inode *inode;
1011         int reserved = 0;
1012
1013         spin_lock(&inode_sb_list_lock);
1014         list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
1015                 /*
1016                  *  We have to scan also I_NEW inodes because they can already
1017                  *  have quota pointer initialized. Luckily, we need to touch
1018                  *  only quota pointers and these have separate locking
1019                  *  (dqptr_sem).
1020                  */
1021                 if (!IS_NOQUOTA(inode)) {
1022                         if (unlikely(inode_get_rsv_space(inode) > 0))
1023                                 reserved = 1;
1024                         remove_inode_dquot_ref(inode, type, tofree_head);
1025                 }
1026         }
1027         spin_unlock(&inode_sb_list_lock);
1028 #ifdef CONFIG_QUOTA_DEBUG
1029         if (reserved) {
1030                 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1031                         " was disabled thus quota information is probably "
1032                         "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1033         }
1034 #endif
1035 }
1036
1037 /* Gather all references from inodes and drop them */
1038 static void drop_dquot_ref(struct super_block *sb, int type)
1039 {
1040         LIST_HEAD(tofree_head);
1041
1042         if (sb->dq_op) {
1043                 down_write(&sb_dqopt(sb)->dqptr_sem);
1044                 remove_dquot_ref(sb, type, &tofree_head);
1045                 up_write(&sb_dqopt(sb)->dqptr_sem);
1046                 put_dquot_list(&tofree_head);
1047         }
1048 }
1049
1050 static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
1051 {
1052         dquot->dq_dqb.dqb_curinodes += number;
1053 }
1054
1055 static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
1056 {
1057         dquot->dq_dqb.dqb_curspace += number;
1058 }
1059
1060 static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
1061 {
1062         dquot->dq_dqb.dqb_rsvspace += number;
1063 }
1064
1065 /*
1066  * Claim reserved quota space
1067  */
1068 static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
1069 {
1070         if (dquot->dq_dqb.dqb_rsvspace < number) {
1071                 WARN_ON_ONCE(1);
1072                 number = dquot->dq_dqb.dqb_rsvspace;
1073         }
1074         dquot->dq_dqb.dqb_curspace += number;
1075         dquot->dq_dqb.dqb_rsvspace -= number;
1076 }
1077
1078 static inline
1079 void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1080 {
1081         if (dquot->dq_dqb.dqb_rsvspace >= number)
1082                 dquot->dq_dqb.dqb_rsvspace -= number;
1083         else {
1084                 WARN_ON_ONCE(1);
1085                 dquot->dq_dqb.dqb_rsvspace = 0;
1086         }
1087 }
1088
1089 static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
1090 {
1091         if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1092             dquot->dq_dqb.dqb_curinodes >= number)
1093                 dquot->dq_dqb.dqb_curinodes -= number;
1094         else
1095                 dquot->dq_dqb.dqb_curinodes = 0;
1096         if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1097                 dquot->dq_dqb.dqb_itime = (time_t) 0;
1098         clear_bit(DQ_INODES_B, &dquot->dq_flags);
1099 }
1100
1101 static void dquot_decr_space(struct dquot *dquot, qsize_t number)
1102 {
1103         if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1104             dquot->dq_dqb.dqb_curspace >= number)
1105                 dquot->dq_dqb.dqb_curspace -= number;
1106         else
1107                 dquot->dq_dqb.dqb_curspace = 0;
1108         if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
1109                 dquot->dq_dqb.dqb_btime = (time_t) 0;
1110         clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1111 }
1112
1113 struct dquot_warn {
1114         struct super_block *w_sb;
1115         qid_t w_dq_id;
1116         short w_dq_type;
1117         short w_type;
1118 };
1119
1120 static int warning_issued(struct dquot *dquot, const int warntype)
1121 {
1122         int flag = (warntype == QUOTA_NL_BHARDWARN ||
1123                 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1124                 ((warntype == QUOTA_NL_IHARDWARN ||
1125                 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1126
1127         if (!flag)
1128                 return 0;
1129         return test_and_set_bit(flag, &dquot->dq_flags);
1130 }
1131
1132 #ifdef CONFIG_PRINT_QUOTA_WARNING
1133 static int flag_print_warnings = 1;
1134
1135 static int need_print_warning(struct dquot_warn *warn)
1136 {
1137         if (!flag_print_warnings)
1138                 return 0;
1139
1140         switch (warn->w_dq_type) {
1141                 case USRQUOTA:
1142                         return current_fsuid() == warn->w_dq_id;
1143                 case GRPQUOTA:
1144                         return in_group_p(warn->w_dq_id);
1145         }
1146         return 0;
1147 }
1148
1149 /* Print warning to user which exceeded quota */
1150 static void print_warning(struct dquot_warn *warn)
1151 {
1152         char *msg = NULL;
1153         struct tty_struct *tty;
1154         int warntype = warn->w_type;
1155
1156         if (warntype == QUOTA_NL_IHARDBELOW ||
1157             warntype == QUOTA_NL_ISOFTBELOW ||
1158             warntype == QUOTA_NL_BHARDBELOW ||
1159             warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
1160                 return;
1161
1162         tty = get_current_tty();
1163         if (!tty)
1164                 return;
1165         tty_write_message(tty, warn->w_sb->s_id);
1166         if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
1167                 tty_write_message(tty, ": warning, ");
1168         else
1169                 tty_write_message(tty, ": write failed, ");
1170         tty_write_message(tty, quotatypes[warn->w_dq_type]);
1171         switch (warntype) {
1172                 case QUOTA_NL_IHARDWARN:
1173                         msg = " file limit reached.\r\n";
1174                         break;
1175                 case QUOTA_NL_ISOFTLONGWARN:
1176                         msg = " file quota exceeded too long.\r\n";
1177                         break;
1178                 case QUOTA_NL_ISOFTWARN:
1179                         msg = " file quota exceeded.\r\n";
1180                         break;
1181                 case QUOTA_NL_BHARDWARN:
1182                         msg = " block limit reached.\r\n";
1183                         break;
1184                 case QUOTA_NL_BSOFTLONGWARN:
1185                         msg = " block quota exceeded too long.\r\n";
1186                         break;
1187                 case QUOTA_NL_BSOFTWARN:
1188                         msg = " block quota exceeded.\r\n";
1189                         break;
1190         }
1191         tty_write_message(tty, msg);
1192         tty_kref_put(tty);
1193 }
1194 #endif
1195
1196 static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1197                             int warntype)
1198 {
1199         if (warning_issued(dquot, warntype))
1200                 return;
1201         warn->w_type = warntype;
1202         warn->w_sb = dquot->dq_sb;
1203         warn->w_dq_id = dquot->dq_id;
1204         warn->w_dq_type = dquot->dq_type;
1205 }
1206
1207 /*
1208  * Write warnings to the console and send warning messages over netlink.
1209  *
1210  * Note that this function can call into tty and networking code.
1211  */
1212 static void flush_warnings(struct dquot_warn *warn)
1213 {
1214         int i;
1215
1216         for (i = 0; i < MAXQUOTAS; i++) {
1217                 if (warn[i].w_type == QUOTA_NL_NOWARN)
1218                         continue;
1219 #ifdef CONFIG_PRINT_QUOTA_WARNING
1220                 print_warning(&warn[i]);
1221 #endif
1222                 quota_send_warning(warn[i].w_dq_type, warn[i].w_dq_id,
1223                                    warn[i].w_sb->s_dev, warn[i].w_type);
1224         }
1225 }
1226
1227 static int ignore_hardlimit(struct dquot *dquot)
1228 {
1229         struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];
1230
1231         return capable(CAP_SYS_RESOURCE) &&
1232                (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1233                 !(info->dqi_flags & V1_DQF_RSQUASH));
1234 }
1235
1236 /* needs dq_data_lock */
1237 static int check_idq(struct dquot *dquot, qsize_t inodes,
1238                      struct dquot_warn *warn)
1239 {
1240         qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1241
1242         if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) ||
1243             test_bit(DQ_FAKE_B, &dquot->dq_flags))
1244                 return 0;
1245
1246         if (dquot->dq_dqb.dqb_ihardlimit &&
1247             newinodes > dquot->dq_dqb.dqb_ihardlimit &&
1248             !ignore_hardlimit(dquot)) {
1249                 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
1250                 return -EDQUOT;
1251         }
1252
1253         if (dquot->dq_dqb.dqb_isoftlimit &&
1254             newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1255             dquot->dq_dqb.dqb_itime &&
1256             get_seconds() >= dquot->dq_dqb.dqb_itime &&
1257             !ignore_hardlimit(dquot)) {
1258                 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
1259                 return -EDQUOT;
1260         }
1261
1262         if (dquot->dq_dqb.dqb_isoftlimit &&
1263             newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1264             dquot->dq_dqb.dqb_itime == 0) {
1265                 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
1266                 dquot->dq_dqb.dqb_itime = get_seconds() +
1267                     sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace;
1268         }
1269
1270         return 0;
1271 }
1272
1273 /* needs dq_data_lock */
1274 static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc,
1275                      struct dquot_warn *warn)
1276 {
1277         qsize_t tspace;
1278         struct super_block *sb = dquot->dq_sb;
1279
1280         if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) ||
1281             test_bit(DQ_FAKE_B, &dquot->dq_flags))
1282                 return 0;
1283
1284         tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1285                 + space;
1286
1287         if (dquot->dq_dqb.dqb_bhardlimit &&
1288             tspace > dquot->dq_dqb.dqb_bhardlimit &&
1289             !ignore_hardlimit(dquot)) {
1290                 if (!prealloc)
1291                         prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
1292                 return -EDQUOT;
1293         }
1294
1295         if (dquot->dq_dqb.dqb_bsoftlimit &&
1296             tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1297             dquot->dq_dqb.dqb_btime &&
1298             get_seconds() >= dquot->dq_dqb.dqb_btime &&
1299             !ignore_hardlimit(dquot)) {
1300                 if (!prealloc)
1301                         prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
1302                 return -EDQUOT;
1303         }
1304
1305         if (dquot->dq_dqb.dqb_bsoftlimit &&
1306             tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1307             dquot->dq_dqb.dqb_btime == 0) {
1308                 if (!prealloc) {
1309                         prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
1310                         dquot->dq_dqb.dqb_btime = get_seconds() +
1311                             sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace;
1312                 }
1313                 else
1314                         /*
1315                          * We don't allow preallocation to exceed softlimit so exceeding will
1316                          * be always printed
1317                          */
1318                         return -EDQUOT;
1319         }
1320
1321         return 0;
1322 }
1323
1324 static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1325 {
1326         qsize_t newinodes;
1327
1328         if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1329             dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
1330             !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type))
1331                 return QUOTA_NL_NOWARN;
1332
1333         newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1334         if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1335                 return QUOTA_NL_ISOFTBELOW;
1336         if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
1337             newinodes < dquot->dq_dqb.dqb_ihardlimit)
1338                 return QUOTA_NL_IHARDBELOW;
1339         return QUOTA_NL_NOWARN;
1340 }
1341
1342 static int info_bdq_free(struct dquot *dquot, qsize_t space)
1343 {
1344         if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1345             dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
1346                 return QUOTA_NL_NOWARN;
1347
1348         if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
1349                 return QUOTA_NL_BSOFTBELOW;
1350         if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
1351             dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
1352                 return QUOTA_NL_BHARDBELOW;
1353         return QUOTA_NL_NOWARN;
1354 }
1355
1356 static int dquot_active(const struct inode *inode)
1357 {
1358         struct super_block *sb = inode->i_sb;
1359
1360         if (IS_NOQUOTA(inode))
1361                 return 0;
1362         return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1363 }
1364
1365 /*
1366  * Initialize quota pointers in inode
1367  *
1368  * We do things in a bit complicated way but by that we avoid calling
1369  * dqget() and thus filesystem callbacks under dqptr_sem.
1370  *
1371  * It is better to call this function outside of any transaction as it
1372  * might need a lot of space in journal for dquot structure allocation.
1373  */
1374 static void __dquot_initialize(struct inode *inode, int type)
1375 {
1376         unsigned int id = 0;
1377         int cnt;
1378         struct dquot *got[MAXQUOTAS];
1379         struct super_block *sb = inode->i_sb;
1380         qsize_t rsv;
1381
1382         /* First test before acquiring mutex - solves deadlocks when we
1383          * re-enter the quota code and are already holding the mutex */
1384         if (!dquot_active(inode))
1385                 return;
1386
1387         /* First get references to structures we might need. */
1388         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1389                 got[cnt] = NULL;
1390                 if (type != -1 && cnt != type)
1391                         continue;
1392                 switch (cnt) {
1393                 case USRQUOTA:
1394                         id = inode->i_uid;
1395                         break;
1396                 case GRPQUOTA:
1397                         id = inode->i_gid;
1398                         break;
1399                 }
1400                 got[cnt] = dqget(sb, id, cnt);
1401         }
1402
1403         down_write(&sb_dqopt(sb)->dqptr_sem);
1404         if (IS_NOQUOTA(inode))
1405                 goto out_err;
1406         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1407                 if (type != -1 && cnt != type)
1408                         continue;
1409                 /* Avoid races with quotaoff() */
1410                 if (!sb_has_quota_active(sb, cnt))
1411                         continue;
1412                 /* We could race with quotaon or dqget() could have failed */
1413                 if (!got[cnt])
1414                         continue;
1415                 if (!inode->i_dquot[cnt]) {
1416                         inode->i_dquot[cnt] = got[cnt];
1417                         got[cnt] = NULL;
1418                         /*
1419                          * Make quota reservation system happy if someone
1420                          * did a write before quota was turned on
1421                          */
1422                         rsv = inode_get_rsv_space(inode);
1423                         if (unlikely(rsv))
1424                                 dquot_resv_space(inode->i_dquot[cnt], rsv);
1425                 }
1426         }
1427 out_err:
1428         up_write(&sb_dqopt(sb)->dqptr_sem);
1429         /* Drop unused references */
1430         dqput_all(got);
1431 }
1432
1433 void dquot_initialize(struct inode *inode)
1434 {
1435         __dquot_initialize(inode, -1);
1436 }
1437 EXPORT_SYMBOL(dquot_initialize);
1438
1439 /*
1440  *      Release all quotas referenced by inode
1441  */
1442 static void __dquot_drop(struct inode *inode)
1443 {
1444         int cnt;
1445         struct dquot *put[MAXQUOTAS];
1446
1447         down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1448         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1449                 put[cnt] = inode->i_dquot[cnt];
1450                 inode->i_dquot[cnt] = NULL;
1451         }
1452         up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1453         dqput_all(put);
1454 }
1455
1456 void dquot_drop(struct inode *inode)
1457 {
1458         int cnt;
1459
1460         if (IS_NOQUOTA(inode))
1461                 return;
1462
1463         /*
1464          * Test before calling to rule out calls from proc and such
1465          * where we are not allowed to block. Note that this is
1466          * actually reliable test even without the lock - the caller
1467          * must assure that nobody can come after the DQUOT_DROP and
1468          * add quota pointers back anyway.
1469          */
1470         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1471                 if (inode->i_dquot[cnt])
1472                         break;
1473         }
1474
1475         if (cnt < MAXQUOTAS)
1476                 __dquot_drop(inode);
1477 }
1478 EXPORT_SYMBOL(dquot_drop);
1479
1480 /*
1481  * inode_reserved_space is managed internally by quota, and protected by
1482  * i_lock similar to i_blocks+i_bytes.
1483  */
1484 static qsize_t *inode_reserved_space(struct inode * inode)
1485 {
1486         /* Filesystem must explicitly define it's own method in order to use
1487          * quota reservation interface */
1488         BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1489         return inode->i_sb->dq_op->get_reserved_space(inode);
1490 }
1491
1492 void inode_add_rsv_space(struct inode *inode, qsize_t number)
1493 {
1494         spin_lock(&inode->i_lock);
1495         *inode_reserved_space(inode) += number;
1496         spin_unlock(&inode->i_lock);
1497 }
1498 EXPORT_SYMBOL(inode_add_rsv_space);
1499
1500 void inode_claim_rsv_space(struct inode *inode, qsize_t number)
1501 {
1502         spin_lock(&inode->i_lock);
1503         *inode_reserved_space(inode) -= number;
1504         __inode_add_bytes(inode, number);
1505         spin_unlock(&inode->i_lock);
1506 }
1507 EXPORT_SYMBOL(inode_claim_rsv_space);
1508
1509 void inode_sub_rsv_space(struct inode *inode, qsize_t number)
1510 {
1511         spin_lock(&inode->i_lock);
1512         *inode_reserved_space(inode) -= number;
1513         spin_unlock(&inode->i_lock);
1514 }
1515 EXPORT_SYMBOL(inode_sub_rsv_space);
1516
1517 static qsize_t inode_get_rsv_space(struct inode *inode)
1518 {
1519         qsize_t ret;
1520
1521         if (!inode->i_sb->dq_op->get_reserved_space)
1522                 return 0;
1523         spin_lock(&inode->i_lock);
1524         ret = *inode_reserved_space(inode);
1525         spin_unlock(&inode->i_lock);
1526         return ret;
1527 }
1528
1529 static void inode_incr_space(struct inode *inode, qsize_t number,
1530                                 int reserve)
1531 {
1532         if (reserve)
1533                 inode_add_rsv_space(inode, number);
1534         else
1535                 inode_add_bytes(inode, number);
1536 }
1537
1538 static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1539 {
1540         if (reserve)
1541                 inode_sub_rsv_space(inode, number);
1542         else
1543                 inode_sub_bytes(inode, number);
1544 }
1545
1546 /*
1547  * This functions updates i_blocks+i_bytes fields and quota information
1548  * (together with appropriate checks).
1549  *
1550  * NOTE: We absolutely rely on the fact that caller dirties the inode
1551  * (usually helpers in quotaops.h care about this) and holds a handle for
1552  * the current transaction so that dquot write and inode write go into the
1553  * same transaction.
1554  */
1555
1556 /*
1557  * This operation can block, but only after everything is updated
1558  */
1559 int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
1560 {
1561         int cnt, ret = 0;
1562         struct dquot_warn warn[MAXQUOTAS];
1563         struct dquot **dquots = inode->i_dquot;
1564         int reserve = flags & DQUOT_SPACE_RESERVE;
1565
1566         /*
1567          * First test before acquiring mutex - solves deadlocks when we
1568          * re-enter the quota code and are already holding the mutex
1569          */
1570         if (!dquot_active(inode)) {
1571                 inode_incr_space(inode, number, reserve);
1572                 goto out;
1573         }
1574
1575         down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1576         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1577                 warn[cnt].w_type = QUOTA_NL_NOWARN;
1578
1579         spin_lock(&dq_data_lock);
1580         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1581                 if (!dquots[cnt])
1582                         continue;
1583                 ret = check_bdq(dquots[cnt], number,
1584                                 !(flags & DQUOT_SPACE_WARN), &warn[cnt]);
1585                 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
1586                         spin_unlock(&dq_data_lock);
1587                         goto out_flush_warn;
1588                 }
1589         }
1590         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1591                 if (!dquots[cnt])
1592                         continue;
1593                 if (reserve)
1594                         dquot_resv_space(dquots[cnt], number);
1595                 else
1596                         dquot_incr_space(dquots[cnt], number);
1597         }
1598         inode_incr_space(inode, number, reserve);
1599         spin_unlock(&dq_data_lock);
1600
1601         if (reserve)
1602                 goto out_flush_warn;
1603         mark_all_dquot_dirty(dquots);
1604 out_flush_warn:
1605         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1606         flush_warnings(warn);
1607 out:
1608         return ret;
1609 }
1610 EXPORT_SYMBOL(__dquot_alloc_space);
1611
1612 /*
1613  * This operation can block, but only after everything is updated
1614  */
1615 int dquot_alloc_inode(const struct inode *inode)
1616 {
1617         int cnt, ret = 0;
1618         struct dquot_warn warn[MAXQUOTAS];
1619         struct dquot * const *dquots = inode->i_dquot;
1620
1621         /* First test before acquiring mutex - solves deadlocks when we
1622          * re-enter the quota code and are already holding the mutex */
1623         if (!dquot_active(inode))
1624                 return 0;
1625         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1626                 warn[cnt].w_type = QUOTA_NL_NOWARN;
1627         down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1628         spin_lock(&dq_data_lock);
1629         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1630                 if (!dquots[cnt])
1631                         continue;
1632                 ret = check_idq(dquots[cnt], 1, &warn[cnt]);
1633                 if (ret)
1634                         goto warn_put_all;
1635         }
1636
1637         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1638                 if (!dquots[cnt])
1639                         continue;
1640                 dquot_incr_inodes(dquots[cnt], 1);
1641         }
1642
1643 warn_put_all:
1644         spin_unlock(&dq_data_lock);
1645         if (ret == 0)
1646                 mark_all_dquot_dirty(dquots);
1647         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1648         flush_warnings(warn);
1649         return ret;
1650 }
1651 EXPORT_SYMBOL(dquot_alloc_inode);
1652
1653 /*
1654  * Convert in-memory reserved quotas to real consumed quotas
1655  */
1656 int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1657 {
1658         int cnt;
1659
1660         if (!dquot_active(inode)) {
1661                 inode_claim_rsv_space(inode, number);
1662                 return 0;
1663         }
1664
1665         down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1666         spin_lock(&dq_data_lock);
1667         /* Claim reserved quotas to allocated quotas */
1668         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1669                 if (inode->i_dquot[cnt])
1670                         dquot_claim_reserved_space(inode->i_dquot[cnt],
1671                                                         number);
1672         }
1673         /* Update inode bytes */
1674         inode_claim_rsv_space(inode, number);
1675         spin_unlock(&dq_data_lock);
1676         mark_all_dquot_dirty(inode->i_dquot);
1677         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1678         return 0;
1679 }
1680 EXPORT_SYMBOL(dquot_claim_space_nodirty);
1681
1682 /*
1683  * This operation can block, but only after everything is updated
1684  */
1685 void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
1686 {
1687         unsigned int cnt;
1688         struct dquot_warn warn[MAXQUOTAS];
1689         struct dquot **dquots = inode->i_dquot;
1690         int reserve = flags & DQUOT_SPACE_RESERVE;
1691
1692         /* First test before acquiring mutex - solves deadlocks when we
1693          * re-enter the quota code and are already holding the mutex */
1694         if (!dquot_active(inode)) {
1695                 inode_decr_space(inode, number, reserve);
1696                 return;
1697         }
1698
1699         down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1700         spin_lock(&dq_data_lock);
1701         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1702                 int wtype;
1703
1704                 warn[cnt].w_type = QUOTA_NL_NOWARN;
1705                 if (!dquots[cnt])
1706                         continue;
1707                 wtype = info_bdq_free(dquots[cnt], number);
1708                 if (wtype != QUOTA_NL_NOWARN)
1709                         prepare_warning(&warn[cnt], dquots[cnt], wtype);
1710                 if (reserve)
1711                         dquot_free_reserved_space(dquots[cnt], number);
1712                 else
1713                         dquot_decr_space(dquots[cnt], number);
1714         }
1715         inode_decr_space(inode, number, reserve);
1716         spin_unlock(&dq_data_lock);
1717
1718         if (reserve)
1719                 goto out_unlock;
1720         mark_all_dquot_dirty(dquots);
1721 out_unlock:
1722         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1723         flush_warnings(warn);
1724 }
1725 EXPORT_SYMBOL(__dquot_free_space);
1726
1727 /*
1728  * This operation can block, but only after everything is updated
1729  */
1730 void dquot_free_inode(const struct inode *inode)
1731 {
1732         unsigned int cnt;
1733         struct dquot_warn warn[MAXQUOTAS];
1734         struct dquot * const *dquots = inode->i_dquot;
1735
1736         /* First test before acquiring mutex - solves deadlocks when we
1737          * re-enter the quota code and are already holding the mutex */
1738         if (!dquot_active(inode))
1739                 return;
1740
1741         down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1742         spin_lock(&dq_data_lock);
1743         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1744                 int wtype;
1745
1746                 warn[cnt].w_type = QUOTA_NL_NOWARN;
1747                 if (!dquots[cnt])
1748                         continue;
1749                 wtype = info_idq_free(dquots[cnt], 1);
1750                 if (wtype != QUOTA_NL_NOWARN)
1751                         prepare_warning(&warn[cnt], dquots[cnt], wtype);
1752                 dquot_decr_inodes(dquots[cnt], 1);
1753         }
1754         spin_unlock(&dq_data_lock);
1755         mark_all_dquot_dirty(dquots);
1756         up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1757         flush_warnings(warn);
1758 }
1759 EXPORT_SYMBOL(dquot_free_inode);
1760
1761 /*
1762  * Transfer the number of inode and blocks from one diskquota to an other.
1763  * On success, dquot references in transfer_to are consumed and references
1764  * to original dquots that need to be released are placed there. On failure,
1765  * references are kept untouched.
1766  *
1767  * This operation can block, but only after everything is updated
1768  * A transaction must be started when entering this function.
1769  *
1770  */
1771 int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
1772 {
1773         qsize_t space, cur_space;
1774         qsize_t rsv_space = 0;
1775         struct dquot *transfer_from[MAXQUOTAS] = {};
1776         int cnt, ret = 0;
1777         char is_valid[MAXQUOTAS] = {};
1778         struct dquot_warn warn_to[MAXQUOTAS];
1779         struct dquot_warn warn_from_inodes[MAXQUOTAS];
1780         struct dquot_warn warn_from_space[MAXQUOTAS];
1781
1782         /* First test before acquiring mutex - solves deadlocks when we
1783          * re-enter the quota code and are already holding the mutex */
1784         if (IS_NOQUOTA(inode))
1785                 return 0;
1786         /* Initialize the arrays */
1787         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1788                 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1789                 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1790                 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1791         }
1792         down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1793         if (IS_NOQUOTA(inode)) {        /* File without quota accounting? */
1794                 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1795                 return 0;
1796         }
1797         spin_lock(&dq_data_lock);
1798         cur_space = inode_get_bytes(inode);
1799         rsv_space = inode_get_rsv_space(inode);
1800         space = cur_space + rsv_space;
1801         /* Build the transfer_from list and check the limits */
1802         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1803                 /*
1804                  * Skip changes for same uid or gid or for turned off quota-type.
1805                  */
1806                 if (!transfer_to[cnt])
1807                         continue;
1808                 /* Avoid races with quotaoff() */
1809                 if (!sb_has_quota_active(inode->i_sb, cnt))
1810                         continue;
1811                 is_valid[cnt] = 1;
1812                 transfer_from[cnt] = inode->i_dquot[cnt];
1813                 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]);
1814                 if (ret)
1815                         goto over_quota;
1816                 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
1817                 if (ret)
1818                         goto over_quota;
1819         }
1820
1821         /*
1822          * Finally perform the needed transfer from transfer_from to transfer_to
1823          */
1824         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1825                 if (!is_valid[cnt])
1826                         continue;
1827                 /* Due to IO error we might not have transfer_from[] structure */
1828                 if (transfer_from[cnt]) {
1829                         int wtype;
1830                         wtype = info_idq_free(transfer_from[cnt], 1);
1831                         if (wtype != QUOTA_NL_NOWARN)
1832                                 prepare_warning(&warn_from_inodes[cnt],
1833                                                 transfer_from[cnt], wtype);
1834                         wtype = info_bdq_free(transfer_from[cnt], space);
1835                         if (wtype != QUOTA_NL_NOWARN)
1836                                 prepare_warning(&warn_from_space[cnt],
1837                                                 transfer_from[cnt], wtype);
1838                         dquot_decr_inodes(transfer_from[cnt], 1);
1839                         dquot_decr_space(transfer_from[cnt], cur_space);
1840                         dquot_free_reserved_space(transfer_from[cnt],
1841                                                   rsv_space);
1842                 }
1843
1844                 dquot_incr_inodes(transfer_to[cnt], 1);
1845                 dquot_incr_space(transfer_to[cnt], cur_space);
1846                 dquot_resv_space(transfer_to[cnt], rsv_space);
1847
1848                 inode->i_dquot[cnt] = transfer_to[cnt];
1849         }
1850         spin_unlock(&dq_data_lock);
1851         up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1852
1853         mark_all_dquot_dirty(transfer_from);
1854         mark_all_dquot_dirty(transfer_to);
1855         flush_warnings(warn_to);
1856         flush_warnings(warn_from_inodes);
1857         flush_warnings(warn_from_space);
1858         /* Pass back references to put */
1859         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1860                 if (is_valid[cnt])
1861                         transfer_to[cnt] = transfer_from[cnt];
1862         return 0;
1863 over_quota:
1864         spin_unlock(&dq_data_lock);
1865         up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1866         flush_warnings(warn_to);
1867         return ret;
1868 }
1869 EXPORT_SYMBOL(__dquot_transfer);
1870
1871 /* Wrapper for transferring ownership of an inode for uid/gid only
1872  * Called from FSXXX_setattr()
1873  */
1874 int dquot_transfer(struct inode *inode, struct iattr *iattr)
1875 {
1876         struct dquot *transfer_to[MAXQUOTAS] = {};
1877         struct super_block *sb = inode->i_sb;
1878         int ret;
1879
1880         if (!dquot_active(inode))
1881                 return 0;
1882
1883         if (iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid)
1884                 transfer_to[USRQUOTA] = dqget(sb, iattr->ia_uid, USRQUOTA);
1885         if (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)
1886                 transfer_to[GRPQUOTA] = dqget(sb, iattr->ia_gid, GRPQUOTA);
1887
1888         ret = __dquot_transfer(inode, transfer_to);
1889         dqput_all(transfer_to);
1890         return ret;
1891 }
1892 EXPORT_SYMBOL(dquot_transfer);
1893
1894 /*
1895  * Write info of quota file to disk
1896  */
1897 int dquot_commit_info(struct super_block *sb, int type)
1898 {
1899         int ret;
1900         struct quota_info *dqopt = sb_dqopt(sb);
1901
1902         mutex_lock(&dqopt->dqio_mutex);
1903         ret = dqopt->ops[type]->write_file_info(sb, type);
1904         mutex_unlock(&dqopt->dqio_mutex);
1905         return ret;
1906 }
1907 EXPORT_SYMBOL(dquot_commit_info);
1908
1909 /*
1910  * Definitions of diskquota operations.
1911  */
1912 const struct dquot_operations dquot_operations = {
1913         .write_dquot    = dquot_commit,
1914         .acquire_dquot  = dquot_acquire,
1915         .release_dquot  = dquot_release,
1916         .mark_dirty     = dquot_mark_dquot_dirty,
1917         .write_info     = dquot_commit_info,
1918         .alloc_dquot    = dquot_alloc,
1919         .destroy_dquot  = dquot_destroy,
1920 };
1921 EXPORT_SYMBOL(dquot_operations);
1922
1923 /*
1924  * Generic helper for ->open on filesystems supporting disk quotas.
1925  */
1926 int dquot_file_open(struct inode *inode, struct file *file)
1927 {
1928         int error;
1929
1930         error = generic_file_open(inode, file);
1931         if (!error && (file->f_mode & FMODE_WRITE))
1932                 dquot_initialize(inode);
1933         return error;
1934 }
1935 EXPORT_SYMBOL(dquot_file_open);
1936
1937 /*
1938  * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
1939  */
1940 int dquot_disable(struct super_block *sb, int type, unsigned int flags)
1941 {
1942         int cnt, ret = 0;
1943         struct quota_info *dqopt = sb_dqopt(sb);
1944         struct inode *toputinode[MAXQUOTAS];
1945
1946         /* Cannot turn off usage accounting without turning off limits, or
1947          * suspend quotas and simultaneously turn quotas off. */
1948         if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
1949             || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
1950             DQUOT_USAGE_ENABLED)))
1951                 return -EINVAL;
1952
1953         /* We need to serialize quota_off() for device */
1954         mutex_lock(&dqopt->dqonoff_mutex);
1955
1956         /*
1957          * Skip everything if there's nothing to do. We have to do this because
1958          * sometimes we are called when fill_super() failed and calling
1959          * sync_fs() in such cases does no good.
1960          */
1961         if (!sb_any_quota_loaded(sb)) {
1962                 mutex_unlock(&dqopt->dqonoff_mutex);
1963                 return 0;
1964         }
1965         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1966                 toputinode[cnt] = NULL;
1967                 if (type != -1 && cnt != type)
1968                         continue;
1969                 if (!sb_has_quota_loaded(sb, cnt))
1970                         continue;
1971
1972                 if (flags & DQUOT_SUSPENDED) {
1973                         spin_lock(&dq_state_lock);
1974                         dqopt->flags |=
1975                                 dquot_state_flag(DQUOT_SUSPENDED, cnt);
1976                         spin_unlock(&dq_state_lock);
1977                 } else {
1978                         spin_lock(&dq_state_lock);
1979                         dqopt->flags &= ~dquot_state_flag(flags, cnt);
1980                         /* Turning off suspended quotas? */
1981                         if (!sb_has_quota_loaded(sb, cnt) &&
1982                             sb_has_quota_suspended(sb, cnt)) {
1983                                 dqopt->flags &= ~dquot_state_flag(
1984                                                         DQUOT_SUSPENDED, cnt);
1985                                 spin_unlock(&dq_state_lock);
1986                                 iput(dqopt->files[cnt]);
1987                                 dqopt->files[cnt] = NULL;
1988                                 continue;
1989                         }
1990                         spin_unlock(&dq_state_lock);
1991                 }
1992
1993                 /* We still have to keep quota loaded? */
1994                 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
1995                         continue;
1996
1997                 /* Note: these are blocking operations */
1998                 drop_dquot_ref(sb, cnt);
1999                 invalidate_dquots(sb, cnt);
2000                 /*
2001                  * Now all dquots should be invalidated, all writes done so we
2002                  * should be only users of the info. No locks needed.
2003                  */
2004                 if (info_dirty(&dqopt->info[cnt]))
2005                         sb->dq_op->write_info(sb, cnt);
2006                 if (dqopt->ops[cnt]->free_file_info)
2007                         dqopt->ops[cnt]->free_file_info(sb, cnt);
2008                 put_quota_format(dqopt->info[cnt].dqi_format);
2009
2010                 toputinode[cnt] = dqopt->files[cnt];
2011                 if (!sb_has_quota_loaded(sb, cnt))
2012                         dqopt->files[cnt] = NULL;
2013                 dqopt->info[cnt].dqi_flags = 0;
2014                 dqopt->info[cnt].dqi_igrace = 0;
2015                 dqopt->info[cnt].dqi_bgrace = 0;
2016                 dqopt->ops[cnt] = NULL;
2017         }
2018         mutex_unlock(&dqopt->dqonoff_mutex);
2019
2020         /* Skip syncing and setting flags if quota files are hidden */
2021         if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2022                 goto put_inodes;
2023
2024         /* Sync the superblock so that buffers with quota data are written to
2025          * disk (and so userspace sees correct data afterwards). */
2026         if (sb->s_op->sync_fs)
2027                 sb->s_op->sync_fs(sb, 1);
2028         sync_blockdev(sb->s_bdev);
2029         /* Now the quota files are just ordinary files and we can set the
2030          * inode flags back. Moreover we discard the pagecache so that
2031          * userspace sees the writes we did bypassing the pagecache. We
2032          * must also discard the blockdev buffers so that we see the
2033          * changes done by userspace on the next quotaon() */
2034         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2035                 if (toputinode[cnt]) {
2036                         mutex_lock(&dqopt->dqonoff_mutex);
2037                         /* If quota was reenabled in the meantime, we have
2038                          * nothing to do */
2039                         if (!sb_has_quota_loaded(sb, cnt)) {
2040                                 mutex_lock_nested(&toputinode[cnt]->i_mutex,
2041                                                   I_MUTEX_QUOTA);
2042                                 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
2043                                   S_NOATIME | S_NOQUOTA);
2044                                 truncate_inode_pages(&toputinode[cnt]->i_data,
2045                                                      0);
2046                                 mutex_unlock(&toputinode[cnt]->i_mutex);
2047                                 mark_inode_dirty_sync(toputinode[cnt]);
2048                         }
2049                         mutex_unlock(&dqopt->dqonoff_mutex);
2050                 }
2051         if (sb->s_bdev)
2052                 invalidate_bdev(sb->s_bdev);
2053 put_inodes:
2054         for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2055                 if (toputinode[cnt]) {
2056                         /* On remount RO, we keep the inode pointer so that we
2057                          * can reenable quota on the subsequent remount RW. We
2058                          * have to check 'flags' variable and not use sb_has_
2059                          * function because another quotaon / quotaoff could
2060                          * change global state before we got here. We refuse
2061                          * to suspend quotas when there is pending delete on
2062                          * the quota file... */
2063                         if (!(flags & DQUOT_SUSPENDED))
2064                                 iput(toputinode[cnt]);
2065                         else if (!toputinode[cnt]->i_nlink)
2066                                 ret = -EBUSY;
2067                 }
2068         return ret;
2069 }
2070 EXPORT_SYMBOL(dquot_disable);
2071
2072 int dquot_quota_off(struct super_block *sb, int type)
2073 {
2074         return dquot_disable(sb, type,
2075                              DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2076 }
2077 EXPORT_SYMBOL(dquot_quota_off);
2078
2079 /*
2080  *      Turn quotas on on a device
2081  */
2082
2083 /*
2084  * Helper function to turn quotas on when we already have the inode of
2085  * quota file and no quota information is loaded.
2086  */
2087 static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2088         unsigned int flags)
2089 {
2090         struct quota_format_type *fmt = find_quota_format(format_id);
2091         struct super_block *sb = inode->i_sb;
2092         struct quota_info *dqopt = sb_dqopt(sb);
2093         int error;
2094         int oldflags = -1;
2095
2096         if (!fmt)
2097                 return -ESRCH;
2098         if (!S_ISREG(inode->i_mode)) {
2099                 error = -EACCES;
2100                 goto out_fmt;
2101         }
2102         if (IS_RDONLY(inode)) {
2103                 error = -EROFS;
2104                 goto out_fmt;
2105         }
2106         if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
2107                 error = -EINVAL;
2108                 goto out_fmt;
2109         }
2110         /* Usage always has to be set... */
2111         if (!(flags & DQUOT_USAGE_ENABLED)) {
2112                 error = -EINVAL;
2113                 goto out_fmt;
2114         }
2115
2116         if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2117                 /* As we bypass the pagecache we must now flush all the
2118                  * dirty data and invalidate caches so that kernel sees
2119                  * changes from userspace. It is not enough to just flush
2120                  * the quota file since if blocksize < pagesize, invalidation
2121                  * of the cache could fail because of other unrelated dirty
2122                  * data */
2123                 sync_filesystem(sb);
2124                 invalidate_bdev(sb->s_bdev);
2125         }
2126         mutex_lock(&dqopt->dqonoff_mutex);
2127         if (sb_has_quota_loaded(sb, type)) {
2128                 error = -EBUSY;
2129                 goto out_lock;
2130         }
2131
2132         if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2133                 /* We don't want quota and atime on quota files (deadlocks
2134                  * possible) Also nobody should write to the file - we use
2135                  * special IO operations which ignore the immutable bit. */
2136                 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
2137                 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2138                                              S_NOQUOTA);
2139                 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
2140                 mutex_unlock(&inode->i_mutex);
2141                 /*
2142                  * When S_NOQUOTA is set, remove dquot references as no more
2143                  * references can be added
2144                  */
2145                 __dquot_drop(inode);
2146         }
2147
2148         error = -EIO;
2149         dqopt->files[type] = igrab(inode);
2150         if (!dqopt->files[type])
2151                 goto out_lock;
2152         error = -EINVAL;
2153         if (!fmt->qf_ops->check_quota_file(sb, type))
2154                 goto out_file_init;
2155
2156         dqopt->ops[type] = fmt->qf_ops;
2157         dqopt->info[type].dqi_format = fmt;
2158         dqopt->info[type].dqi_fmt_id = format_id;
2159         INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
2160         mutex_lock(&dqopt->dqio_mutex);
2161         error = dqopt->ops[type]->read_file_info(sb, type);
2162         if (error < 0) {
2163                 mutex_unlock(&dqopt->dqio_mutex);
2164                 goto out_file_init;
2165         }
2166         if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2167                 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
2168         mutex_unlock(&dqopt->dqio_mutex);
2169         spin_lock(&dq_state_lock);
2170         dqopt->flags |= dquot_state_flag(flags, type);
2171         spin_unlock(&dq_state_lock);
2172
2173         add_dquot_ref(sb, type);
2174         mutex_unlock(&dqopt->dqonoff_mutex);
2175
2176         return 0;
2177
2178 out_file_init:
2179         dqopt->files[type] = NULL;
2180         iput(inode);
2181 out_lock:
2182         if (oldflags != -1) {
2183                 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
2184                 /* Set the flags back (in the case of accidental quotaon()
2185                  * on a wrong file we don't want to mess up the flags) */
2186                 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2187                 inode->i_flags |= oldflags;
2188                 mutex_unlock(&inode->i_mutex);
2189         }
2190         mutex_unlock(&dqopt->dqonoff_mutex);
2191 out_fmt:
2192         put_quota_format(fmt);
2193
2194         return error; 
2195 }
2196
2197 /* Reenable quotas on remount RW */
2198 int dquot_resume(struct super_block *sb, int type)
2199 {
2200         struct quota_info *dqopt = sb_dqopt(sb);
2201         struct inode *inode;
2202         int ret = 0, cnt;
2203         unsigned int flags;
2204
2205         for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2206                 if (type != -1 && cnt != type)
2207                         continue;
2208
2209                 mutex_lock(&dqopt->dqonoff_mutex);
2210                 if (!sb_has_quota_suspended(sb, cnt)) {
2211                         mutex_unlock(&dqopt->dqonoff_mutex);
2212                         continue;
2213                 }
2214                 inode = dqopt->files[cnt];
2215                 dqopt->files[cnt] = NULL;
2216                 spin_lock(&dq_state_lock);
2217                 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2218                                                         DQUOT_LIMITS_ENABLED,
2219                                                         cnt);
2220                 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2221                 spin_unlock(&dq_state_lock);
2222                 mutex_unlock(&dqopt->dqonoff_mutex);
2223
2224                 flags = dquot_generic_flag(flags, cnt);
2225                 ret = vfs_load_quota_inode(inode, cnt,
2226                                 dqopt->info[cnt].dqi_fmt_id, flags);
2227                 iput(inode);
2228         }
2229
2230         return ret;
2231 }
2232 EXPORT_SYMBOL(dquot_resume);
2233
2234 int dquot_quota_on(struct super_block *sb, int type, int format_id,
2235                    struct path *path)
2236 {
2237         int error = security_quota_on(path->dentry);
2238         if (error)
2239                 return error;
2240         /* Quota file not on the same filesystem? */
2241         if (path->dentry->d_sb != sb)
2242                 error = -EXDEV;
2243         else
2244                 error = vfs_load_quota_inode(path->dentry->d_inode, type,
2245                                              format_id, DQUOT_USAGE_ENABLED |
2246                                              DQUOT_LIMITS_ENABLED);
2247         return error;
2248 }
2249 EXPORT_SYMBOL(dquot_quota_on);
2250
2251 /*
2252  * More powerful function for turning on quotas allowing setting
2253  * of individual quota flags
2254  */
2255 int dquot_enable(struct inode *inode, int type, int format_id,
2256                  unsigned int flags)
2257 {
2258         int ret = 0;
2259         struct super_block *sb = inode->i_sb;
2260         struct quota_info *dqopt = sb_dqopt(sb);
2261
2262         /* Just unsuspend quotas? */
2263         BUG_ON(flags & DQUOT_SUSPENDED);
2264
2265         if (!flags)
2266                 return 0;
2267         /* Just updating flags needed? */
2268         if (sb_has_quota_loaded(sb, type)) {
2269                 mutex_lock(&dqopt->dqonoff_mutex);
2270                 /* Now do a reliable test... */
2271                 if (!sb_has_quota_loaded(sb, type)) {
2272                         mutex_unlock(&dqopt->dqonoff_mutex);
2273                         goto load_quota;
2274                 }
2275                 if (flags & DQUOT_USAGE_ENABLED &&
2276                     sb_has_quota_usage_enabled(sb, type)) {
2277                         ret = -EBUSY;
2278                         goto out_lock;
2279                 }
2280                 if (flags & DQUOT_LIMITS_ENABLED &&
2281                     sb_has_quota_limits_enabled(sb, type)) {
2282                         ret = -EBUSY;
2283                         goto out_lock;
2284                 }
2285                 spin_lock(&dq_state_lock);
2286                 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
2287                 spin_unlock(&dq_state_lock);
2288 out_lock:
2289                 mutex_unlock(&dqopt->dqonoff_mutex);
2290                 return ret;
2291         }
2292
2293 load_quota:
2294         return vfs_load_quota_inode(inode, type, format_id, flags);
2295 }
2296 EXPORT_SYMBOL(dquot_enable);
2297
2298 /*
2299  * This function is used when filesystem needs to initialize quotas
2300  * during mount time.
2301  */
2302 int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
2303                 int format_id, int type)
2304 {
2305         struct dentry *dentry;
2306         int error;
2307
2308         mutex_lock(&sb->s_root->d_inode->i_mutex);
2309         dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
2310         mutex_unlock(&sb->s_root->d_inode->i_mutex);
2311         if (IS_ERR(dentry))
2312                 return PTR_ERR(dentry);
2313
2314         if (!dentry->d_inode) {
2315                 error = -ENOENT;
2316                 goto out;
2317         }
2318
2319         error = security_quota_on(dentry);
2320         if (!error)
2321                 error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
2322                                 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2323
2324 out:
2325         dput(dentry);
2326         return error;
2327 }
2328 EXPORT_SYMBOL(dquot_quota_on_mount);
2329
2330 static inline qsize_t qbtos(qsize_t blocks)
2331 {
2332         return blocks << QIF_DQBLKSIZE_BITS;
2333 }
2334
2335 static inline qsize_t stoqb(qsize_t space)
2336 {
2337         return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
2338 }
2339
2340 /* Generic routine for getting common part of quota structure */
2341 static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
2342 {
2343         struct mem_dqblk *dm = &dquot->dq_dqb;
2344
2345         memset(di, 0, sizeof(*di));
2346         di->d_version = FS_DQUOT_VERSION;
2347         di->d_flags = dquot->dq_type == USRQUOTA ?
2348                         FS_USER_QUOTA : FS_GROUP_QUOTA;
2349         di->d_id = dquot->dq_id;
2350
2351         spin_lock(&dq_data_lock);
2352         di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
2353         di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
2354         di->d_ino_hardlimit = dm->dqb_ihardlimit;
2355         di->d_ino_softlimit = dm->dqb_isoftlimit;
2356         di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
2357         di->d_icount = dm->dqb_curinodes;
2358         di->d_btimer = dm->dqb_btime;
2359         di->d_itimer = dm->dqb_itime;
2360         spin_unlock(&dq_data_lock);
2361 }
2362
2363 int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
2364                     struct fs_disk_quota *di)
2365 {
2366         struct dquot *dquot;
2367
2368         dquot = dqget(sb, id, type);
2369         if (!dquot)
2370                 return -ESRCH;
2371         do_get_dqblk(dquot, di);
2372         dqput(dquot);
2373
2374         return 0;
2375 }
2376 EXPORT_SYMBOL(dquot_get_dqblk);
2377
2378 #define VFS_FS_DQ_MASK \
2379         (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
2380          FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
2381          FS_DQ_BTIMER | FS_DQ_ITIMER)
2382
2383 /* Generic routine for setting common part of quota structure */
2384 static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
2385 {
2386         struct mem_dqblk *dm = &dquot->dq_dqb;
2387         int check_blim = 0, check_ilim = 0;
2388         struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];
2389
2390         if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
2391                 return -EINVAL;
2392
2393         if (((di->d_fieldmask & FS_DQ_BSOFT) &&
2394              (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
2395             ((di->d_fieldmask & FS_DQ_BHARD) &&
2396              (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
2397             ((di->d_fieldmask & FS_DQ_ISOFT) &&
2398              (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
2399             ((di->d_fieldmask & FS_DQ_IHARD) &&
2400              (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
2401                 return -ERANGE;
2402
2403         spin_lock(&dq_data_lock);
2404         if (di->d_fieldmask & FS_DQ_BCOUNT) {
2405                 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
2406                 check_blim = 1;
2407                 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
2408         }
2409
2410         if (di->d_fieldmask & FS_DQ_BSOFT)
2411                 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
2412         if (di->d_fieldmask & FS_DQ_BHARD)
2413                 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
2414         if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
2415                 check_blim = 1;
2416                 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
2417         }
2418
2419         if (di->d_fieldmask & FS_DQ_ICOUNT) {
2420                 dm->dqb_curinodes = di->d_icount;
2421                 check_ilim = 1;
2422                 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
2423         }
2424
2425         if (di->d_fieldmask & FS_DQ_ISOFT)
2426                 dm->dqb_isoftlimit = di->d_ino_softlimit;
2427         if (di->d_fieldmask & FS_DQ_IHARD)
2428                 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2429         if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
2430                 check_ilim = 1;
2431                 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
2432         }
2433
2434         if (di->d_fieldmask & FS_DQ_BTIMER) {
2435                 dm->dqb_btime = di->d_btimer;
2436                 check_blim = 1;
2437                 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
2438         }
2439
2440         if (di->d_fieldmask & FS_DQ_ITIMER) {
2441                 dm->dqb_itime = di->d_itimer;
2442                 check_ilim = 1;
2443                 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
2444         }
2445
2446         if (check_blim) {
2447                 if (!dm->dqb_bsoftlimit ||
2448                     dm->dqb_curspace < dm->dqb_bsoftlimit) {
2449                         dm->dqb_btime = 0;
2450                         clear_bit(DQ_BLKS_B, &dquot->dq_flags);
2451                 } else if (!(di->d_fieldmask & FS_DQ_BTIMER))
2452                         /* Set grace only if user hasn't provided his own... */
2453                         dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
2454         }
2455         if (check_ilim) {
2456                 if (!dm->dqb_isoftlimit ||
2457                     dm->dqb_curinodes < dm->dqb_isoftlimit) {
2458                         dm->dqb_itime = 0;
2459                         clear_bit(DQ_INODES_B, &dquot->dq_flags);
2460                 } else if (!(di->d_fieldmask & FS_DQ_ITIMER))
2461                         /* Set grace only if user hasn't provided his own... */
2462                         dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
2463         }
2464         if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2465             dm->dqb_isoftlimit)
2466                 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2467         else
2468                 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2469         spin_unlock(&dq_data_lock);
2470         mark_dquot_dirty(dquot);
2471
2472         return 0;
2473 }
2474
2475 int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
2476                   struct fs_disk_quota *di)
2477 {
2478         struct dquot *dquot;
2479         int rc;
2480
2481         dquot = dqget(sb, id, type);
2482         if (!dquot) {
2483                 rc = -ESRCH;
2484                 goto out;
2485         }
2486         rc = do_set_dqblk(dquot, di);
2487         dqput(dquot);
2488 out:
2489         return rc;
2490 }
2491 EXPORT_SYMBOL(dquot_set_dqblk);
2492
2493 /* Generic routine for getting common part of quota file information */
2494 int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
2495 {
2496         struct mem_dqinfo *mi;
2497   
2498         mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2499         if (!sb_has_quota_active(sb, type)) {
2500                 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2501                 return -ESRCH;
2502         }
2503         mi = sb_dqopt(sb)->info + type;
2504         spin_lock(&dq_data_lock);
2505         ii->dqi_bgrace = mi->dqi_bgrace;
2506         ii->dqi_igrace = mi->dqi_igrace;
2507         ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK;
2508         ii->dqi_valid = IIF_ALL;
2509         spin_unlock(&dq_data_lock);
2510         mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2511         return 0;
2512 }
2513 EXPORT_SYMBOL(dquot_get_dqinfo);
2514
2515 /* Generic routine for setting common part of quota file information */
2516 int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
2517 {
2518         struct mem_dqinfo *mi;
2519         int err = 0;
2520
2521         mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2522         if (!sb_has_quota_active(sb, type)) {
2523                 err = -ESRCH;
2524                 goto out;
2525         }
2526         mi = sb_dqopt(sb)->info + type;
2527         spin_lock(&dq_data_lock);
2528         if (ii->dqi_valid & IIF_BGRACE)
2529                 mi->dqi_bgrace = ii->dqi_bgrace;
2530         if (ii->dqi_valid & IIF_IGRACE)
2531                 mi->dqi_igrace = ii->dqi_igrace;
2532         if (ii->dqi_valid & IIF_FLAGS)
2533                 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) |
2534                                 (ii->dqi_flags & DQF_SETINFO_MASK);
2535         spin_unlock(&dq_data_lock);
2536         mark_info_dirty(sb, type);
2537         /* Force write to disk */
2538         sb->dq_op->write_info(sb, type);
2539 out:
2540         mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2541         return err;
2542 }
2543 EXPORT_SYMBOL(dquot_set_dqinfo);
2544
2545 const struct quotactl_ops dquot_quotactl_ops = {
2546         .quota_on       = dquot_quota_on,
2547         .quota_off      = dquot_quota_off,
2548         .quota_sync     = dquot_quota_sync,
2549         .get_info       = dquot_get_dqinfo,
2550         .set_info       = dquot_set_dqinfo,
2551         .get_dqblk      = dquot_get_dqblk,
2552         .set_dqblk      = dquot_set_dqblk
2553 };
2554 EXPORT_SYMBOL(dquot_quotactl_ops);
2555
2556 static int do_proc_dqstats(struct ctl_table *table, int write,
2557                      void __user *buffer, size_t *lenp, loff_t *ppos)
2558 {
2559         unsigned int type = (int *)table->data - dqstats.stat;
2560
2561         /* Update global table */
2562         dqstats.stat[type] =
2563                         percpu_counter_sum_positive(&dqstats.counter[type]);
2564         return proc_dointvec(table, write, buffer, lenp, ppos);
2565 }
2566
2567 static ctl_table fs_dqstats_table[] = {
2568         {
2569                 .procname       = "lookups",
2570                 .data           = &dqstats.stat[DQST_LOOKUPS],
2571                 .maxlen         = sizeof(int),
2572                 .mode           = 0444,
2573                 .proc_handler   = do_proc_dqstats,
2574         },
2575         {
2576                 .procname       = "drops",
2577                 .data           = &dqstats.stat[DQST_DROPS],
2578                 .maxlen         = sizeof(int),
2579                 .mode           = 0444,
2580                 .proc_handler   = do_proc_dqstats,
2581         },
2582         {
2583                 .procname       = "reads",
2584                 .data           = &dqstats.stat[DQST_READS],
2585                 .maxlen         = sizeof(int),
2586                 .mode           = 0444,
2587                 .proc_handler   = do_proc_dqstats,
2588         },
2589         {
2590                 .procname       = "writes",
2591                 .data           = &dqstats.stat[DQST_WRITES],
2592                 .maxlen         = sizeof(int),
2593                 .mode           = 0444,
2594                 .proc_handler   = do_proc_dqstats,
2595         },
2596         {
2597                 .procname       = "cache_hits",
2598                 .data           = &dqstats.stat[DQST_CACHE_HITS],
2599                 .maxlen         = sizeof(int),
2600                 .mode           = 0444,
2601                 .proc_handler   = do_proc_dqstats,
2602         },
2603         {
2604                 .procname       = "allocated_dquots",
2605                 .data           = &dqstats.stat[DQST_ALLOC_DQUOTS],
2606                 .maxlen         = sizeof(int),
2607                 .mode           = 0444,
2608                 .proc_handler   = do_proc_dqstats,
2609         },
2610         {
2611                 .procname       = "free_dquots",
2612                 .data           = &dqstats.stat[DQST_FREE_DQUOTS],
2613                 .maxlen         = sizeof(int),
2614                 .mode           = 0444,
2615                 .proc_handler   = do_proc_dqstats,
2616         },
2617         {
2618                 .procname       = "syncs",
2619                 .data           = &dqstats.stat[DQST_SYNCS],
2620                 .maxlen         = sizeof(int),
2621                 .mode           = 0444,
2622                 .proc_handler   = do_proc_dqstats,
2623         },
2624 #ifdef CONFIG_PRINT_QUOTA_WARNING
2625         {
2626                 .procname       = "warnings",
2627                 .data           = &flag_print_warnings,
2628                 .maxlen         = sizeof(int),
2629                 .mode           = 0644,
2630                 .proc_handler   = proc_dointvec,
2631         },
2632 #endif
2633         { },
2634 };
2635
2636 static ctl_table fs_table[] = {
2637         {
2638                 .procname       = "quota",
2639                 .mode           = 0555,
2640                 .child          = fs_dqstats_table,
2641         },
2642         { },
2643 };
2644
2645 static ctl_table sys_table[] = {
2646         {
2647                 .procname       = "fs",
2648                 .mode           = 0555,
2649                 .child          = fs_table,
2650         },
2651         { },
2652 };
2653
2654 static int __init dquot_init(void)
2655 {
2656         int i, ret;
2657         unsigned long nr_hash, order;
2658
2659         printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2660
2661         register_sysctl_table(sys_table);
2662
2663         dquot_cachep = kmem_cache_create("dquot",
2664                         sizeof(struct dquot), sizeof(unsigned long) * 4,
2665                         (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2666                                 SLAB_MEM_SPREAD|SLAB_PANIC),
2667                         NULL);
2668
2669         order = 0;
2670         dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2671         if (!dquot_hash)
2672                 panic("Cannot create dquot hash table");
2673
2674         for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2675                 ret = percpu_counter_init(&dqstats.counter[i], 0);
2676                 if (ret)
2677                         panic("Cannot create dquot stat counters");
2678         }
2679
2680         /* Find power-of-two hlist_heads which can fit into allocation */
2681         nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2682         dq_hash_bits = 0;
2683         do {
2684                 dq_hash_bits++;
2685         } while (nr_hash >> dq_hash_bits);
2686         dq_hash_bits--;
2687
2688         nr_hash = 1UL << dq_hash_bits;
2689         dq_hash_mask = nr_hash - 1;
2690         for (i = 0; i < nr_hash; i++)
2691                 INIT_HLIST_HEAD(dquot_hash + i);
2692
2693         printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2694                         nr_hash, order, (PAGE_SIZE << order));
2695
2696         register_shrinker(&dqcache_shrinker);
2697
2698         return 0;
2699 }
2700 module_init(dquot_init);