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