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 dquot_resv_space(inode->i_dquot[cnt], rsv);
1444 }
1445 }
1446out_err:
1447 up_write(&sb_dqopt(sb)->dqptr_sem);
1448
1449 dqput_all(got);
1450}
1451
1452void dquot_initialize(struct inode *inode)
1453{
1454 __dquot_initialize(inode, -1);
1455}
1456EXPORT_SYMBOL(dquot_initialize);
1457
1458
1459
1460
1461static void __dquot_drop(struct inode *inode)
1462{
1463 int cnt;
1464 struct dquot *put[MAXQUOTAS];
1465
1466 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1467 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1468 put[cnt] = inode->i_dquot[cnt];
1469 inode->i_dquot[cnt] = NULL;
1470 }
1471 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1472 dqput_all(put);
1473}
1474
1475void dquot_drop(struct inode *inode)
1476{
1477 int cnt;
1478
1479 if (IS_NOQUOTA(inode))
1480 return;
1481
1482
1483
1484
1485
1486
1487
1488
1489 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1490 if (inode->i_dquot[cnt])
1491 break;
1492 }
1493
1494 if (cnt < MAXQUOTAS)
1495 __dquot_drop(inode);
1496}
1497EXPORT_SYMBOL(dquot_drop);
1498
1499
1500
1501
1502
1503static qsize_t *inode_reserved_space(struct inode * inode)
1504{
1505
1506
1507 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1508 return inode->i_sb->dq_op->get_reserved_space(inode);
1509}
1510
1511void inode_add_rsv_space(struct inode *inode, qsize_t number)
1512{
1513 spin_lock(&inode->i_lock);
1514 *inode_reserved_space(inode) += number;
1515 spin_unlock(&inode->i_lock);
1516}
1517EXPORT_SYMBOL(inode_add_rsv_space);
1518
1519void inode_claim_rsv_space(struct inode *inode, qsize_t number)
1520{
1521 spin_lock(&inode->i_lock);
1522 *inode_reserved_space(inode) -= number;
1523 __inode_add_bytes(inode, number);
1524 spin_unlock(&inode->i_lock);
1525}
1526EXPORT_SYMBOL(inode_claim_rsv_space);
1527
1528void inode_sub_rsv_space(struct inode *inode, qsize_t number)
1529{
1530 spin_lock(&inode->i_lock);
1531 *inode_reserved_space(inode) -= number;
1532 spin_unlock(&inode->i_lock);
1533}
1534EXPORT_SYMBOL(inode_sub_rsv_space);
1535
1536static qsize_t inode_get_rsv_space(struct inode *inode)
1537{
1538 qsize_t ret;
1539
1540 if (!inode->i_sb->dq_op->get_reserved_space)
1541 return 0;
1542 spin_lock(&inode->i_lock);
1543 ret = *inode_reserved_space(inode);
1544 spin_unlock(&inode->i_lock);
1545 return ret;
1546}
1547
1548static void inode_incr_space(struct inode *inode, qsize_t number,
1549 int reserve)
1550{
1551 if (reserve)
1552 inode_add_rsv_space(inode, number);
1553 else
1554 inode_add_bytes(inode, number);
1555}
1556
1557static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1558{
1559 if (reserve)
1560 inode_sub_rsv_space(inode, number);
1561 else
1562 inode_sub_bytes(inode, number);
1563}
1564
1565
1566
1567
1568
1569
1570
1571
1572
1573
1574
1575
1576
1577
1578int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
1579{
1580 int cnt, ret = 0;
1581 struct dquot_warn warn[MAXQUOTAS];
1582 struct dquot **dquots = inode->i_dquot;
1583 int reserve = flags & DQUOT_SPACE_RESERVE;
1584
1585
1586
1587
1588
1589 if (!dquot_active(inode)) {
1590 inode_incr_space(inode, number, reserve);
1591 goto out;
1592 }
1593
1594 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1595 warn[cnt].w_type = QUOTA_NL_NOWARN;
1596
1597 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1598 spin_lock(&dq_data_lock);
1599 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1600 if (!dquots[cnt])
1601 continue;
1602 ret = check_bdq(dquots[cnt], number,
1603 !(flags & DQUOT_SPACE_WARN), &warn[cnt]);
1604 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
1605 spin_unlock(&dq_data_lock);
1606 goto out_flush_warn;
1607 }
1608 }
1609 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1610 if (!dquots[cnt])
1611 continue;
1612 if (reserve)
1613 dquot_resv_space(dquots[cnt], number);
1614 else
1615 dquot_incr_space(dquots[cnt], number);
1616 }
1617 inode_incr_space(inode, number, reserve);
1618 spin_unlock(&dq_data_lock);
1619
1620 if (reserve)
1621 goto out_flush_warn;
1622 mark_all_dquot_dirty(dquots);
1623out_flush_warn:
1624 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1625 flush_warnings(warn);
1626out:
1627 return ret;
1628}
1629EXPORT_SYMBOL(__dquot_alloc_space);
1630
1631
1632
1633
1634int dquot_alloc_inode(const struct inode *inode)
1635{
1636 int cnt, ret = 0;
1637 struct dquot_warn warn[MAXQUOTAS];
1638 struct dquot * const *dquots = inode->i_dquot;
1639
1640
1641
1642 if (!dquot_active(inode))
1643 return 0;
1644 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1645 warn[cnt].w_type = QUOTA_NL_NOWARN;
1646 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1647 spin_lock(&dq_data_lock);
1648 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1649 if (!dquots[cnt])
1650 continue;
1651 ret = check_idq(dquots[cnt], 1, &warn[cnt]);
1652 if (ret)
1653 goto warn_put_all;
1654 }
1655
1656 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1657 if (!dquots[cnt])
1658 continue;
1659 dquot_incr_inodes(dquots[cnt], 1);
1660 }
1661
1662warn_put_all:
1663 spin_unlock(&dq_data_lock);
1664 if (ret == 0)
1665 mark_all_dquot_dirty(dquots);
1666 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1667 flush_warnings(warn);
1668 return ret;
1669}
1670EXPORT_SYMBOL(dquot_alloc_inode);
1671
1672
1673
1674
1675int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1676{
1677 int cnt;
1678
1679 if (!dquot_active(inode)) {
1680 inode_claim_rsv_space(inode, number);
1681 return 0;
1682 }
1683
1684 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1685 spin_lock(&dq_data_lock);
1686
1687 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1688 if (inode->i_dquot[cnt])
1689 dquot_claim_reserved_space(inode->i_dquot[cnt],
1690 number);
1691 }
1692
1693 inode_claim_rsv_space(inode, number);
1694 spin_unlock(&dq_data_lock);
1695 mark_all_dquot_dirty(inode->i_dquot);
1696 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1697 return 0;
1698}
1699EXPORT_SYMBOL(dquot_claim_space_nodirty);
1700
1701
1702
1703
1704void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
1705{
1706 unsigned int cnt;
1707 struct dquot_warn warn[MAXQUOTAS];
1708 struct dquot **dquots = inode->i_dquot;
1709 int reserve = flags & DQUOT_SPACE_RESERVE;
1710
1711
1712
1713 if (!dquot_active(inode)) {
1714 inode_decr_space(inode, number, reserve);
1715 return;
1716 }
1717
1718 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1719 spin_lock(&dq_data_lock);
1720 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1721 int wtype;
1722
1723 warn[cnt].w_type = QUOTA_NL_NOWARN;
1724 if (!dquots[cnt])
1725 continue;
1726 wtype = info_bdq_free(dquots[cnt], number);
1727 if (wtype != QUOTA_NL_NOWARN)
1728 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1729 if (reserve)
1730 dquot_free_reserved_space(dquots[cnt], number);
1731 else
1732 dquot_decr_space(dquots[cnt], number);
1733 }
1734 inode_decr_space(inode, number, reserve);
1735 spin_unlock(&dq_data_lock);
1736
1737 if (reserve)
1738 goto out_unlock;
1739 mark_all_dquot_dirty(dquots);
1740out_unlock:
1741 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1742 flush_warnings(warn);
1743}
1744EXPORT_SYMBOL(__dquot_free_space);
1745
1746
1747
1748
1749void dquot_free_inode(const struct inode *inode)
1750{
1751 unsigned int cnt;
1752 struct dquot_warn warn[MAXQUOTAS];
1753 struct dquot * const *dquots = inode->i_dquot;
1754
1755
1756
1757 if (!dquot_active(inode))
1758 return;
1759
1760 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1761 spin_lock(&dq_data_lock);
1762 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1763 int wtype;
1764
1765 warn[cnt].w_type = QUOTA_NL_NOWARN;
1766 if (!dquots[cnt])
1767 continue;
1768 wtype = info_idq_free(dquots[cnt], 1);
1769 if (wtype != QUOTA_NL_NOWARN)
1770 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1771 dquot_decr_inodes(dquots[cnt], 1);
1772 }
1773 spin_unlock(&dq_data_lock);
1774 mark_all_dquot_dirty(dquots);
1775 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1776 flush_warnings(warn);
1777}
1778EXPORT_SYMBOL(dquot_free_inode);
1779
1780
1781
1782
1783
1784
1785
1786
1787
1788
1789
1790int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
1791{
1792 qsize_t space, cur_space;
1793 qsize_t rsv_space = 0;
1794 struct dquot *transfer_from[MAXQUOTAS] = {};
1795 int cnt, ret = 0;
1796 char is_valid[MAXQUOTAS] = {};
1797 struct dquot_warn warn_to[MAXQUOTAS];
1798 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1799 struct dquot_warn warn_from_space[MAXQUOTAS];
1800
1801
1802
1803 if (IS_NOQUOTA(inode))
1804 return 0;
1805
1806 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1807 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1808 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1809 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1810 }
1811 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1812 if (IS_NOQUOTA(inode)) {
1813 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1814 return 0;
1815 }
1816 spin_lock(&dq_data_lock);
1817 cur_space = inode_get_bytes(inode);
1818 rsv_space = inode_get_rsv_space(inode);
1819 space = cur_space + rsv_space;
1820
1821 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1822
1823
1824
1825 if (!transfer_to[cnt])
1826 continue;
1827
1828 if (!sb_has_quota_active(inode->i_sb, cnt))
1829 continue;
1830 is_valid[cnt] = 1;
1831 transfer_from[cnt] = inode->i_dquot[cnt];
1832 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]);
1833 if (ret)
1834 goto over_quota;
1835 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
1836 if (ret)
1837 goto over_quota;
1838 }
1839
1840
1841
1842
1843 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1844 if (!is_valid[cnt])
1845 continue;
1846
1847 if (transfer_from[cnt]) {
1848 int wtype;
1849 wtype = info_idq_free(transfer_from[cnt], 1);
1850 if (wtype != QUOTA_NL_NOWARN)
1851 prepare_warning(&warn_from_inodes[cnt],
1852 transfer_from[cnt], wtype);
1853 wtype = info_bdq_free(transfer_from[cnt], space);
1854 if (wtype != QUOTA_NL_NOWARN)
1855 prepare_warning(&warn_from_space[cnt],
1856 transfer_from[cnt], wtype);
1857 dquot_decr_inodes(transfer_from[cnt], 1);
1858 dquot_decr_space(transfer_from[cnt], cur_space);
1859 dquot_free_reserved_space(transfer_from[cnt],
1860 rsv_space);
1861 }
1862
1863 dquot_incr_inodes(transfer_to[cnt], 1);
1864 dquot_incr_space(transfer_to[cnt], cur_space);
1865 dquot_resv_space(transfer_to[cnt], rsv_space);
1866
1867 inode->i_dquot[cnt] = transfer_to[cnt];
1868 }
1869 spin_unlock(&dq_data_lock);
1870 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1871
1872 mark_all_dquot_dirty(transfer_from);
1873 mark_all_dquot_dirty(transfer_to);
1874 flush_warnings(warn_to);
1875 flush_warnings(warn_from_inodes);
1876 flush_warnings(warn_from_space);
1877
1878 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1879 if (is_valid[cnt])
1880 transfer_to[cnt] = transfer_from[cnt];
1881 return 0;
1882over_quota:
1883 spin_unlock(&dq_data_lock);
1884 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1885 flush_warnings(warn_to);
1886 return ret;
1887}
1888EXPORT_SYMBOL(__dquot_transfer);
1889
1890
1891
1892
1893int dquot_transfer(struct inode *inode, struct iattr *iattr)
1894{
1895 struct dquot *transfer_to[MAXQUOTAS] = {};
1896 struct super_block *sb = inode->i_sb;
1897 int ret;
1898
1899 if (!dquot_active(inode))
1900 return 0;
1901
1902 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid))
1903 transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(iattr->ia_uid));
1904 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))
1905 transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(iattr->ia_gid));
1906
1907 ret = __dquot_transfer(inode, transfer_to);
1908 dqput_all(transfer_to);
1909 return ret;
1910}
1911EXPORT_SYMBOL(dquot_transfer);
1912
1913
1914
1915
1916int dquot_commit_info(struct super_block *sb, int type)
1917{
1918 int ret;
1919 struct quota_info *dqopt = sb_dqopt(sb);
1920
1921 mutex_lock(&dqopt->dqio_mutex);
1922 ret = dqopt->ops[type]->write_file_info(sb, type);
1923 mutex_unlock(&dqopt->dqio_mutex);
1924 return ret;
1925}
1926EXPORT_SYMBOL(dquot_commit_info);
1927
1928
1929
1930
1931const struct dquot_operations dquot_operations = {
1932 .write_dquot = dquot_commit,
1933 .acquire_dquot = dquot_acquire,
1934 .release_dquot = dquot_release,
1935 .mark_dirty = dquot_mark_dquot_dirty,
1936 .write_info = dquot_commit_info,
1937 .alloc_dquot = dquot_alloc,
1938 .destroy_dquot = dquot_destroy,
1939};
1940EXPORT_SYMBOL(dquot_operations);
1941
1942
1943
1944
1945int dquot_file_open(struct inode *inode, struct file *file)
1946{
1947 int error;
1948
1949 error = generic_file_open(inode, file);
1950 if (!error && (file->f_mode & FMODE_WRITE))
1951 dquot_initialize(inode);
1952 return error;
1953}
1954EXPORT_SYMBOL(dquot_file_open);
1955
1956
1957
1958
1959int dquot_disable(struct super_block *sb, int type, unsigned int flags)
1960{
1961 int cnt, ret = 0;
1962 struct quota_info *dqopt = sb_dqopt(sb);
1963 struct inode *toputinode[MAXQUOTAS];
1964
1965
1966
1967 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
1968 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
1969 DQUOT_USAGE_ENABLED)))
1970 return -EINVAL;
1971
1972
1973 mutex_lock(&dqopt->dqonoff_mutex);
1974
1975
1976
1977
1978
1979
1980 if (!sb_any_quota_loaded(sb)) {
1981 mutex_unlock(&dqopt->dqonoff_mutex);
1982 return 0;
1983 }
1984 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1985 toputinode[cnt] = NULL;
1986 if (type != -1 && cnt != type)
1987 continue;
1988 if (!sb_has_quota_loaded(sb, cnt))
1989 continue;
1990
1991 if (flags & DQUOT_SUSPENDED) {
1992 spin_lock(&dq_state_lock);
1993 dqopt->flags |=
1994 dquot_state_flag(DQUOT_SUSPENDED, cnt);
1995 spin_unlock(&dq_state_lock);
1996 } else {
1997 spin_lock(&dq_state_lock);
1998 dqopt->flags &= ~dquot_state_flag(flags, cnt);
1999
2000 if (!sb_has_quota_loaded(sb, cnt) &&
2001 sb_has_quota_suspended(sb, cnt)) {
2002 dqopt->flags &= ~dquot_state_flag(
2003 DQUOT_SUSPENDED, cnt);
2004 spin_unlock(&dq_state_lock);
2005 iput(dqopt->files[cnt]);
2006 dqopt->files[cnt] = NULL;
2007 continue;
2008 }
2009 spin_unlock(&dq_state_lock);
2010 }
2011
2012
2013 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
2014 continue;
2015
2016
2017 drop_dquot_ref(sb, cnt);
2018 invalidate_dquots(sb, cnt);
2019
2020
2021
2022
2023 if (info_dirty(&dqopt->info[cnt]))
2024 sb->dq_op->write_info(sb, cnt);
2025 if (dqopt->ops[cnt]->free_file_info)
2026 dqopt->ops[cnt]->free_file_info(sb, cnt);
2027 put_quota_format(dqopt->info[cnt].dqi_format);
2028
2029 toputinode[cnt] = dqopt->files[cnt];
2030 if (!sb_has_quota_loaded(sb, cnt))
2031 dqopt->files[cnt] = NULL;
2032 dqopt->info[cnt].dqi_flags = 0;
2033 dqopt->info[cnt].dqi_igrace = 0;
2034 dqopt->info[cnt].dqi_bgrace = 0;
2035 dqopt->ops[cnt] = NULL;
2036 }
2037 mutex_unlock(&dqopt->dqonoff_mutex);
2038
2039
2040 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2041 goto put_inodes;
2042
2043
2044
2045 if (sb->s_op->sync_fs)
2046 sb->s_op->sync_fs(sb, 1);
2047 sync_blockdev(sb->s_bdev);
2048
2049
2050
2051
2052
2053 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2054 if (toputinode[cnt]) {
2055 mutex_lock(&dqopt->dqonoff_mutex);
2056
2057
2058 if (!sb_has_quota_loaded(sb, cnt)) {
2059 mutex_lock(&toputinode[cnt]->i_mutex);
2060 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
2061 S_NOATIME | S_NOQUOTA);
2062 truncate_inode_pages(&toputinode[cnt]->i_data,
2063 0);
2064 mutex_unlock(&toputinode[cnt]->i_mutex);
2065 mark_inode_dirty_sync(toputinode[cnt]);
2066 }
2067 mutex_unlock(&dqopt->dqonoff_mutex);
2068 }
2069 if (sb->s_bdev)
2070 invalidate_bdev(sb->s_bdev);
2071put_inodes:
2072 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2073 if (toputinode[cnt]) {
2074
2075
2076
2077
2078
2079
2080
2081 if (!(flags & DQUOT_SUSPENDED))
2082 iput(toputinode[cnt]);
2083 else if (!toputinode[cnt]->i_nlink)
2084 ret = -EBUSY;
2085 }
2086 return ret;
2087}
2088EXPORT_SYMBOL(dquot_disable);
2089
2090int dquot_quota_off(struct super_block *sb, int type)
2091{
2092 return dquot_disable(sb, type,
2093 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2094}
2095EXPORT_SYMBOL(dquot_quota_off);
2096
2097
2098
2099
2100
2101
2102
2103
2104
2105static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2106 unsigned int flags)
2107{
2108 struct quota_format_type *fmt = find_quota_format(format_id);
2109 struct super_block *sb = inode->i_sb;
2110 struct quota_info *dqopt = sb_dqopt(sb);
2111 int error;
2112 int oldflags = -1;
2113
2114 if (!fmt)
2115 return -ESRCH;
2116 if (!S_ISREG(inode->i_mode)) {
2117 error = -EACCES;
2118 goto out_fmt;
2119 }
2120 if (IS_RDONLY(inode)) {
2121 error = -EROFS;
2122 goto out_fmt;
2123 }
2124 if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
2125 error = -EINVAL;
2126 goto out_fmt;
2127 }
2128
2129 if (!(flags & DQUOT_USAGE_ENABLED)) {
2130 error = -EINVAL;
2131 goto out_fmt;
2132 }
2133
2134 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2135
2136
2137
2138
2139
2140
2141 sync_filesystem(sb);
2142 invalidate_bdev(sb->s_bdev);
2143 }
2144 mutex_lock(&dqopt->dqonoff_mutex);
2145 if (sb_has_quota_loaded(sb, type)) {
2146 error = -EBUSY;
2147 goto out_lock;
2148 }
2149
2150 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2151
2152
2153
2154 mutex_lock(&inode->i_mutex);
2155 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2156 S_NOQUOTA);
2157 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
2158 mutex_unlock(&inode->i_mutex);
2159
2160
2161
2162
2163 __dquot_drop(inode);
2164 }
2165
2166 error = -EIO;
2167 dqopt->files[type] = igrab(inode);
2168 if (!dqopt->files[type])
2169 goto out_lock;
2170 error = -EINVAL;
2171 if (!fmt->qf_ops->check_quota_file(sb, type))
2172 goto out_file_init;
2173
2174 dqopt->ops[type] = fmt->qf_ops;
2175 dqopt->info[type].dqi_format = fmt;
2176 dqopt->info[type].dqi_fmt_id = format_id;
2177 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
2178 mutex_lock(&dqopt->dqio_mutex);
2179 error = dqopt->ops[type]->read_file_info(sb, type);
2180 if (error < 0) {
2181 mutex_unlock(&dqopt->dqio_mutex);
2182 goto out_file_init;
2183 }
2184 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2185 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
2186 mutex_unlock(&dqopt->dqio_mutex);
2187 spin_lock(&dq_state_lock);
2188 dqopt->flags |= dquot_state_flag(flags, type);
2189 spin_unlock(&dq_state_lock);
2190
2191 add_dquot_ref(sb, type);
2192 mutex_unlock(&dqopt->dqonoff_mutex);
2193
2194 return 0;
2195
2196out_file_init:
2197 dqopt->files[type] = NULL;
2198 iput(inode);
2199out_lock:
2200 if (oldflags != -1) {
2201 mutex_lock(&inode->i_mutex);
2202
2203
2204 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2205 inode->i_flags |= oldflags;
2206 mutex_unlock(&inode->i_mutex);
2207 }
2208 mutex_unlock(&dqopt->dqonoff_mutex);
2209out_fmt:
2210 put_quota_format(fmt);
2211
2212 return error;
2213}
2214
2215
2216int dquot_resume(struct super_block *sb, int type)
2217{
2218 struct quota_info *dqopt = sb_dqopt(sb);
2219 struct inode *inode;
2220 int ret = 0, cnt;
2221 unsigned int flags;
2222
2223 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2224 if (type != -1 && cnt != type)
2225 continue;
2226
2227 mutex_lock(&dqopt->dqonoff_mutex);
2228 if (!sb_has_quota_suspended(sb, cnt)) {
2229 mutex_unlock(&dqopt->dqonoff_mutex);
2230 continue;
2231 }
2232 inode = dqopt->files[cnt];
2233 dqopt->files[cnt] = NULL;
2234 spin_lock(&dq_state_lock);
2235 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2236 DQUOT_LIMITS_ENABLED,
2237 cnt);
2238 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2239 spin_unlock(&dq_state_lock);
2240 mutex_unlock(&dqopt->dqonoff_mutex);
2241
2242 flags = dquot_generic_flag(flags, cnt);
2243 ret = vfs_load_quota_inode(inode, cnt,
2244 dqopt->info[cnt].dqi_fmt_id, flags);
2245 iput(inode);
2246 }
2247
2248 return ret;
2249}
2250EXPORT_SYMBOL(dquot_resume);
2251
2252int dquot_quota_on(struct super_block *sb, int type, int format_id,
2253 struct path *path)
2254{
2255 int error = security_quota_on(path->dentry);
2256 if (error)
2257 return error;
2258
2259 if (path->dentry->d_sb != sb)
2260 error = -EXDEV;
2261 else
2262 error = vfs_load_quota_inode(path->dentry->d_inode, type,
2263 format_id, DQUOT_USAGE_ENABLED |
2264 DQUOT_LIMITS_ENABLED);
2265 return error;
2266}
2267EXPORT_SYMBOL(dquot_quota_on);
2268
2269
2270
2271
2272
2273int dquot_enable(struct inode *inode, int type, int format_id,
2274 unsigned int flags)
2275{
2276 int ret = 0;
2277 struct super_block *sb = inode->i_sb;
2278 struct quota_info *dqopt = sb_dqopt(sb);
2279
2280
2281 BUG_ON(flags & DQUOT_SUSPENDED);
2282
2283 if (!flags)
2284 return 0;
2285
2286 if (sb_has_quota_loaded(sb, type)) {
2287 mutex_lock(&dqopt->dqonoff_mutex);
2288
2289 if (!sb_has_quota_loaded(sb, type)) {
2290 mutex_unlock(&dqopt->dqonoff_mutex);
2291 goto load_quota;
2292 }
2293 if (flags & DQUOT_USAGE_ENABLED &&
2294 sb_has_quota_usage_enabled(sb, type)) {
2295 ret = -EBUSY;
2296 goto out_lock;
2297 }
2298 if (flags & DQUOT_LIMITS_ENABLED &&
2299 sb_has_quota_limits_enabled(sb, type)) {
2300 ret = -EBUSY;
2301 goto out_lock;
2302 }
2303 spin_lock(&dq_state_lock);
2304 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
2305 spin_unlock(&dq_state_lock);
2306out_lock:
2307 mutex_unlock(&dqopt->dqonoff_mutex);
2308 return ret;
2309 }
2310
2311load_quota:
2312 return vfs_load_quota_inode(inode, type, format_id, flags);
2313}
2314EXPORT_SYMBOL(dquot_enable);
2315
2316
2317
2318
2319
2320int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
2321 int format_id, int type)
2322{
2323 struct dentry *dentry;
2324 int error;
2325
2326 mutex_lock(&sb->s_root->d_inode->i_mutex);
2327 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
2328 mutex_unlock(&sb->s_root->d_inode->i_mutex);
2329 if (IS_ERR(dentry))
2330 return PTR_ERR(dentry);
2331
2332 if (!dentry->d_inode) {
2333 error = -ENOENT;
2334 goto out;
2335 }
2336
2337 error = security_quota_on(dentry);
2338 if (!error)
2339 error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
2340 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2341
2342out:
2343 dput(dentry);
2344 return error;
2345}
2346EXPORT_SYMBOL(dquot_quota_on_mount);
2347
2348static inline qsize_t qbtos(qsize_t blocks)
2349{
2350 return blocks << QIF_DQBLKSIZE_BITS;
2351}
2352
2353static inline qsize_t stoqb(qsize_t space)
2354{
2355 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
2356}
2357
2358
2359static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
2360{
2361 struct mem_dqblk *dm = &dquot->dq_dqb;
2362
2363 memset(di, 0, sizeof(*di));
2364 di->d_version = FS_DQUOT_VERSION;
2365 di->d_flags = dquot->dq_id.type == USRQUOTA ?
2366 FS_USER_QUOTA : FS_GROUP_QUOTA;
2367 di->d_id = from_kqid_munged(current_user_ns(), dquot->dq_id);
2368
2369 spin_lock(&dq_data_lock);
2370 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
2371 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
2372 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2373 di->d_ino_softlimit = dm->dqb_isoftlimit;
2374 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
2375 di->d_icount = dm->dqb_curinodes;
2376 di->d_btimer = dm->dqb_btime;
2377 di->d_itimer = dm->dqb_itime;
2378 spin_unlock(&dq_data_lock);
2379}
2380
2381int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
2382 struct fs_disk_quota *di)
2383{
2384 struct dquot *dquot;
2385
2386 dquot = dqget(sb, qid);
2387 if (!dquot)
2388 return -ESRCH;
2389 do_get_dqblk(dquot, di);
2390 dqput(dquot);
2391
2392 return 0;
2393}
2394EXPORT_SYMBOL(dquot_get_dqblk);
2395
2396#define VFS_FS_DQ_MASK \
2397 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
2398 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
2399 FS_DQ_BTIMER | FS_DQ_ITIMER)
2400
2401
2402static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
2403{
2404 struct mem_dqblk *dm = &dquot->dq_dqb;
2405 int check_blim = 0, check_ilim = 0;
2406 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
2407
2408 if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
2409 return -EINVAL;
2410
2411 if (((di->d_fieldmask & FS_DQ_BSOFT) &&
2412 (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
2413 ((di->d_fieldmask & FS_DQ_BHARD) &&
2414 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
2415 ((di->d_fieldmask & FS_DQ_ISOFT) &&
2416 (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
2417 ((di->d_fieldmask & FS_DQ_IHARD) &&
2418 (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
2419 return -ERANGE;
2420
2421 spin_lock(&dq_data_lock);
2422 if (di->d_fieldmask & FS_DQ_BCOUNT) {
2423 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
2424 check_blim = 1;
2425 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
2426 }
2427
2428 if (di->d_fieldmask & FS_DQ_BSOFT)
2429 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
2430 if (di->d_fieldmask & FS_DQ_BHARD)
2431 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
2432 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
2433 check_blim = 1;
2434 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
2435 }
2436
2437 if (di->d_fieldmask & FS_DQ_ICOUNT) {
2438 dm->dqb_curinodes = di->d_icount;
2439 check_ilim = 1;
2440 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
2441 }
2442
2443 if (di->d_fieldmask & FS_DQ_ISOFT)
2444 dm->dqb_isoftlimit = di->d_ino_softlimit;
2445 if (di->d_fieldmask & FS_DQ_IHARD)
2446 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2447 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
2448 check_ilim = 1;
2449 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
2450 }
2451
2452 if (di->d_fieldmask & FS_DQ_BTIMER) {
2453 dm->dqb_btime = di->d_btimer;
2454 check_blim = 1;
2455 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
2456 }
2457
2458 if (di->d_fieldmask & FS_DQ_ITIMER) {
2459 dm->dqb_itime = di->d_itimer;
2460 check_ilim = 1;
2461 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
2462 }
2463
2464 if (check_blim) {
2465 if (!dm->dqb_bsoftlimit ||
2466 dm->dqb_curspace < dm->dqb_bsoftlimit) {
2467 dm->dqb_btime = 0;
2468 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
2469 } else if (!(di->d_fieldmask & FS_DQ_BTIMER))
2470
2471 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
2472 }
2473 if (check_ilim) {
2474 if (!dm->dqb_isoftlimit ||
2475 dm->dqb_curinodes < dm->dqb_isoftlimit) {
2476 dm->dqb_itime = 0;
2477 clear_bit(DQ_INODES_B, &dquot->dq_flags);
2478 } else if (!(di->d_fieldmask & FS_DQ_ITIMER))
2479
2480 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
2481 }
2482 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2483 dm->dqb_isoftlimit)
2484 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2485 else
2486 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2487 spin_unlock(&dq_data_lock);
2488 mark_dquot_dirty(dquot);
2489
2490 return 0;
2491}
2492
2493int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
2494 struct fs_disk_quota *di)
2495{
2496 struct dquot *dquot;
2497 int rc;
2498
2499 dquot = dqget(sb, qid);
2500 if (!dquot) {
2501 rc = -ESRCH;
2502 goto out;
2503 }
2504 rc = do_set_dqblk(dquot, di);
2505 dqput(dquot);
2506out:
2507 return rc;
2508}
2509EXPORT_SYMBOL(dquot_set_dqblk);
2510
2511
2512int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
2513{
2514 struct mem_dqinfo *mi;
2515
2516 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2517 if (!sb_has_quota_active(sb, type)) {
2518 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2519 return -ESRCH;
2520 }
2521 mi = sb_dqopt(sb)->info + type;
2522 spin_lock(&dq_data_lock);
2523 ii->dqi_bgrace = mi->dqi_bgrace;
2524 ii->dqi_igrace = mi->dqi_igrace;
2525 ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK;
2526 ii->dqi_valid = IIF_ALL;
2527 spin_unlock(&dq_data_lock);
2528 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2529 return 0;
2530}
2531EXPORT_SYMBOL(dquot_get_dqinfo);
2532
2533
2534int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
2535{
2536 struct mem_dqinfo *mi;
2537 int err = 0;
2538
2539 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2540 if (!sb_has_quota_active(sb, type)) {
2541 err = -ESRCH;
2542 goto out;
2543 }
2544 mi = sb_dqopt(sb)->info + type;
2545 spin_lock(&dq_data_lock);
2546 if (ii->dqi_valid & IIF_BGRACE)
2547 mi->dqi_bgrace = ii->dqi_bgrace;
2548 if (ii->dqi_valid & IIF_IGRACE)
2549 mi->dqi_igrace = ii->dqi_igrace;
2550 if (ii->dqi_valid & IIF_FLAGS)
2551 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) |
2552 (ii->dqi_flags & DQF_SETINFO_MASK);
2553 spin_unlock(&dq_data_lock);
2554 mark_info_dirty(sb, type);
2555
2556 sb->dq_op->write_info(sb, type);
2557out:
2558 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2559 return err;
2560}
2561EXPORT_SYMBOL(dquot_set_dqinfo);
2562
2563const struct quotactl_ops dquot_quotactl_ops = {
2564 .quota_on = dquot_quota_on,
2565 .quota_off = dquot_quota_off,
2566 .quota_sync = dquot_quota_sync,
2567 .get_info = dquot_get_dqinfo,
2568 .set_info = dquot_set_dqinfo,
2569 .get_dqblk = dquot_get_dqblk,
2570 .set_dqblk = dquot_set_dqblk
2571};
2572EXPORT_SYMBOL(dquot_quotactl_ops);
2573
2574static int do_proc_dqstats(struct ctl_table *table, int write,
2575 void __user *buffer, size_t *lenp, loff_t *ppos)
2576{
2577 unsigned int type = (int *)table->data - dqstats.stat;
2578
2579
2580 dqstats.stat[type] =
2581 percpu_counter_sum_positive(&dqstats.counter[type]);
2582 return proc_dointvec(table, write, buffer, lenp, ppos);
2583}
2584
2585static ctl_table fs_dqstats_table[] = {
2586 {
2587 .procname = "lookups",
2588 .data = &dqstats.stat[DQST_LOOKUPS],
2589 .maxlen = sizeof(int),
2590 .mode = 0444,
2591 .proc_handler = do_proc_dqstats,
2592 },
2593 {
2594 .procname = "drops",
2595 .data = &dqstats.stat[DQST_DROPS],
2596 .maxlen = sizeof(int),
2597 .mode = 0444,
2598 .proc_handler = do_proc_dqstats,
2599 },
2600 {
2601 .procname = "reads",
2602 .data = &dqstats.stat[DQST_READS],
2603 .maxlen = sizeof(int),
2604 .mode = 0444,
2605 .proc_handler = do_proc_dqstats,
2606 },
2607 {
2608 .procname = "writes",
2609 .data = &dqstats.stat[DQST_WRITES],
2610 .maxlen = sizeof(int),
2611 .mode = 0444,
2612 .proc_handler = do_proc_dqstats,
2613 },
2614 {
2615 .procname = "cache_hits",
2616 .data = &dqstats.stat[DQST_CACHE_HITS],
2617 .maxlen = sizeof(int),
2618 .mode = 0444,
2619 .proc_handler = do_proc_dqstats,
2620 },
2621 {
2622 .procname = "allocated_dquots",
2623 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
2624 .maxlen = sizeof(int),
2625 .mode = 0444,
2626 .proc_handler = do_proc_dqstats,
2627 },
2628 {
2629 .procname = "free_dquots",
2630 .data = &dqstats.stat[DQST_FREE_DQUOTS],
2631 .maxlen = sizeof(int),
2632 .mode = 0444,
2633 .proc_handler = do_proc_dqstats,
2634 },
2635 {
2636 .procname = "syncs",
2637 .data = &dqstats.stat[DQST_SYNCS],
2638 .maxlen = sizeof(int),
2639 .mode = 0444,
2640 .proc_handler = do_proc_dqstats,
2641 },
2642#ifdef CONFIG_PRINT_QUOTA_WARNING
2643 {
2644 .procname = "warnings",
2645 .data = &flag_print_warnings,
2646 .maxlen = sizeof(int),
2647 .mode = 0644,
2648 .proc_handler = proc_dointvec,
2649 },
2650#endif
2651 { },
2652};
2653
2654static ctl_table fs_table[] = {
2655 {
2656 .procname = "quota",
2657 .mode = 0555,
2658 .child = fs_dqstats_table,
2659 },
2660 { },
2661};
2662
2663static ctl_table sys_table[] = {
2664 {
2665 .procname = "fs",
2666 .mode = 0555,
2667 .child = fs_table,
2668 },
2669 { },
2670};
2671
2672static int __init dquot_init(void)
2673{
2674 int i, ret;
2675 unsigned long nr_hash, order;
2676
2677 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2678
2679 register_sysctl_table(sys_table);
2680
2681 dquot_cachep = kmem_cache_create("dquot",
2682 sizeof(struct dquot), sizeof(unsigned long) * 4,
2683 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2684 SLAB_MEM_SPREAD|SLAB_PANIC),
2685 NULL);
2686
2687 order = 0;
2688 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2689 if (!dquot_hash)
2690 panic("Cannot create dquot hash table");
2691
2692 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2693 ret = percpu_counter_init(&dqstats.counter[i], 0);
2694 if (ret)
2695 panic("Cannot create dquot stat counters");
2696 }
2697
2698
2699 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2700 dq_hash_bits = 0;
2701 do {
2702 dq_hash_bits++;
2703 } while (nr_hash >> dq_hash_bits);
2704 dq_hash_bits--;
2705
2706 nr_hash = 1UL << dq_hash_bits;
2707 dq_hash_mask = nr_hash - 1;
2708 for (i = 0; i < nr_hash; i++)
2709 INIT_HLIST_HEAD(dquot_hash + i);
2710
2711 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2712 nr_hash, order, (PAGE_SIZE << order));
2713
2714 register_shrinker(&dqcache_shrinker);
2715
2716 return 0;
2717}
2718module_init(dquot_init);
2719