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