2 * Implementation of the diskquota system for the LINUX operating
3 * system. QUOTA is implemented using the BSD system call interface as
4 * the means of communication with the user level. Currently only the
5 * ext2 filesystem has support for disk quotas. Other filesystems may
6 * be added in the future. This file contains the generic routines
7 * called by the different filesystems on allocation of an inode or
8 * block. These routines take care of the administration needed to
9 * have a consistent diskquota tracking system. The ideas of both
10 * user and group quotas are based on the Melbourne quota system as
11 * used on BSD derived systems. The internal implementation is
12 * based on one of the several variants of the LINUX inode-subsystem
13 * with added complexity of the diskquota system.
15 * Version: $Id: dquot.c,v 6.3 1996/11/17 18:35:34 mvw Exp mvw $
17 * Author: Marco van Wieringen <mvw@planets.elm.net>
19 * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
21 * Revised list management to avoid races
22 * -- Bill Hawes, <whawes@star.net>, 9/98
24 * (C) Copyright 1994 - 1997 Marco van Wieringen
27 #include <linux/errno.h>
28 #include <linux/kernel.h>
29 #include <linux/sched.h>
31 #include <linux/types.h>
32 #include <linux/string.h>
33 #include <linux/fcntl.h>
34 #include <linux/stat.h>
35 #include <linux/tty.h>
36 #include <linux/file.h>
37 #include <linux/malloc.h>
38 #include <linux/mount.h>
39 #include <linux/smp.h>
40 #include <linux/smp_lock.h>
41 #include <linux/init.h>
42 #include <linux/slab.h>
44 #include <asm/uaccess.h>
46 #define __DQUOT_VERSION__ "dquot_6.4.0"
48 int nr_dquots
= 0, nr_free_dquots
= 0;
49 int max_dquots
= NR_DQUOTS
;
51 static char quotamessage
[MAX_QUOTA_MESSAGE
];
52 static char *quotatypes
[] = INITQFNAMES
;
54 static kmem_cache_t
*dquot_cachep
;
57 * Dquot List Management:
58 * The quota code uses three lists for dquot management: the inuse_list,
59 * free_dquots, and dquot_hash[] array. A single dquot structure may be
60 * on all three lists, depending on its current state.
62 * All dquots are placed on the inuse_list when first created, and this
63 * list is used for the sync and invalidate operations, which must look
66 * Unused dquots (dq_count == 0) are added to the free_dquots list when
67 * freed, and this list is searched whenever we need an available dquot.
68 * Dquots are removed from the list as soon as they are used again, and
69 * nr_free_dquots gives the number of dquots on the list.
71 * Dquots with a specific identity (device, type and id) are placed on
72 * one of the dquot_hash[] hash chains. The provides an efficient search
73 * mechanism to lcoate a specific dquot.
76 static struct dquot
*inuse_list
= NULL
;
77 LIST_HEAD(free_dquots
);
78 static struct dquot
*dquot_hash
[NR_DQHASH
];
79 static int dquot_updating
[NR_DQHASH
];
81 static struct dqstats dqstats
;
82 static struct wait_queue
*dquot_wait
= (struct wait_queue
*)NULL
,
83 *update_wait
= (struct wait_queue
*)NULL
;
85 static inline char is_enabled(struct vfsmount
*vfsmnt
, short type
)
89 return((vfsmnt
->mnt_dquot
.flags
& DQUOT_USR_ENABLED
) != 0);
91 return((vfsmnt
->mnt_dquot
.flags
& DQUOT_GRP_ENABLED
) != 0);
96 static inline char sb_has_quota_enabled(struct super_block
*sb
, short type
)
98 struct vfsmount
*vfsmnt
;
100 return((vfsmnt
= lookup_vfsmnt(sb
->s_dev
)) != (struct vfsmount
*)NULL
&& is_enabled(vfsmnt
, type
));
103 static inline char dev_has_quota_enabled(kdev_t dev
, short type
)
105 struct vfsmount
*vfsmnt
;
107 return((vfsmnt
= lookup_vfsmnt(dev
)) != (struct vfsmount
*)NULL
&& is_enabled(vfsmnt
, type
));
110 static inline int const hashfn(kdev_t dev
, unsigned int id
, short type
)
112 return((HASHDEV(dev
) ^ id
) * (MAXQUOTAS
- type
)) % NR_DQHASH
;
115 static inline void insert_dquot_hash(struct dquot
*dquot
)
117 struct dquot
**htable
;
119 htable
= &dquot_hash
[hashfn(dquot
->dq_dev
, dquot
->dq_id
, dquot
->dq_type
)];
120 if ((dquot
->dq_hash_next
= *htable
) != NULL
)
121 (*htable
)->dq_hash_pprev
= &dquot
->dq_hash_next
;
123 dquot
->dq_hash_pprev
= htable
;
126 static inline void hash_dquot(struct dquot
*dquot
)
128 insert_dquot_hash(dquot
);
131 static inline void unhash_dquot(struct dquot
*dquot
)
133 if (dquot
->dq_hash_pprev
) {
134 if (dquot
->dq_hash_next
)
135 dquot
->dq_hash_next
->dq_hash_pprev
= dquot
->dq_hash_pprev
;
136 *(dquot
->dq_hash_pprev
) = dquot
->dq_hash_next
;
137 dquot
->dq_hash_pprev
= NULL
;
141 static inline struct dquot
*find_dquot(unsigned int hashent
, kdev_t dev
, unsigned int id
, short type
)
145 for (dquot
= dquot_hash
[hashent
]; dquot
; dquot
= dquot
->dq_hash_next
)
146 if (dquot
->dq_dev
== dev
&& dquot
->dq_id
== id
&& dquot
->dq_type
== type
)
151 /* Add a dquot to the head of the free list */
152 static inline void put_dquot_head(struct dquot
*dquot
)
154 list_add(&dquot
->dq_free
, &free_dquots
);
158 /* Add a dquot to the tail of the free list */
159 static inline void put_dquot_last(struct dquot
*dquot
)
161 list_add(&dquot
->dq_free
, free_dquots
.prev
);
165 static inline void remove_free_dquot(struct dquot
*dquot
)
168 if (list_empty(&dquot
->dq_free
)) {
169 printk("remove_free_dquot: dquot not on free list??\n");
171 list_del(&dquot
->dq_free
);
172 INIT_LIST_HEAD(&dquot
->dq_free
);
176 static inline void put_inuse(struct dquot
*dquot
)
178 if ((dquot
->dq_next
= inuse_list
) != NULL
)
179 inuse_list
->dq_pprev
= &dquot
->dq_next
;
181 dquot
->dq_pprev
= &inuse_list
;
184 #if 0 /* currently not needed */
185 static inline void remove_inuse(struct dquot
*dquot
)
187 if (dquot
->dq_pprev
) {
189 dquot
->dq_next
->dq_pprev
= dquot
->dq_pprev
;
190 *dquot
->dq_pprev
= dquot
->dq_next
;
191 dquot
->dq_pprev
= NULL
;
196 static void __wait_on_dquot(struct dquot
*dquot
)
198 struct wait_queue wait
= { current
, NULL
};
200 add_wait_queue(&dquot
->dq_wait
, &wait
);
202 current
->state
= TASK_UNINTERRUPTIBLE
;
203 if (dquot
->dq_flags
& DQ_LOCKED
) {
207 remove_wait_queue(&dquot
->dq_wait
, &wait
);
208 current
->state
= TASK_RUNNING
;
211 static inline void wait_on_dquot(struct dquot
*dquot
)
213 if (dquot
->dq_flags
& DQ_LOCKED
)
214 __wait_on_dquot(dquot
);
217 static inline void lock_dquot(struct dquot
*dquot
)
219 wait_on_dquot(dquot
);
220 dquot
->dq_flags
|= DQ_LOCKED
;
223 static inline void unlock_dquot(struct dquot
*dquot
)
225 dquot
->dq_flags
&= ~DQ_LOCKED
;
226 wake_up(&dquot
->dq_wait
);
229 static void write_dquot(struct dquot
*dquot
)
231 short type
= dquot
->dq_type
;
232 struct file
*filp
= dquot
->dq_mnt
->mnt_dquot
.files
[type
];
238 down(&dquot
->dq_mnt
->mnt_dquot
.semaphore
);
239 offset
= dqoff(dquot
->dq_id
);
244 * Note: clear the DQ_MOD flag unconditionally,
245 * so we don't loop forever on failure.
247 dquot
->dq_flags
&= ~DQ_MOD
;
250 ret
= filp
->f_op
->write(filp
, (char *)&dquot
->dq_dqb
,
251 sizeof(struct dqblk
), &offset
);
252 if (ret
!= sizeof(struct dqblk
))
253 printk(KERN_WARNING
"VFS: dquota write failed on dev %s\n",
254 kdevname(dquot
->dq_dev
));
256 up(&dquot
->dq_mnt
->mnt_dquot
.semaphore
);
263 static void read_dquot(struct dquot
*dquot
)
270 type
= dquot
->dq_type
;
271 filp
= dquot
->dq_mnt
->mnt_dquot
.files
[type
];
273 if (filp
== (struct file
*)NULL
)
277 down(&dquot
->dq_mnt
->mnt_dquot
.semaphore
);
278 offset
= dqoff(dquot
->dq_id
);
281 filp
->f_op
->read(filp
, (char *)&dquot
->dq_dqb
, sizeof(struct dqblk
), &offset
);
282 up(&dquot
->dq_mnt
->mnt_dquot
.semaphore
);
285 if (dquot
->dq_bhardlimit
== 0 && dquot
->dq_bsoftlimit
== 0 &&
286 dquot
->dq_ihardlimit
== 0 && dquot
->dq_isoftlimit
== 0)
287 dquot
->dq_flags
|= DQ_FAKE
;
293 * Unhash and selectively clear the dquot structure,
294 * but preserve the use count, list pointers, and
297 void clear_dquot(struct dquot
*dquot
)
299 /* unhash it first */
301 dquot
->dq_mnt
= NULL
;
303 dquot
->dq_referenced
= 0;
304 memset(&dquot
->dq_dqb
, 0, sizeof(struct dqblk
));
307 void invalidate_dquots(kdev_t dev
, short type
)
309 struct dquot
*dquot
, *next
= inuse_list
;
314 while ((dquot
= next
) != NULL
) {
315 next
= dquot
->dq_next
;
316 if (dquot
->dq_dev
!= dev
)
318 if (dquot
->dq_type
!= type
)
320 if (dquot
->dq_flags
& DQ_LOCKED
) {
321 __wait_on_dquot(dquot
);
323 /* Set the flag for another pass. */
326 * Make sure it's still the same dquot.
328 if (dquot
->dq_dev
!= dev
)
330 if (dquot
->dq_type
!= type
)
336 * If anything blocked, restart the operation
337 * to ensure we don't miss any dquots.
343 int sync_dquots(kdev_t dev
, short type
)
345 struct dquot
*dquot
, *next
= inuse_list
;
350 while ((dquot
= next
) != NULL
) {
351 next
= dquot
->dq_next
;
352 if (dev
&& dquot
->dq_dev
!= dev
)
354 if (type
!= -1 && dquot
->dq_type
!= type
)
356 if (!(dquot
->dq_flags
& (DQ_LOCKED
| DQ_MOD
)))
359 wait_on_dquot(dquot
);
360 if (dquot
->dq_flags
& DQ_MOD
)
362 /* Set the flag for another pass. */
366 * If anything blocked, restart the operation
367 * to ensure we don't miss any dquots.
376 void dqput(struct dquot
*dquot
)
380 if (!dquot
->dq_count
) {
381 printk("VFS: dqput: trying to free free dquot\n");
382 printk("VFS: device %s, dquot of %s %d\n",
383 kdevname(dquot
->dq_dev
), quotatypes
[dquot
->dq_type
],
389 * If the dq_mnt pointer isn't initialized this entry needs no
390 * checking and doesn't need to be written. It's just an empty
391 * dquot that is put back on to the freelist.
393 if (dquot
->dq_mnt
!= (struct vfsmount
*)NULL
) {
396 wait_on_dquot(dquot
);
397 if (dquot
->dq_count
> 1) {
401 if (dquot
->dq_flags
& DQ_MOD
) {
408 if (!list_empty(&dquot
->dq_free
)) {
409 printk("dqput: dquot already on free list??\n");
411 if (--dquot
->dq_count
== 0) {
412 /* Place at end of LRU free queue */
413 put_dquot_last(dquot
);
414 wake_up(&dquot_wait
);
420 static void grow_dquots(void)
426 dquot
= kmem_cache_alloc(dquot_cachep
, SLAB_KERNEL
);
431 memset((caddr_t
)dquot
, 0, sizeof(struct dquot
));
432 /* all dquots go on the inuse_list */
434 put_dquot_head(dquot
);
439 static struct dquot
*find_best_candidate_weighted(void)
441 struct list_head
*tmp
= &free_dquots
;
442 struct dquot
*dquot
, *best
= NULL
;
443 unsigned long myscore
, bestscore
= ~0U;
444 int limit
= (nr_free_dquots
> 128) ? nr_free_dquots
>> 2 : 32;
446 while ((tmp
= tmp
->next
) != &free_dquots
&& --limit
) {
447 dquot
= list_entry(tmp
, struct dquot
, dq_free
);
448 if (dquot
->dq_flags
& (DQ_LOCKED
| DQ_MOD
))
450 myscore
= dquot
->dq_referenced
;
451 if (myscore
< bestscore
) {
459 static inline struct dquot
*find_best_free(void)
461 struct list_head
*tmp
= &free_dquots
;
463 int limit
= (nr_free_dquots
> 1024) ? nr_free_dquots
>> 5 : 32;
465 while ((tmp
= tmp
->next
) != &free_dquots
&& --limit
) {
466 dquot
= list_entry(tmp
, struct dquot
, dq_free
);
467 if (dquot
->dq_referenced
== 0)
473 struct dquot
*get_empty_dquot(void)
479 dquot
= find_best_free();
483 if (dquot
->dq_flags
& (DQ_LOCKED
| DQ_MOD
)) {
484 wait_on_dquot(dquot
);
485 if (dquot
->dq_flags
& DQ_MOD
)
487 if(dquot
->dq_mnt
!= (struct vfsmount
*)NULL
)
491 * The dquot may be back in use now, so we
492 * must recheck the free list.
496 /* sanity check ... */
497 if (dquot
->dq_count
!= 0)
498 printk(KERN_ERR
"VFS: free dquot count=%d\n", dquot
->dq_count
);
500 remove_free_dquot(dquot
);
502 /* unhash and selectively clear the structure */
507 if (nr_dquots
< max_dquots
) {
512 dquot
= find_best_candidate_weighted();
516 * Try pruning the dcache to free up some dquots ...
518 count
= select_dcache(128, 0);
520 printk(KERN_DEBUG
"get_empty_dquot: pruning %d\n", count
);
522 free_inode_memory(count
);
526 printk("VFS: No free dquots, contact mvw@planets.elm.net\n");
527 sleep_on(&dquot_wait
);
531 struct dquot
*dqget(kdev_t dev
, unsigned int id
, short type
)
533 unsigned int hashent
= hashfn(dev
, id
, type
);
534 struct dquot
*dquot
, *empty
= NULL
;
535 struct vfsmount
*vfsmnt
;
537 if ((vfsmnt
= lookup_vfsmnt(dev
)) == (struct vfsmount
*)NULL
|| is_enabled(vfsmnt
, type
) == 0)
541 if ((dquot
= find_dquot(hashent
, dev
, id
, type
)) == NULL
) {
543 dquot_updating
[hashent
]++;
544 empty
= get_empty_dquot();
545 if (!--dquot_updating
[hashent
])
546 wake_up(&update_wait
);
551 dquot
->dq_type
= type
;
553 dquot
->dq_mnt
= vfsmnt
;
554 /* hash it first so it can be found */
558 if (!dquot
->dq_count
++) {
559 remove_free_dquot(dquot
);
561 dqstats
.cache_hits
++;
562 wait_on_dquot(dquot
);
567 while (dquot_updating
[hashent
])
568 sleep_on(&update_wait
);
570 dquot
->dq_referenced
++;
576 static void add_dquot_ref(kdev_t dev
, short type
)
578 struct super_block
*sb
= get_super(dev
);
582 if (!sb
|| !sb
->dq_op
)
583 return; /* nothing to do */
585 for (filp
= inuse_filps
; filp
; filp
= filp
->f_next
) {
588 if (filp
->f_dentry
->d_sb
!= sb
)
590 inode
= filp
->f_dentry
->d_inode
;
593 /* N.B. race problem -- filp could become unused */
594 if (filp
->f_mode
& FMODE_WRITE
) {
595 sb
->dq_op
->initialize(inode
, type
);
596 inode
->i_flags
|= S_QUOTA
;
601 static void reset_dquot_ptrs(kdev_t dev
, short type
)
603 struct super_block
*sb
= get_super(dev
);
609 if (!sb
|| !sb
->dq_op
)
610 return; /* nothing to do */
613 /* free any quota for unused dentries */
614 shrink_dcache_sb(sb
);
616 for (filp
= inuse_filps
; filp
; filp
= filp
->f_next
) {
619 if (filp
->f_dentry
->d_sb
!= sb
)
621 inode
= filp
->f_dentry
->d_inode
;
625 * Note: we restart after each blocking operation,
626 * as the inuse_filps list may have changed.
628 if (IS_QUOTAINIT(inode
)) {
629 dquot
= inode
->i_dquot
[type
];
630 inode
->i_dquot
[type
] = NODQUOT
;
631 /* any other quota in use? */
632 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
633 if (inode
->i_dquot
[cnt
] != NODQUOT
)
636 inode
->i_flags
&= ~S_QUOTA
;
638 if (dquot
!= NODQUOT
) {
640 /* we may have blocked ... */
647 static inline void dquot_incr_inodes(struct dquot
*dquot
, unsigned long number
)
650 dquot
->dq_curinodes
+= number
;
651 dquot
->dq_flags
|= DQ_MOD
;
655 static inline void dquot_incr_blocks(struct dquot
*dquot
, unsigned long number
)
658 dquot
->dq_curblocks
+= number
;
659 dquot
->dq_flags
|= DQ_MOD
;
663 static inline void dquot_decr_inodes(struct dquot
*dquot
, unsigned long number
)
666 if (dquot
->dq_curinodes
> number
)
667 dquot
->dq_curinodes
-= number
;
669 dquot
->dq_curinodes
= 0;
670 if (dquot
->dq_curinodes
< dquot
->dq_isoftlimit
)
671 dquot
->dq_itime
= (time_t) 0;
672 dquot
->dq_flags
&= ~DQ_INODES
;
673 dquot
->dq_flags
|= DQ_MOD
;
677 static inline void dquot_decr_blocks(struct dquot
*dquot
, unsigned long number
)
680 if (dquot
->dq_curblocks
> number
)
681 dquot
->dq_curblocks
-= number
;
683 dquot
->dq_curblocks
= 0;
684 if (dquot
->dq_curblocks
< dquot
->dq_bsoftlimit
)
685 dquot
->dq_btime
= (time_t) 0;
686 dquot
->dq_flags
&= ~DQ_BLKS
;
687 dquot
->dq_flags
|= DQ_MOD
;
691 static inline char need_print_warning(short type
, uid_t initiator
, struct dquot
*dquot
)
695 return(initiator
== dquot
->dq_id
);
697 return(initiator
== dquot
->dq_id
);
702 static inline char ignore_hardlimit(struct dquot
*dquot
, uid_t initiator
)
704 return(initiator
== 0 && dquot
->dq_mnt
->mnt_dquot
.rsquash
[dquot
->dq_type
] == 0);
707 static int check_idq(struct dquot
*dquot
, short type
, u_long
short inodes
, uid_t initiator
,
708 struct tty_struct
*tty
)
710 if (inodes
<= 0 || dquot
->dq_flags
& DQ_FAKE
)
713 if (dquot
->dq_ihardlimit
&&
714 (dquot
->dq_curinodes
+ inodes
) > dquot
->dq_ihardlimit
&&
715 !ignore_hardlimit(dquot
, initiator
)) {
716 if ((dquot
->dq_flags
& DQ_INODES
) == 0 &&
717 need_print_warning(type
, initiator
, dquot
)) {
718 sprintf(quotamessage
, "%s: write failed, %s file limit reached\n",
719 dquot
->dq_mnt
->mnt_dirname
, quotatypes
[type
]);
720 tty_write_message(tty
, quotamessage
);
721 dquot
->dq_flags
|= DQ_INODES
;
726 if (dquot
->dq_isoftlimit
&&
727 (dquot
->dq_curinodes
+ inodes
) > dquot
->dq_isoftlimit
&&
728 dquot
->dq_itime
&& CURRENT_TIME
>= dquot
->dq_itime
&&
729 !ignore_hardlimit(dquot
, initiator
)) {
730 if (need_print_warning(type
, initiator
, dquot
)) {
731 sprintf(quotamessage
, "%s: warning, %s file quota exceeded too long.\n",
732 dquot
->dq_mnt
->mnt_dirname
, quotatypes
[type
]);
733 tty_write_message(tty
, quotamessage
);
738 if (dquot
->dq_isoftlimit
&&
739 (dquot
->dq_curinodes
+ inodes
) > dquot
->dq_isoftlimit
&&
740 dquot
->dq_itime
== 0) {
741 if (need_print_warning(type
, initiator
, dquot
)) {
742 sprintf(quotamessage
, "%s: warning, %s file quota exceeded\n",
743 dquot
->dq_mnt
->mnt_dirname
, quotatypes
[type
]);
744 tty_write_message(tty
, quotamessage
);
746 dquot
->dq_itime
= CURRENT_TIME
+ dquot
->dq_mnt
->mnt_dquot
.inode_expire
[type
];
752 static int check_bdq(struct dquot
*dquot
, short type
, u_long blocks
, uid_t initiator
,
753 struct tty_struct
*tty
, char warn
)
755 if (blocks
<= 0 || dquot
->dq_flags
& DQ_FAKE
)
758 if (dquot
->dq_bhardlimit
&&
759 (dquot
->dq_curblocks
+ blocks
) > dquot
->dq_bhardlimit
&&
760 !ignore_hardlimit(dquot
, initiator
)) {
761 if (warn
&& (dquot
->dq_flags
& DQ_BLKS
) == 0 &&
762 need_print_warning(type
, initiator
, dquot
)) {
763 sprintf(quotamessage
, "%s: write failed, %s disk limit reached.\n",
764 dquot
->dq_mnt
->mnt_dirname
, quotatypes
[type
]);
765 tty_write_message(tty
, quotamessage
);
766 dquot
->dq_flags
|= DQ_BLKS
;
771 if (dquot
->dq_bsoftlimit
&&
772 (dquot
->dq_curblocks
+ blocks
) > dquot
->dq_bsoftlimit
&&
773 dquot
->dq_btime
&& CURRENT_TIME
>= dquot
->dq_btime
&&
774 !ignore_hardlimit(dquot
, initiator
)) {
775 if (warn
&& need_print_warning(type
, initiator
, dquot
)) {
776 sprintf(quotamessage
, "%s: write failed, %s disk quota exceeded too long.\n",
777 dquot
->dq_mnt
->mnt_dirname
, quotatypes
[type
]);
778 tty_write_message(tty
, quotamessage
);
783 if (dquot
->dq_bsoftlimit
&&
784 (dquot
->dq_curblocks
+ blocks
) > dquot
->dq_bsoftlimit
&&
785 dquot
->dq_btime
== 0) {
786 if (warn
&& need_print_warning(type
, initiator
, dquot
)) {
787 sprintf(quotamessage
, "%s: warning, %s disk quota exceeded\n",
788 dquot
->dq_mnt
->mnt_dirname
, quotatypes
[type
]);
789 tty_write_message(tty
, quotamessage
);
791 dquot
->dq_btime
= CURRENT_TIME
+ dquot
->dq_mnt
->mnt_dquot
.block_expire
[type
];
798 * Initialize a dquot-struct with new quota info. This is used by the
799 * system call interface functions.
801 static int set_dqblk(kdev_t dev
, int id
, short type
, int flags
, struct dqblk
*dqblk
)
805 struct dqblk dq_dqblk
;
807 if (dqblk
== (struct dqblk
*)NULL
)
810 if (flags
& QUOTA_SYSCALL
) {
811 if (copy_from_user(&dq_dqblk
, dqblk
, sizeof(struct dqblk
)))
814 memcpy((caddr_t
)&dq_dqblk
, (caddr_t
)dqblk
, sizeof(struct dqblk
));
816 if ((dquot
= dqget(dev
, id
, type
)) != NODQUOT
) {
819 if (id
> 0 && ((flags
& SET_QUOTA
) || (flags
& SET_QLIMIT
))) {
820 dquot
->dq_bhardlimit
= dq_dqblk
.dqb_bhardlimit
;
821 dquot
->dq_bsoftlimit
= dq_dqblk
.dqb_bsoftlimit
;
822 dquot
->dq_ihardlimit
= dq_dqblk
.dqb_ihardlimit
;
823 dquot
->dq_isoftlimit
= dq_dqblk
.dqb_isoftlimit
;
826 if ((flags
& SET_QUOTA
) || (flags
& SET_USE
)) {
827 if (dquot
->dq_isoftlimit
&&
828 dquot
->dq_curinodes
< dquot
->dq_isoftlimit
&&
829 dq_dqblk
.dqb_curinodes
>= dquot
->dq_isoftlimit
)
830 dquot
->dq_itime
= CURRENT_TIME
+ dquot
->dq_mnt
->mnt_dquot
.inode_expire
[type
];
831 dquot
->dq_curinodes
= dq_dqblk
.dqb_curinodes
;
832 if (dquot
->dq_curinodes
< dquot
->dq_isoftlimit
)
833 dquot
->dq_flags
&= ~DQ_INODES
;
834 if (dquot
->dq_bsoftlimit
&&
835 dquot
->dq_curblocks
< dquot
->dq_bsoftlimit
&&
836 dq_dqblk
.dqb_curblocks
>= dquot
->dq_bsoftlimit
)
837 dquot
->dq_btime
= CURRENT_TIME
+ dquot
->dq_mnt
->mnt_dquot
.block_expire
[type
];
838 dquot
->dq_curblocks
= dq_dqblk
.dqb_curblocks
;
839 if (dquot
->dq_curblocks
< dquot
->dq_bsoftlimit
)
840 dquot
->dq_flags
&= ~DQ_BLKS
;
844 dquot
->dq_mnt
->mnt_dquot
.block_expire
[type
] = dquot
->dq_btime
= dq_dqblk
.dqb_btime
;
845 dquot
->dq_mnt
->mnt_dquot
.inode_expire
[type
] = dquot
->dq_itime
= dq_dqblk
.dqb_itime
;
848 if (dq_dqblk
.dqb_bhardlimit
== 0 && dq_dqblk
.dqb_bsoftlimit
== 0 &&
849 dq_dqblk
.dqb_ihardlimit
== 0 && dq_dqblk
.dqb_isoftlimit
== 0)
850 dquot
->dq_flags
|= DQ_FAKE
;
852 dquot
->dq_flags
&= ~DQ_FAKE
;
854 dquot
->dq_flags
|= DQ_MOD
;
861 static int get_quota(kdev_t dev
, int id
, short type
, struct dqblk
*dqblk
)
866 if (!dev_has_quota_enabled(dev
, type
))
868 dquot
= dqget(dev
, id
, type
);
869 if (dquot
== NODQUOT
)
873 if (dqblk
&& !copy_to_user(dqblk
, &dquot
->dq_dqb
, sizeof(struct dqblk
)))
880 static int get_stats(caddr_t addr
)
883 struct dqstats stats
;
885 dqstats
.allocated_dquots
= nr_dquots
;
886 dqstats
.free_dquots
= nr_free_dquots
;
888 /* make a copy, in case we page-fault in user space */
889 memcpy(&stats
, &dqstats
, sizeof(struct dqstats
));
890 if (!copy_to_user(addr
, &stats
, sizeof(struct dqstats
)))
895 static int quota_root_squash(kdev_t dev
, short type
, int *addr
)
897 struct vfsmount
*vfsmnt
;
898 int new_value
, error
;
900 if ((vfsmnt
= lookup_vfsmnt(dev
)) == (struct vfsmount
*)NULL
)
904 if (!copy_from_user(&new_value
, addr
, sizeof(int))) {
905 vfsmnt
->mnt_dquot
.rsquash
[type
] = new_value
;
912 * This is a simple algorithm that calculates the size of a file in blocks.
913 * This is only used on filesystems that do not have an i_blocks count.
915 static u_long
isize_to_blocks(size_t isize
, size_t blksize
)
921 blksize
= BLOCK_SIZE
;
922 blocks
= (isize
/ blksize
) + ((isize
% blksize
) ? 1 : 0);
924 indirect
= ((blocks
- 11) >> 8) + 1; /* single indirect blocks */
925 if (blocks
> (10 + 256)) {
926 indirect
+= ((blocks
- 267) >> 16) + 1; /* double indirect blocks */
927 if (blocks
> (10 + 256 + (256 << 8)))
928 indirect
++; /* triple indirect blocks */
936 * Externally referenced functions through dquot_operations in inode.
938 * Note: this is a blocking operation.
940 void dquot_initialize(struct inode
*inode
, short type
)
946 if (S_ISREG(inode
->i_mode
) ||
947 S_ISDIR(inode
->i_mode
) ||
948 S_ISLNK(inode
->i_mode
)) {
949 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
950 if (type
!= -1 && cnt
!= type
)
953 if (!sb_has_quota_enabled(inode
->i_sb
, cnt
))
956 if (inode
->i_dquot
[cnt
] == NODQUOT
) {
965 dquot
= dqget(inode
->i_dev
, id
, cnt
);
966 if (inode
->i_dquot
[cnt
] != NODQUOT
) {
970 inode
->i_dquot
[cnt
] = dquot
;
971 inode
->i_flags
|= S_QUOTA
;
978 * Release all quota for the specified inode.
980 * Note: this is a blocking operation.
982 void dquot_drop(struct inode
*inode
)
987 inode
->i_flags
&= ~S_QUOTA
;
988 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
989 if (inode
->i_dquot
[cnt
] == NODQUOT
)
991 dquot
= inode
->i_dquot
[cnt
];
992 inode
->i_dquot
[cnt
] = NODQUOT
;
998 * Note: this is a blocking operation.
1000 int dquot_alloc_block(const struct inode
*inode
, unsigned long number
, uid_t initiator
,
1004 struct tty_struct
*tty
= current
->tty
;
1006 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1007 if (inode
->i_dquot
[cnt
] == NODQUOT
)
1009 if (check_bdq(inode
->i_dquot
[cnt
], cnt
, number
, initiator
, tty
, warn
))
1013 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1014 if (inode
->i_dquot
[cnt
] == NODQUOT
)
1016 dquot_incr_blocks(inode
->i_dquot
[cnt
], number
);
1023 * Note: this is a blocking operation.
1025 int dquot_alloc_inode(const struct inode
*inode
, unsigned long number
, uid_t initiator
)
1028 struct tty_struct
*tty
= current
->tty
;
1030 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1031 if (inode
->i_dquot
[cnt
] == NODQUOT
)
1033 if (check_idq(inode
->i_dquot
[cnt
], cnt
, number
, initiator
, tty
))
1037 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1038 if (inode
->i_dquot
[cnt
] == NODQUOT
)
1040 dquot_incr_inodes(inode
->i_dquot
[cnt
], number
);
1047 * Note: this is a blocking operation.
1049 void dquot_free_block(const struct inode
*inode
, unsigned long number
)
1053 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1054 if (inode
->i_dquot
[cnt
] == NODQUOT
)
1056 dquot_decr_blocks(inode
->i_dquot
[cnt
], number
);
1061 * Note: this is a blocking operation.
1063 void dquot_free_inode(const struct inode
*inode
, unsigned long number
)
1067 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1068 if (inode
->i_dquot
[cnt
] == NODQUOT
)
1070 dquot_decr_inodes(inode
->i_dquot
[cnt
], number
);
1075 * Transfer the number of inode and blocks from one diskquota to an other.
1077 * Note: this is a blocking operation.
1079 int dquot_transfer(struct inode
*inode
, struct iattr
*iattr
, char direction
, uid_t initiator
)
1081 unsigned long blocks
;
1082 struct dquot
*transfer_from
[MAXQUOTAS
];
1083 struct dquot
*transfer_to
[MAXQUOTAS
];
1084 struct tty_struct
*tty
= current
->tty
;
1088 * Find out if this filesystem uses i_blocks.
1090 if (inode
->i_blksize
== 0)
1091 blocks
= isize_to_blocks(inode
->i_size
, BLOCK_SIZE
);
1093 blocks
= (inode
->i_blocks
/ 2);
1096 * Build the transfer_from and transfer_to lists and check quotas to see
1097 * if operation is permitted.
1099 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1100 transfer_from
[cnt
] = NODQUOT
;
1101 transfer_to
[cnt
] = NODQUOT
;
1103 if (!sb_has_quota_enabled(inode
->i_sb
, cnt
))
1108 if (inode
->i_uid
== iattr
->ia_uid
)
1110 transfer_from
[cnt
] = dqget(inode
->i_dev
, (direction
) ? iattr
->ia_uid
: inode
->i_uid
, cnt
);
1111 transfer_to
[cnt
] = dqget(inode
->i_dev
, (direction
) ? inode
->i_uid
: iattr
->ia_uid
, cnt
);
1114 if (inode
->i_gid
== iattr
->ia_gid
)
1116 transfer_from
[cnt
] = dqget(inode
->i_dev
, (direction
) ? iattr
->ia_gid
: inode
->i_gid
, cnt
);
1117 transfer_to
[cnt
] = dqget(inode
->i_dev
, (direction
) ? inode
->i_gid
: iattr
->ia_gid
, cnt
);
1121 if (check_idq(transfer_to
[cnt
], cnt
, 1, initiator
, tty
) == NO_QUOTA
||
1122 check_bdq(transfer_to
[cnt
], cnt
, blocks
, initiator
, tty
, 0) == NO_QUOTA
) {
1123 for (disc
= 0; disc
<= cnt
; disc
++) {
1124 dqput(transfer_from
[disc
]);
1125 dqput(transfer_to
[disc
]);
1132 * Finally perform the needed transfer from transfer_from to transfer_to,
1133 * and release any pointers to dquots not needed anymore.
1135 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1137 * Skip changes for same uid or gid or for non-existing quota-type.
1139 if (transfer_from
[cnt
] == NODQUOT
&& transfer_to
[cnt
] == NODQUOT
)
1142 if (transfer_from
[cnt
] != NODQUOT
) {
1143 dquot_decr_inodes(transfer_from
[cnt
], 1);
1144 dquot_decr_blocks(transfer_from
[cnt
], blocks
);
1147 if (transfer_to
[cnt
] != NODQUOT
) {
1148 dquot_incr_inodes(transfer_to
[cnt
], 1);
1149 dquot_incr_blocks(transfer_to
[cnt
], blocks
);
1152 if (inode
->i_dquot
[cnt
] != NODQUOT
) {
1153 struct dquot
*temp
= inode
->i_dquot
[cnt
];
1154 inode
->i_dquot
[cnt
] = transfer_to
[cnt
];
1156 dqput(transfer_from
[cnt
]);
1158 dqput(transfer_from
[cnt
]);
1159 dqput(transfer_to
[cnt
]);
1167 void __init
dquot_init_hash(void)
1169 printk(KERN_NOTICE
"VFS: Diskquotas version %s initialized\n", __DQUOT_VERSION__
);
1171 dquot_cachep
= kmem_cache_create("dquot", sizeof(struct dquot
),
1172 sizeof(unsigned long) * 4,
1173 SLAB_HWCACHE_ALIGN
, NULL
, NULL
);
1176 panic("Cannot create dquot SLAB cache\n");
1178 memset(dquot_hash
, 0, sizeof(dquot_hash
));
1179 memset((caddr_t
)&dqstats
, 0, sizeof(dqstats
));
1183 * Definitions of diskquota operations.
1185 struct dquot_operations dquot_operations
= {
1186 dquot_initialize
, /* mandatory */
1187 dquot_drop
, /* mandatory */
1195 static inline void set_enable_flags(struct vfsmount
*vfsmnt
, short type
)
1199 vfsmnt
->mnt_dquot
.flags
|= DQUOT_USR_ENABLED
;
1202 vfsmnt
->mnt_dquot
.flags
|= DQUOT_GRP_ENABLED
;
1207 static inline void reset_enable_flags(struct vfsmount
*vfsmnt
, short type
)
1211 vfsmnt
->mnt_dquot
.flags
&= ~DQUOT_USR_ENABLED
;
1214 vfsmnt
->mnt_dquot
.flags
&= ~DQUOT_GRP_ENABLED
;
1220 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
1222 int quota_off(kdev_t dev
, short type
)
1224 struct vfsmount
*vfsmnt
;
1228 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1229 if (type
!= -1 && cnt
!= type
)
1232 vfsmnt
= lookup_vfsmnt(dev
);
1235 if (!vfsmnt
->mnt_sb
)
1237 if (!is_enabled(vfsmnt
, cnt
))
1239 reset_enable_flags(vfsmnt
, cnt
);
1241 /* Note: these are blocking operations */
1242 reset_dquot_ptrs(dev
, cnt
);
1243 invalidate_dquots(dev
, cnt
);
1245 filp
= vfsmnt
->mnt_dquot
.files
[cnt
];
1246 vfsmnt
->mnt_dquot
.files
[cnt
] = (struct file
*)NULL
;
1247 vfsmnt
->mnt_dquot
.inode_expire
[cnt
] = 0;
1248 vfsmnt
->mnt_dquot
.block_expire
[cnt
] = 0;
1253 * Check whether any quota is still enabled,
1254 * and if not clear the dq_op pointer.
1256 vfsmnt
= lookup_vfsmnt(dev
);
1257 if (vfsmnt
&& vfsmnt
->mnt_sb
) {
1259 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1260 enabled
|= is_enabled(vfsmnt
, cnt
);
1262 vfsmnt
->mnt_sb
->dq_op
= NULL
;
1269 int quota_on(kdev_t dev
, short type
, char *path
)
1272 struct vfsmount
*vfsmnt
;
1273 struct inode
*inode
;
1274 struct dquot
*dquot
;
1275 struct quota_mount_options
*mnt_dquot
;
1279 vfsmnt
= lookup_vfsmnt(dev
);
1280 if (vfsmnt
== (struct vfsmount
*)NULL
)
1283 if (is_enabled(vfsmnt
, type
))
1285 mnt_dquot
= &vfsmnt
->mnt_dquot
;
1287 tmp
= getname(path
);
1288 error
= PTR_ERR(tmp
);
1292 f
= filp_open(tmp
, O_RDWR
, 0600);
1299 if (!f
->f_op
->read
&& !f
->f_op
->write
)
1301 inode
= f
->f_dentry
->d_inode
;
1303 if (!S_ISREG(inode
->i_mode
))
1306 if (inode
->i_size
== 0 || (inode
->i_size
% sizeof(struct dqblk
)) != 0)
1309 /* OK, there we go */
1310 set_enable_flags(vfsmnt
, type
);
1311 mnt_dquot
->files
[type
] = f
;
1313 dquot
= dqget(dev
, 0, type
);
1314 mnt_dquot
->inode_expire
[type
] = (dquot
) ? dquot
->dq_itime
: MAX_IQ_TIME
;
1315 mnt_dquot
->block_expire
[type
] = (dquot
) ? dquot
->dq_btime
: MAX_DQ_TIME
;
1318 vfsmnt
->mnt_sb
->dq_op
= &dquot_operations
;
1319 add_dquot_ref(dev
, type
);
1329 * This is the system call interface. This communicates with
1330 * the user-level programs. Currently this only supports diskquota
1331 * calls. Maybe we need to add the process quotas etc. in the future,
1332 * but we probably should use rlimits for that.
1334 asmlinkage
int sys_quotactl(int cmd
, const char *special
, int id
, caddr_t addr
)
1336 int cmds
= 0, type
= 0, flags
= 0;
1341 cmds
= cmd
>> SUBCMDSHIFT
;
1342 type
= cmd
& SUBCMDMASK
;
1344 if ((u_int
) type
>= MAXQUOTAS
)
1352 if (((type
== USRQUOTA
&& current
->uid
!= id
) ||
1353 (type
== GRPQUOTA
&& current
->gid
!= id
)) &&
1354 !capable(CAP_SYS_RESOURCE
))
1358 if (!capable(CAP_SYS_RESOURCE
))
1364 if (special
!= NULL
|| (cmds
!= Q_SYNC
&& cmds
!= Q_GETSTATS
)) {
1366 struct dentry
* dentry
;
1368 dentry
= namei(special
);
1372 dev
= dentry
->d_inode
->i_rdev
;
1373 mode
= dentry
->d_inode
->i_mode
;
1384 ret
= quota_on(dev
, type
, (char *) addr
);
1387 ret
= quota_off(dev
, type
);
1390 ret
= get_quota(dev
, id
, type
, (struct dqblk
*) addr
);
1399 flags
|= SET_QLIMIT
;
1402 ret
= sync_dquots(dev
, type
);
1405 ret
= get_stats(addr
);
1408 ret
= quota_root_squash(dev
, type
, (int *) addr
);
1414 flags
|= QUOTA_SYSCALL
;
1417 if (dev_has_quota_enabled(dev
, type
))
1418 ret
= set_dqblk(dev
, id
, type
, flags
, (struct dqblk
*) addr
);