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