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