2 * Implementation of the diskquota system for the LINUX operating system. QUOTA
3 * is implemented using the BSD system call interface as the means of
4 * communication with the user level. This file contains the generic routines
5 * called by the different filesystems on allocation of an inode or block.
6 * These routines take care of the administration needed to have a consistent
7 * diskquota tracking system. The ideas of both user and group quotas are based
8 * on the Melbourne quota system as used on BSD derived systems. The internal
9 * implementation is based on one of the several variants of the LINUX
10 * inode-subsystem with added complexity of the diskquota system.
12 * Author: Marco van Wieringen <mvw@planets.elm.net>
14 * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
16 * Revised list management to avoid races
17 * -- Bill Hawes, <whawes@star.net>, 9/98
19 * Fixed races in dquot_transfer(), dqget() and dquot_alloc_...().
20 * As the consequence the locking was moved from dquot_decr_...(),
21 * dquot_incr_...() to calling functions.
22 * invalidate_dquots() now writes modified dquots.
23 * Serialized quota_off() and quota_on() for mount point.
24 * Fixed a few bugs in grow_dquots().
25 * Fixed deadlock in write_dquot() - we no longer account quotas on
27 * remove_dquot_ref() moved to inode.c - it now traverses through inodes
28 * add_dquot_ref() restarts after blocking
29 * Added check for bogus uid and fixed check for group in quotactl.
30 * Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99
32 * Used struct list_head instead of own list struct
33 * Invalidation of referenced dquots is no longer possible
34 * Improved free_dquots list management
35 * Quota and i_blocks are now updated in one place to avoid races
36 * Warnings are now delayed so we won't block in critical section
37 * Write updated not to require dquot lock
38 * Jan Kara, <jack@suse.cz>, 9/2000
40 * Added dynamic quota structure allocation
41 * Jan Kara <jack@suse.cz> 12/2000
43 * Rewritten quota interface. Implemented new quota format and
44 * formats registering.
45 * Jan Kara, <jack@suse.cz>, 2001,2002
48 * Jan Kara, <jack@suse.cz>, 10/2002
50 * Added journalled quota support, fix lock inversion problems
51 * Jan Kara, <jack@suse.cz>, 2003,2004
53 * (C) Copyright 1994 - 1997 Marco van Wieringen
56 #include <linux/errno.h>
57 #include <linux/kernel.h>
59 #include <linux/mount.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> /* for inode_lock, oddly enough.. */
81 #include <asm/uaccess.h>
83 #define __DQUOT_PARANOIA
86 * There are three quota SMP locks. dq_list_lock protects all lists with quotas
87 * and quota formats, dqstats structure containing statistics about the lists
88 * dq_data_lock protects data from dq_dqb and also mem_dqinfo structures and
89 * also guards consistency of dquot->dq_dqb with inode->i_blocks, i_bytes.
90 * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly
91 * in inode_add_bytes() and inode_sub_bytes(). dq_state_lock protects
92 * modifications of quota state (on quotaon and quotaoff) and readers who care
93 * about latest values take it as well.
95 * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock,
96 * dq_list_lock > dq_state_lock
98 * Note that some things (eg. sb pointer, type, id) doesn't change during
99 * the life of the dquot structure and so needn't to be protected by a lock
101 * Any operation working on dquots via inode pointers must hold dqptr_sem. If
102 * operation is just reading pointers from inode (or not using them at all) the
103 * read lock is enough. If pointers are altered function must hold write lock
104 * (these locking rules also apply for S_NOQUOTA flag in the inode - note that
105 * for altering the flag i_mutex is also needed).
107 * Each dquot has its dq_lock mutex. Locked dquots might not be referenced
108 * from inodes (dquot_alloc_space() and such don't check the dq_lock).
109 * Currently dquot is locked only when it is being read to memory (or space for
110 * it is being allocated) on the first dqget() and when it is being released on
111 * the last dqput(). The allocation and release oparations are serialized by
112 * the dq_lock and by checking the use count in dquot_release(). Write
113 * operations on dquots don't hold dq_lock as they copy data under dq_data_lock
114 * spinlock to internal buffers before writing.
116 * Lock ordering (including related VFS locks) is the following:
117 * i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock >
119 * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem >
120 * dqptr_sem. But filesystem has to count with the fact that functions such as
121 * dquot_alloc_space() acquire dqptr_sem and they usually have to be called
122 * from inside a transaction to keep filesystem consistency after a crash. Also
123 * filesystems usually want to do some IO on dquot from ->mark_dirty which is
124 * called with dqptr_sem held.
125 * i_mutex on quota files is special (it's below dqio_mutex)
128 static __cacheline_aligned_in_smp
DEFINE_SPINLOCK(dq_list_lock
);
129 static __cacheline_aligned_in_smp
DEFINE_SPINLOCK(dq_state_lock
);
130 __cacheline_aligned_in_smp
DEFINE_SPINLOCK(dq_data_lock
);
131 EXPORT_SYMBOL(dq_data_lock
);
133 static char *quotatypes
[] = INITQFNAMES
;
134 static struct quota_format_type
*quota_formats
; /* List of registered formats */
135 static struct quota_module_name module_names
[] = INIT_QUOTA_MODULE_NAMES
;
137 /* SLAB cache for dquot structures */
138 static struct kmem_cache
*dquot_cachep
;
140 int register_quota_format(struct quota_format_type
*fmt
)
142 spin_lock(&dq_list_lock
);
143 fmt
->qf_next
= quota_formats
;
145 spin_unlock(&dq_list_lock
);
148 EXPORT_SYMBOL(register_quota_format
);
150 void unregister_quota_format(struct quota_format_type
*fmt
)
152 struct quota_format_type
**actqf
;
154 spin_lock(&dq_list_lock
);
155 for (actqf
= "a_formats
; *actqf
&& *actqf
!= fmt
;
156 actqf
= &(*actqf
)->qf_next
)
159 *actqf
= (*actqf
)->qf_next
;
160 spin_unlock(&dq_list_lock
);
162 EXPORT_SYMBOL(unregister_quota_format
);
164 static struct quota_format_type
*find_quota_format(int id
)
166 struct quota_format_type
*actqf
;
168 spin_lock(&dq_list_lock
);
169 for (actqf
= quota_formats
; actqf
&& actqf
->qf_fmt_id
!= id
;
170 actqf
= actqf
->qf_next
)
172 if (!actqf
|| !try_module_get(actqf
->qf_owner
)) {
175 spin_unlock(&dq_list_lock
);
177 for (qm
= 0; module_names
[qm
].qm_fmt_id
&&
178 module_names
[qm
].qm_fmt_id
!= id
; qm
++)
180 if (!module_names
[qm
].qm_fmt_id
||
181 request_module(module_names
[qm
].qm_mod_name
))
184 spin_lock(&dq_list_lock
);
185 for (actqf
= quota_formats
; actqf
&& actqf
->qf_fmt_id
!= id
;
186 actqf
= actqf
->qf_next
)
188 if (actqf
&& !try_module_get(actqf
->qf_owner
))
191 spin_unlock(&dq_list_lock
);
195 static void put_quota_format(struct quota_format_type
*fmt
)
197 module_put(fmt
->qf_owner
);
201 * Dquot List Management:
202 * The quota code uses three lists for dquot management: the inuse_list,
203 * free_dquots, and dquot_hash[] array. A single dquot structure may be
204 * on all three lists, depending on its current state.
206 * All dquots are placed to the end of inuse_list when first created, and this
207 * list is used for invalidate operation, which must look at every dquot.
209 * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
210 * and this list is searched whenever we need an available dquot. Dquots are
211 * removed from the list as soon as they are used again, and
212 * dqstats.free_dquots gives the number of dquots on the list. When
213 * dquot is invalidated it's completely released from memory.
215 * Dquots with a specific identity (device, type and id) are placed on
216 * one of the dquot_hash[] hash chains. The provides an efficient search
217 * mechanism to locate a specific dquot.
220 static LIST_HEAD(inuse_list
);
221 static LIST_HEAD(free_dquots
);
222 static unsigned int dq_hash_bits
, dq_hash_mask
;
223 static struct hlist_head
*dquot_hash
;
225 struct dqstats dqstats
;
226 EXPORT_SYMBOL(dqstats
);
228 static inline unsigned int
229 hashfn(const struct super_block
*sb
, unsigned int id
, int type
)
233 tmp
= (((unsigned long)sb
>>L1_CACHE_SHIFT
) ^ id
) * (MAXQUOTAS
- type
);
234 return (tmp
+ (tmp
>> dq_hash_bits
)) & dq_hash_mask
;
238 * Following list functions expect dq_list_lock to be held
240 static inline void insert_dquot_hash(struct dquot
*dquot
)
242 struct hlist_head
*head
;
243 head
= dquot_hash
+ hashfn(dquot
->dq_sb
, dquot
->dq_id
, dquot
->dq_type
);
244 hlist_add_head(&dquot
->dq_hash
, head
);
247 static inline void remove_dquot_hash(struct dquot
*dquot
)
249 hlist_del_init(&dquot
->dq_hash
);
252 static struct dquot
*find_dquot(unsigned int hashent
, struct super_block
*sb
,
253 unsigned int id
, int type
)
255 struct hlist_node
*node
;
258 hlist_for_each (node
, dquot_hash
+hashent
) {
259 dquot
= hlist_entry(node
, struct dquot
, dq_hash
);
260 if (dquot
->dq_sb
== sb
&& dquot
->dq_id
== id
&&
261 dquot
->dq_type
== type
)
267 /* Add a dquot to the tail of the free list */
268 static inline void put_dquot_last(struct dquot
*dquot
)
270 list_add_tail(&dquot
->dq_free
, &free_dquots
);
271 dqstats
.free_dquots
++;
274 static inline void remove_free_dquot(struct dquot
*dquot
)
276 if (list_empty(&dquot
->dq_free
))
278 list_del_init(&dquot
->dq_free
);
279 dqstats
.free_dquots
--;
282 static inline void put_inuse(struct dquot
*dquot
)
284 /* We add to the back of inuse list so we don't have to restart
285 * when traversing this list and we block */
286 list_add_tail(&dquot
->dq_inuse
, &inuse_list
);
287 dqstats
.allocated_dquots
++;
290 static inline void remove_inuse(struct dquot
*dquot
)
292 dqstats
.allocated_dquots
--;
293 list_del(&dquot
->dq_inuse
);
296 * End of list functions needing dq_list_lock
299 static void wait_on_dquot(struct dquot
*dquot
)
301 mutex_lock(&dquot
->dq_lock
);
302 mutex_unlock(&dquot
->dq_lock
);
305 static inline int dquot_dirty(struct dquot
*dquot
)
307 return test_bit(DQ_MOD_B
, &dquot
->dq_flags
);
310 static inline int mark_dquot_dirty(struct dquot
*dquot
)
312 return dquot
->dq_sb
->dq_op
->mark_dirty(dquot
);
315 int dquot_mark_dquot_dirty(struct dquot
*dquot
)
317 spin_lock(&dq_list_lock
);
318 if (!test_and_set_bit(DQ_MOD_B
, &dquot
->dq_flags
))
319 list_add(&dquot
->dq_dirty
, &sb_dqopt(dquot
->dq_sb
)->
320 info
[dquot
->dq_type
].dqi_dirty_list
);
321 spin_unlock(&dq_list_lock
);
324 EXPORT_SYMBOL(dquot_mark_dquot_dirty
);
326 /* Dirtify all the dquots - this can block when journalling */
327 static inline int mark_all_dquot_dirty(struct dquot
* const *dquot
)
332 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
334 /* Even in case of error we have to continue */
335 ret
= mark_dquot_dirty(dquot
[cnt
]);
342 static inline void dqput_all(struct dquot
**dquot
)
346 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
350 /* This function needs dq_list_lock */
351 static inline int clear_dquot_dirty(struct dquot
*dquot
)
353 if (!test_and_clear_bit(DQ_MOD_B
, &dquot
->dq_flags
))
355 list_del_init(&dquot
->dq_dirty
);
359 void mark_info_dirty(struct super_block
*sb
, int type
)
361 set_bit(DQF_INFO_DIRTY_B
, &sb_dqopt(sb
)->info
[type
].dqi_flags
);
363 EXPORT_SYMBOL(mark_info_dirty
);
366 * Read dquot from disk and alloc space for it
369 int dquot_acquire(struct dquot
*dquot
)
371 int ret
= 0, ret2
= 0;
372 struct quota_info
*dqopt
= sb_dqopt(dquot
->dq_sb
);
374 mutex_lock(&dquot
->dq_lock
);
375 mutex_lock(&dqopt
->dqio_mutex
);
376 if (!test_bit(DQ_READ_B
, &dquot
->dq_flags
))
377 ret
= dqopt
->ops
[dquot
->dq_type
]->read_dqblk(dquot
);
380 set_bit(DQ_READ_B
, &dquot
->dq_flags
);
381 /* Instantiate dquot if needed */
382 if (!test_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
) && !dquot
->dq_off
) {
383 ret
= dqopt
->ops
[dquot
->dq_type
]->commit_dqblk(dquot
);
384 /* Write the info if needed */
385 if (info_dirty(&dqopt
->info
[dquot
->dq_type
])) {
386 ret2
= dqopt
->ops
[dquot
->dq_type
]->write_file_info(
387 dquot
->dq_sb
, dquot
->dq_type
);
396 set_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
);
398 mutex_unlock(&dqopt
->dqio_mutex
);
399 mutex_unlock(&dquot
->dq_lock
);
402 EXPORT_SYMBOL(dquot_acquire
);
405 * Write dquot to disk
407 int dquot_commit(struct dquot
*dquot
)
409 int ret
= 0, ret2
= 0;
410 struct quota_info
*dqopt
= sb_dqopt(dquot
->dq_sb
);
412 mutex_lock(&dqopt
->dqio_mutex
);
413 spin_lock(&dq_list_lock
);
414 if (!clear_dquot_dirty(dquot
)) {
415 spin_unlock(&dq_list_lock
);
418 spin_unlock(&dq_list_lock
);
419 /* Inactive dquot can be only if there was error during read/init
420 * => we have better not writing it */
421 if (test_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
)) {
422 ret
= dqopt
->ops
[dquot
->dq_type
]->commit_dqblk(dquot
);
423 if (info_dirty(&dqopt
->info
[dquot
->dq_type
])) {
424 ret2
= dqopt
->ops
[dquot
->dq_type
]->write_file_info(
425 dquot
->dq_sb
, dquot
->dq_type
);
431 mutex_unlock(&dqopt
->dqio_mutex
);
434 EXPORT_SYMBOL(dquot_commit
);
439 int dquot_release(struct dquot
*dquot
)
441 int ret
= 0, ret2
= 0;
442 struct quota_info
*dqopt
= sb_dqopt(dquot
->dq_sb
);
444 mutex_lock(&dquot
->dq_lock
);
445 /* Check whether we are not racing with some other dqget() */
446 if (atomic_read(&dquot
->dq_count
) > 1)
448 mutex_lock(&dqopt
->dqio_mutex
);
449 if (dqopt
->ops
[dquot
->dq_type
]->release_dqblk
) {
450 ret
= dqopt
->ops
[dquot
->dq_type
]->release_dqblk(dquot
);
452 if (info_dirty(&dqopt
->info
[dquot
->dq_type
])) {
453 ret2
= dqopt
->ops
[dquot
->dq_type
]->write_file_info(
454 dquot
->dq_sb
, dquot
->dq_type
);
459 clear_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
);
460 mutex_unlock(&dqopt
->dqio_mutex
);
462 mutex_unlock(&dquot
->dq_lock
);
465 EXPORT_SYMBOL(dquot_release
);
467 void dquot_destroy(struct dquot
*dquot
)
469 kmem_cache_free(dquot_cachep
, dquot
);
471 EXPORT_SYMBOL(dquot_destroy
);
473 static inline void do_destroy_dquot(struct dquot
*dquot
)
475 dquot
->dq_sb
->dq_op
->destroy_dquot(dquot
);
478 /* Invalidate all dquots on the list. Note that this function is called after
479 * quota is disabled and pointers from inodes removed so there cannot be new
480 * quota users. There can still be some users of quotas due to inodes being
481 * just deleted or pruned by prune_icache() (those are not attached to any
482 * list) or parallel quotactl call. We have to wait for such users.
484 static void invalidate_dquots(struct super_block
*sb
, int type
)
486 struct dquot
*dquot
, *tmp
;
489 spin_lock(&dq_list_lock
);
490 list_for_each_entry_safe(dquot
, tmp
, &inuse_list
, dq_inuse
) {
491 if (dquot
->dq_sb
!= sb
)
493 if (dquot
->dq_type
!= type
)
495 /* Wait for dquot users */
496 if (atomic_read(&dquot
->dq_count
)) {
499 atomic_inc(&dquot
->dq_count
);
500 prepare_to_wait(&dquot
->dq_wait_unused
, &wait
,
501 TASK_UNINTERRUPTIBLE
);
502 spin_unlock(&dq_list_lock
);
503 /* Once dqput() wakes us up, we know it's time to free
505 * IMPORTANT: we rely on the fact that there is always
506 * at most one process waiting for dquot to free.
507 * Otherwise dq_count would be > 1 and we would never
510 if (atomic_read(&dquot
->dq_count
) > 1)
512 finish_wait(&dquot
->dq_wait_unused
, &wait
);
514 /* At this moment dquot() need not exist (it could be
515 * reclaimed by prune_dqcache(). Hence we must
520 * Quota now has no users and it has been written on last
523 remove_dquot_hash(dquot
);
524 remove_free_dquot(dquot
);
526 do_destroy_dquot(dquot
);
528 spin_unlock(&dq_list_lock
);
531 /* Call callback for every active dquot on given filesystem */
532 int dquot_scan_active(struct super_block
*sb
,
533 int (*fn
)(struct dquot
*dquot
, unsigned long priv
),
536 struct dquot
*dquot
, *old_dquot
= NULL
;
539 mutex_lock(&sb_dqopt(sb
)->dqonoff_mutex
);
540 spin_lock(&dq_list_lock
);
541 list_for_each_entry(dquot
, &inuse_list
, dq_inuse
) {
542 if (!test_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
))
544 if (dquot
->dq_sb
!= sb
)
546 /* Now we have active dquot so we can just increase use count */
547 atomic_inc(&dquot
->dq_count
);
549 spin_unlock(&dq_list_lock
);
552 ret
= fn(dquot
, priv
);
555 spin_lock(&dq_list_lock
);
556 /* We are safe to continue now because our dquot could not
557 * be moved out of the inuse list while we hold the reference */
559 spin_unlock(&dq_list_lock
);
562 mutex_unlock(&sb_dqopt(sb
)->dqonoff_mutex
);
565 EXPORT_SYMBOL(dquot_scan_active
);
567 int vfs_quota_sync(struct super_block
*sb
, int type
)
569 struct list_head
*dirty
;
571 struct quota_info
*dqopt
= sb_dqopt(sb
);
574 mutex_lock(&dqopt
->dqonoff_mutex
);
575 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
576 if (type
!= -1 && cnt
!= type
)
578 if (!sb_has_quota_active(sb
, cnt
))
580 spin_lock(&dq_list_lock
);
581 dirty
= &dqopt
->info
[cnt
].dqi_dirty_list
;
582 while (!list_empty(dirty
)) {
583 dquot
= list_first_entry(dirty
, struct dquot
,
585 /* Dirty and inactive can be only bad dquot... */
586 if (!test_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
)) {
587 clear_dquot_dirty(dquot
);
590 /* Now we have active dquot from which someone is
591 * holding reference so we can safely just increase
593 atomic_inc(&dquot
->dq_count
);
595 spin_unlock(&dq_list_lock
);
596 sb
->dq_op
->write_dquot(dquot
);
598 spin_lock(&dq_list_lock
);
600 spin_unlock(&dq_list_lock
);
603 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
604 if ((cnt
== type
|| type
== -1) && sb_has_quota_active(sb
, cnt
)
605 && info_dirty(&dqopt
->info
[cnt
]))
606 sb
->dq_op
->write_info(sb
, cnt
);
607 spin_lock(&dq_list_lock
);
609 spin_unlock(&dq_list_lock
);
610 mutex_unlock(&dqopt
->dqonoff_mutex
);
614 EXPORT_SYMBOL(vfs_quota_sync
);
616 /* Free unused dquots from cache */
617 static void prune_dqcache(int count
)
619 struct list_head
*head
;
622 head
= free_dquots
.prev
;
623 while (head
!= &free_dquots
&& count
) {
624 dquot
= list_entry(head
, struct dquot
, dq_free
);
625 remove_dquot_hash(dquot
);
626 remove_free_dquot(dquot
);
628 do_destroy_dquot(dquot
);
630 head
= free_dquots
.prev
;
635 * This is called from kswapd when we think we need some
639 static int shrink_dqcache_memory(int nr
, gfp_t gfp_mask
)
642 spin_lock(&dq_list_lock
);
644 spin_unlock(&dq_list_lock
);
646 return (dqstats
.free_dquots
/ 100) * sysctl_vfs_cache_pressure
;
649 static struct shrinker dqcache_shrinker
= {
650 .shrink
= shrink_dqcache_memory
,
651 .seeks
= DEFAULT_SEEKS
,
655 * Put reference to dquot
656 * NOTE: If you change this function please check whether dqput_blocks() works right...
658 void dqput(struct dquot
*dquot
)
664 #ifdef __DQUOT_PARANOIA
665 if (!atomic_read(&dquot
->dq_count
)) {
666 printk("VFS: dqput: trying to free free dquot\n");
667 printk("VFS: device %s, dquot of %s %d\n",
669 quotatypes
[dquot
->dq_type
],
675 spin_lock(&dq_list_lock
);
677 spin_unlock(&dq_list_lock
);
679 spin_lock(&dq_list_lock
);
680 if (atomic_read(&dquot
->dq_count
) > 1) {
681 /* We have more than one user... nothing to do */
682 atomic_dec(&dquot
->dq_count
);
683 /* Releasing dquot during quotaoff phase? */
684 if (!sb_has_quota_active(dquot
->dq_sb
, dquot
->dq_type
) &&
685 atomic_read(&dquot
->dq_count
) == 1)
686 wake_up(&dquot
->dq_wait_unused
);
687 spin_unlock(&dq_list_lock
);
690 /* Need to release dquot? */
691 if (test_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
) && dquot_dirty(dquot
)) {
692 spin_unlock(&dq_list_lock
);
693 /* Commit dquot before releasing */
694 ret
= dquot
->dq_sb
->dq_op
->write_dquot(dquot
);
696 printk(KERN_ERR
"VFS: cannot write quota structure on "
697 "device %s (error %d). Quota may get out of "
698 "sync!\n", dquot
->dq_sb
->s_id
, ret
);
700 * We clear dirty bit anyway, so that we avoid
703 spin_lock(&dq_list_lock
);
704 clear_dquot_dirty(dquot
);
705 spin_unlock(&dq_list_lock
);
709 /* Clear flag in case dquot was inactive (something bad happened) */
710 clear_dquot_dirty(dquot
);
711 if (test_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
)) {
712 spin_unlock(&dq_list_lock
);
713 dquot
->dq_sb
->dq_op
->release_dquot(dquot
);
716 atomic_dec(&dquot
->dq_count
);
717 #ifdef __DQUOT_PARANOIA
719 BUG_ON(!list_empty(&dquot
->dq_free
));
721 put_dquot_last(dquot
);
722 spin_unlock(&dq_list_lock
);
724 EXPORT_SYMBOL(dqput
);
726 struct dquot
*dquot_alloc(struct super_block
*sb
, int type
)
728 return kmem_cache_zalloc(dquot_cachep
, GFP_NOFS
);
730 EXPORT_SYMBOL(dquot_alloc
);
732 static struct dquot
*get_empty_dquot(struct super_block
*sb
, int type
)
736 dquot
= sb
->dq_op
->alloc_dquot(sb
, type
);
740 mutex_init(&dquot
->dq_lock
);
741 INIT_LIST_HEAD(&dquot
->dq_free
);
742 INIT_LIST_HEAD(&dquot
->dq_inuse
);
743 INIT_HLIST_NODE(&dquot
->dq_hash
);
744 INIT_LIST_HEAD(&dquot
->dq_dirty
);
745 init_waitqueue_head(&dquot
->dq_wait_unused
);
747 dquot
->dq_type
= type
;
748 atomic_set(&dquot
->dq_count
, 1);
754 * Get reference to dquot
756 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
757 * destroying our dquot by:
758 * a) checking for quota flags under dq_list_lock and
759 * b) getting a reference to dquot before we release dq_list_lock
761 struct dquot
*dqget(struct super_block
*sb
, unsigned int id
, int type
)
763 unsigned int hashent
= hashfn(sb
, id
, type
);
764 struct dquot
*dquot
= NULL
, *empty
= NULL
;
766 if (!sb_has_quota_active(sb
, type
))
769 spin_lock(&dq_list_lock
);
770 spin_lock(&dq_state_lock
);
771 if (!sb_has_quota_active(sb
, type
)) {
772 spin_unlock(&dq_state_lock
);
773 spin_unlock(&dq_list_lock
);
776 spin_unlock(&dq_state_lock
);
778 dquot
= find_dquot(hashent
, sb
, id
, type
);
781 spin_unlock(&dq_list_lock
);
782 empty
= get_empty_dquot(sb
, type
);
784 schedule(); /* Try to wait for a moment... */
790 /* all dquots go on the inuse_list */
792 /* hash it first so it can be found */
793 insert_dquot_hash(dquot
);
795 spin_unlock(&dq_list_lock
);
797 if (!atomic_read(&dquot
->dq_count
))
798 remove_free_dquot(dquot
);
799 atomic_inc(&dquot
->dq_count
);
800 dqstats
.cache_hits
++;
802 spin_unlock(&dq_list_lock
);
804 /* Wait for dq_lock - after this we know that either dquot_release() is
805 * already finished or it will be canceled due to dq_count > 1 test */
806 wait_on_dquot(dquot
);
807 /* Read the dquot / allocate space in quota file */
808 if (!test_bit(DQ_ACTIVE_B
, &dquot
->dq_flags
) &&
809 sb
->dq_op
->acquire_dquot(dquot
) < 0) {
814 #ifdef __DQUOT_PARANOIA
815 BUG_ON(!dquot
->dq_sb
); /* Has somebody invalidated entry under us? */
819 do_destroy_dquot(empty
);
823 EXPORT_SYMBOL(dqget
);
825 static int dqinit_needed(struct inode
*inode
, int type
)
829 if (IS_NOQUOTA(inode
))
832 return !inode
->i_dquot
[type
];
833 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
834 if (!inode
->i_dquot
[cnt
])
839 /* This routine is guarded by dqonoff_mutex mutex */
840 static void add_dquot_ref(struct super_block
*sb
, int type
)
842 struct inode
*inode
, *old_inode
= NULL
;
844 spin_lock(&inode_lock
);
845 list_for_each_entry(inode
, &sb
->s_inodes
, i_sb_list
) {
846 if (inode
->i_state
& (I_FREEING
|I_CLEAR
|I_WILL_FREE
|I_NEW
))
848 if (!atomic_read(&inode
->i_writecount
))
850 if (!dqinit_needed(inode
, type
))
854 spin_unlock(&inode_lock
);
857 sb
->dq_op
->initialize(inode
, type
);
858 /* We hold a reference to 'inode' so it couldn't have been
859 * removed from s_inodes list while we dropped the inode_lock.
860 * We cannot iput the inode now as we can be holding the last
861 * reference and we cannot iput it under inode_lock. So we
862 * keep the reference and iput it later. */
864 spin_lock(&inode_lock
);
866 spin_unlock(&inode_lock
);
871 * Return 0 if dqput() won't block.
872 * (note that 1 doesn't necessarily mean blocking)
874 static inline int dqput_blocks(struct dquot
*dquot
)
876 if (atomic_read(&dquot
->dq_count
) <= 1)
882 * Remove references to dquots from inode and add dquot to list for freeing
883 * if we have the last referece to dquot
884 * We can't race with anybody because we hold dqptr_sem for writing...
886 static int remove_inode_dquot_ref(struct inode
*inode
, int type
,
887 struct list_head
*tofree_head
)
889 struct dquot
*dquot
= inode
->i_dquot
[type
];
891 inode
->i_dquot
[type
] = NULL
;
893 if (dqput_blocks(dquot
)) {
894 #ifdef __DQUOT_PARANOIA
895 if (atomic_read(&dquot
->dq_count
) != 1)
896 printk(KERN_WARNING
"VFS: Adding dquot with dq_count %d to dispose list.\n", atomic_read(&dquot
->dq_count
));
898 spin_lock(&dq_list_lock
);
899 /* As dquot must have currently users it can't be on
900 * the free list... */
901 list_add(&dquot
->dq_free
, tofree_head
);
902 spin_unlock(&dq_list_lock
);
906 dqput(dquot
); /* We have guaranteed we won't block */
912 * Free list of dquots
913 * Dquots are removed from inodes and no new references can be got so we are
914 * the only ones holding reference
916 static void put_dquot_list(struct list_head
*tofree_head
)
918 struct list_head
*act_head
;
921 act_head
= tofree_head
->next
;
922 while (act_head
!= tofree_head
) {
923 dquot
= list_entry(act_head
, struct dquot
, dq_free
);
924 act_head
= act_head
->next
;
925 /* Remove dquot from the list so we won't have problems... */
926 list_del_init(&dquot
->dq_free
);
931 static void remove_dquot_ref(struct super_block
*sb
, int type
,
932 struct list_head
*tofree_head
)
936 spin_lock(&inode_lock
);
937 list_for_each_entry(inode
, &sb
->s_inodes
, i_sb_list
) {
939 * We have to scan also I_NEW inodes because they can already
940 * have quota pointer initialized. Luckily, we need to touch
941 * only quota pointers and these have separate locking
944 if (!IS_NOQUOTA(inode
))
945 remove_inode_dquot_ref(inode
, type
, tofree_head
);
947 spin_unlock(&inode_lock
);
950 /* Gather all references from inodes and drop them */
951 static void drop_dquot_ref(struct super_block
*sb
, int type
)
953 LIST_HEAD(tofree_head
);
956 down_write(&sb_dqopt(sb
)->dqptr_sem
);
957 remove_dquot_ref(sb
, type
, &tofree_head
);
958 up_write(&sb_dqopt(sb
)->dqptr_sem
);
959 put_dquot_list(&tofree_head
);
963 static inline void dquot_incr_inodes(struct dquot
*dquot
, qsize_t number
)
965 dquot
->dq_dqb
.dqb_curinodes
+= number
;
968 static inline void dquot_incr_space(struct dquot
*dquot
, qsize_t number
)
970 dquot
->dq_dqb
.dqb_curspace
+= number
;
973 static inline void dquot_resv_space(struct dquot
*dquot
, qsize_t number
)
975 dquot
->dq_dqb
.dqb_rsvspace
+= number
;
979 * Claim reserved quota space
981 static void dquot_claim_reserved_space(struct dquot
*dquot
,
984 WARN_ON(dquot
->dq_dqb
.dqb_rsvspace
< number
);
985 dquot
->dq_dqb
.dqb_curspace
+= number
;
986 dquot
->dq_dqb
.dqb_rsvspace
-= number
;
990 void dquot_free_reserved_space(struct dquot
*dquot
, qsize_t number
)
992 dquot
->dq_dqb
.dqb_rsvspace
-= number
;
995 static void dquot_decr_inodes(struct dquot
*dquot
, qsize_t number
)
997 if (sb_dqopt(dquot
->dq_sb
)->flags
& DQUOT_NEGATIVE_USAGE
||
998 dquot
->dq_dqb
.dqb_curinodes
>= number
)
999 dquot
->dq_dqb
.dqb_curinodes
-= number
;
1001 dquot
->dq_dqb
.dqb_curinodes
= 0;
1002 if (dquot
->dq_dqb
.dqb_curinodes
<= dquot
->dq_dqb
.dqb_isoftlimit
)
1003 dquot
->dq_dqb
.dqb_itime
= (time_t) 0;
1004 clear_bit(DQ_INODES_B
, &dquot
->dq_flags
);
1007 static void dquot_decr_space(struct dquot
*dquot
, qsize_t number
)
1009 if (sb_dqopt(dquot
->dq_sb
)->flags
& DQUOT_NEGATIVE_USAGE
||
1010 dquot
->dq_dqb
.dqb_curspace
>= number
)
1011 dquot
->dq_dqb
.dqb_curspace
-= number
;
1013 dquot
->dq_dqb
.dqb_curspace
= 0;
1014 if (dquot
->dq_dqb
.dqb_curspace
<= dquot
->dq_dqb
.dqb_bsoftlimit
)
1015 dquot
->dq_dqb
.dqb_btime
= (time_t) 0;
1016 clear_bit(DQ_BLKS_B
, &dquot
->dq_flags
);
1019 static int warning_issued(struct dquot
*dquot
, const int warntype
)
1021 int flag
= (warntype
== QUOTA_NL_BHARDWARN
||
1022 warntype
== QUOTA_NL_BSOFTLONGWARN
) ? DQ_BLKS_B
:
1023 ((warntype
== QUOTA_NL_IHARDWARN
||
1024 warntype
== QUOTA_NL_ISOFTLONGWARN
) ? DQ_INODES_B
: 0);
1028 return test_and_set_bit(flag
, &dquot
->dq_flags
);
1031 #ifdef CONFIG_PRINT_QUOTA_WARNING
1032 static int flag_print_warnings
= 1;
1034 static int need_print_warning(struct dquot
*dquot
)
1036 if (!flag_print_warnings
)
1039 switch (dquot
->dq_type
) {
1041 return current_fsuid() == dquot
->dq_id
;
1043 return in_group_p(dquot
->dq_id
);
1048 /* Print warning to user which exceeded quota */
1049 static void print_warning(struct dquot
*dquot
, const int warntype
)
1052 struct tty_struct
*tty
;
1054 if (warntype
== QUOTA_NL_IHARDBELOW
||
1055 warntype
== QUOTA_NL_ISOFTBELOW
||
1056 warntype
== QUOTA_NL_BHARDBELOW
||
1057 warntype
== QUOTA_NL_BSOFTBELOW
|| !need_print_warning(dquot
))
1060 tty
= get_current_tty();
1063 tty_write_message(tty
, dquot
->dq_sb
->s_id
);
1064 if (warntype
== QUOTA_NL_ISOFTWARN
|| warntype
== QUOTA_NL_BSOFTWARN
)
1065 tty_write_message(tty
, ": warning, ");
1067 tty_write_message(tty
, ": write failed, ");
1068 tty_write_message(tty
, quotatypes
[dquot
->dq_type
]);
1070 case QUOTA_NL_IHARDWARN
:
1071 msg
= " file limit reached.\r\n";
1073 case QUOTA_NL_ISOFTLONGWARN
:
1074 msg
= " file quota exceeded too long.\r\n";
1076 case QUOTA_NL_ISOFTWARN
:
1077 msg
= " file quota exceeded.\r\n";
1079 case QUOTA_NL_BHARDWARN
:
1080 msg
= " block limit reached.\r\n";
1082 case QUOTA_NL_BSOFTLONGWARN
:
1083 msg
= " block quota exceeded too long.\r\n";
1085 case QUOTA_NL_BSOFTWARN
:
1086 msg
= " block quota exceeded.\r\n";
1089 tty_write_message(tty
, msg
);
1095 * Write warnings to the console and send warning messages over netlink.
1097 * Note that this function can sleep.
1099 static void flush_warnings(struct dquot
*const *dquots
, char *warntype
)
1104 for (i
= 0; i
< MAXQUOTAS
; i
++) {
1106 if (dq
&& warntype
[i
] != QUOTA_NL_NOWARN
&&
1107 !warning_issued(dq
, warntype
[i
])) {
1108 #ifdef CONFIG_PRINT_QUOTA_WARNING
1109 print_warning(dq
, warntype
[i
]);
1111 quota_send_warning(dq
->dq_type
, dq
->dq_id
,
1112 dq
->dq_sb
->s_dev
, warntype
[i
]);
1117 static int ignore_hardlimit(struct dquot
*dquot
)
1119 struct mem_dqinfo
*info
= &sb_dqopt(dquot
->dq_sb
)->info
[dquot
->dq_type
];
1121 return capable(CAP_SYS_RESOURCE
) &&
1122 (info
->dqi_format
->qf_fmt_id
!= QFMT_VFS_OLD
||
1123 !(info
->dqi_flags
& V1_DQF_RSQUASH
));
1126 /* needs dq_data_lock */
1127 static int check_idq(struct dquot
*dquot
, qsize_t inodes
, char *warntype
)
1129 qsize_t newinodes
= dquot
->dq_dqb
.dqb_curinodes
+ inodes
;
1131 *warntype
= QUOTA_NL_NOWARN
;
1132 if (!sb_has_quota_limits_enabled(dquot
->dq_sb
, dquot
->dq_type
) ||
1133 test_bit(DQ_FAKE_B
, &dquot
->dq_flags
))
1136 if (dquot
->dq_dqb
.dqb_ihardlimit
&&
1137 newinodes
> dquot
->dq_dqb
.dqb_ihardlimit
&&
1138 !ignore_hardlimit(dquot
)) {
1139 *warntype
= QUOTA_NL_IHARDWARN
;
1143 if (dquot
->dq_dqb
.dqb_isoftlimit
&&
1144 newinodes
> dquot
->dq_dqb
.dqb_isoftlimit
&&
1145 dquot
->dq_dqb
.dqb_itime
&&
1146 get_seconds() >= dquot
->dq_dqb
.dqb_itime
&&
1147 !ignore_hardlimit(dquot
)) {
1148 *warntype
= QUOTA_NL_ISOFTLONGWARN
;
1152 if (dquot
->dq_dqb
.dqb_isoftlimit
&&
1153 newinodes
> dquot
->dq_dqb
.dqb_isoftlimit
&&
1154 dquot
->dq_dqb
.dqb_itime
== 0) {
1155 *warntype
= QUOTA_NL_ISOFTWARN
;
1156 dquot
->dq_dqb
.dqb_itime
= get_seconds() +
1157 sb_dqopt(dquot
->dq_sb
)->info
[dquot
->dq_type
].dqi_igrace
;
1163 /* needs dq_data_lock */
1164 static int check_bdq(struct dquot
*dquot
, qsize_t space
, int prealloc
, char *warntype
)
1167 struct super_block
*sb
= dquot
->dq_sb
;
1169 *warntype
= QUOTA_NL_NOWARN
;
1170 if (!sb_has_quota_limits_enabled(sb
, dquot
->dq_type
) ||
1171 test_bit(DQ_FAKE_B
, &dquot
->dq_flags
))
1174 tspace
= dquot
->dq_dqb
.dqb_curspace
+ dquot
->dq_dqb
.dqb_rsvspace
1177 if (dquot
->dq_dqb
.dqb_bhardlimit
&&
1178 tspace
> dquot
->dq_dqb
.dqb_bhardlimit
&&
1179 !ignore_hardlimit(dquot
)) {
1181 *warntype
= QUOTA_NL_BHARDWARN
;
1185 if (dquot
->dq_dqb
.dqb_bsoftlimit
&&
1186 tspace
> dquot
->dq_dqb
.dqb_bsoftlimit
&&
1187 dquot
->dq_dqb
.dqb_btime
&&
1188 get_seconds() >= dquot
->dq_dqb
.dqb_btime
&&
1189 !ignore_hardlimit(dquot
)) {
1191 *warntype
= QUOTA_NL_BSOFTLONGWARN
;
1195 if (dquot
->dq_dqb
.dqb_bsoftlimit
&&
1196 tspace
> dquot
->dq_dqb
.dqb_bsoftlimit
&&
1197 dquot
->dq_dqb
.dqb_btime
== 0) {
1199 *warntype
= QUOTA_NL_BSOFTWARN
;
1200 dquot
->dq_dqb
.dqb_btime
= get_seconds() +
1201 sb_dqopt(sb
)->info
[dquot
->dq_type
].dqi_bgrace
;
1205 * We don't allow preallocation to exceed softlimit so exceeding will
1214 static int info_idq_free(struct dquot
*dquot
, qsize_t inodes
)
1218 if (test_bit(DQ_FAKE_B
, &dquot
->dq_flags
) ||
1219 dquot
->dq_dqb
.dqb_curinodes
<= dquot
->dq_dqb
.dqb_isoftlimit
||
1220 !sb_has_quota_limits_enabled(dquot
->dq_sb
, dquot
->dq_type
))
1221 return QUOTA_NL_NOWARN
;
1223 newinodes
= dquot
->dq_dqb
.dqb_curinodes
- inodes
;
1224 if (newinodes
<= dquot
->dq_dqb
.dqb_isoftlimit
)
1225 return QUOTA_NL_ISOFTBELOW
;
1226 if (dquot
->dq_dqb
.dqb_curinodes
>= dquot
->dq_dqb
.dqb_ihardlimit
&&
1227 newinodes
< dquot
->dq_dqb
.dqb_ihardlimit
)
1228 return QUOTA_NL_IHARDBELOW
;
1229 return QUOTA_NL_NOWARN
;
1232 static int info_bdq_free(struct dquot
*dquot
, qsize_t space
)
1234 if (test_bit(DQ_FAKE_B
, &dquot
->dq_flags
) ||
1235 dquot
->dq_dqb
.dqb_curspace
<= dquot
->dq_dqb
.dqb_bsoftlimit
)
1236 return QUOTA_NL_NOWARN
;
1238 if (dquot
->dq_dqb
.dqb_curspace
- space
<= dquot
->dq_dqb
.dqb_bsoftlimit
)
1239 return QUOTA_NL_BSOFTBELOW
;
1240 if (dquot
->dq_dqb
.dqb_curspace
>= dquot
->dq_dqb
.dqb_bhardlimit
&&
1241 dquot
->dq_dqb
.dqb_curspace
- space
< dquot
->dq_dqb
.dqb_bhardlimit
)
1242 return QUOTA_NL_BHARDBELOW
;
1243 return QUOTA_NL_NOWARN
;
1246 * Initialize quota pointers in inode
1247 * We do things in a bit complicated way but by that we avoid calling
1248 * dqget() and thus filesystem callbacks under dqptr_sem.
1250 int dquot_initialize(struct inode
*inode
, int type
)
1252 unsigned int id
= 0;
1254 struct dquot
*got
[MAXQUOTAS
] = { NULL
, NULL
};
1255 struct super_block
*sb
= inode
->i_sb
;
1257 /* First test before acquiring mutex - solves deadlocks when we
1258 * re-enter the quota code and are already holding the mutex */
1259 if (IS_NOQUOTA(inode
))
1262 /* First get references to structures we might need. */
1263 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1264 if (type
!= -1 && cnt
!= type
)
1274 got
[cnt
] = dqget(sb
, id
, cnt
);
1277 down_write(&sb_dqopt(sb
)->dqptr_sem
);
1278 /* Having dqptr_sem we know NOQUOTA flags can't be altered... */
1279 if (IS_NOQUOTA(inode
))
1281 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1282 if (type
!= -1 && cnt
!= type
)
1284 /* Avoid races with quotaoff() */
1285 if (!sb_has_quota_active(sb
, cnt
))
1287 if (!inode
->i_dquot
[cnt
]) {
1288 inode
->i_dquot
[cnt
] = got
[cnt
];
1293 up_write(&sb_dqopt(sb
)->dqptr_sem
);
1294 /* Drop unused references */
1298 EXPORT_SYMBOL(dquot_initialize
);
1301 * Release all quotas referenced by inode
1303 int dquot_drop(struct inode
*inode
)
1306 struct dquot
*put
[MAXQUOTAS
];
1308 down_write(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1309 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1310 put
[cnt
] = inode
->i_dquot
[cnt
];
1311 inode
->i_dquot
[cnt
] = NULL
;
1313 up_write(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1317 EXPORT_SYMBOL(dquot_drop
);
1319 /* Wrapper to remove references to quota structures from inode */
1320 void vfs_dq_drop(struct inode
*inode
)
1322 /* Here we can get arbitrary inode from clear_inode() so we have
1323 * to be careful. OTOH we don't need locking as quota operations
1324 * are allowed to change only at mount time */
1325 if (!IS_NOQUOTA(inode
) && inode
->i_sb
&& inode
->i_sb
->dq_op
1326 && inode
->i_sb
->dq_op
->drop
) {
1328 /* Test before calling to rule out calls from proc and such
1329 * where we are not allowed to block. Note that this is
1330 * actually reliable test even without the lock - the caller
1331 * must assure that nobody can come after the DQUOT_DROP and
1332 * add quota pointers back anyway */
1333 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1334 if (inode
->i_dquot
[cnt
])
1336 if (cnt
< MAXQUOTAS
)
1337 inode
->i_sb
->dq_op
->drop(inode
);
1340 EXPORT_SYMBOL(vfs_dq_drop
);
1343 * inode_reserved_space is managed internally by quota, and protected by
1344 * i_lock similar to i_blocks+i_bytes.
1346 static qsize_t
*inode_reserved_space(struct inode
* inode
)
1348 /* Filesystem must explicitly define it's own method in order to use
1349 * quota reservation interface */
1350 BUG_ON(!inode
->i_sb
->dq_op
->get_reserved_space
);
1351 return inode
->i_sb
->dq_op
->get_reserved_space(inode
);
1354 static void inode_add_rsv_space(struct inode
*inode
, qsize_t number
)
1356 spin_lock(&inode
->i_lock
);
1357 *inode_reserved_space(inode
) += number
;
1358 spin_unlock(&inode
->i_lock
);
1362 static void inode_claim_rsv_space(struct inode
*inode
, qsize_t number
)
1364 spin_lock(&inode
->i_lock
);
1365 *inode_reserved_space(inode
) -= number
;
1366 __inode_add_bytes(inode
, number
);
1367 spin_unlock(&inode
->i_lock
);
1370 static void inode_sub_rsv_space(struct inode
*inode
, qsize_t number
)
1372 spin_lock(&inode
->i_lock
);
1373 *inode_reserved_space(inode
) -= number
;
1374 spin_unlock(&inode
->i_lock
);
1377 static qsize_t
inode_get_rsv_space(struct inode
*inode
)
1381 if (!inode
->i_sb
->dq_op
->get_reserved_space
)
1383 spin_lock(&inode
->i_lock
);
1384 ret
= *inode_reserved_space(inode
);
1385 spin_unlock(&inode
->i_lock
);
1389 static void inode_incr_space(struct inode
*inode
, qsize_t number
,
1393 inode_add_rsv_space(inode
, number
);
1395 inode_add_bytes(inode
, number
);
1398 static void inode_decr_space(struct inode
*inode
, qsize_t number
, int reserve
)
1401 inode_sub_rsv_space(inode
, number
);
1403 inode_sub_bytes(inode
, number
);
1407 * Following four functions update i_blocks+i_bytes fields and
1408 * quota information (together with appropriate checks)
1409 * NOTE: We absolutely rely on the fact that caller dirties
1410 * the inode (usually macros in quotaops.h care about this) and
1411 * holds a handle for the current transaction so that dquot write and
1412 * inode write go into the same transaction.
1416 * This operation can block, but only after everything is updated
1418 int __dquot_alloc_space(struct inode
*inode
, qsize_t number
,
1419 int warn
, int reserve
)
1421 int cnt
, ret
= QUOTA_OK
;
1422 char warntype
[MAXQUOTAS
];
1425 * First test before acquiring mutex - solves deadlocks when we
1426 * re-enter the quota code and are already holding the mutex
1428 if (IS_NOQUOTA(inode
)) {
1429 inode_incr_space(inode
, number
, reserve
);
1433 down_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1434 if (IS_NOQUOTA(inode
)) {
1435 inode_incr_space(inode
, number
, reserve
);
1439 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1440 warntype
[cnt
] = QUOTA_NL_NOWARN
;
1442 spin_lock(&dq_data_lock
);
1443 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1444 if (!inode
->i_dquot
[cnt
])
1446 if (check_bdq(inode
->i_dquot
[cnt
], number
, warn
, warntype
+cnt
)
1449 spin_unlock(&dq_data_lock
);
1450 goto out_flush_warn
;
1453 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1454 if (!inode
->i_dquot
[cnt
])
1457 dquot_resv_space(inode
->i_dquot
[cnt
], number
);
1459 dquot_incr_space(inode
->i_dquot
[cnt
], number
);
1461 inode_incr_space(inode
, number
, reserve
);
1462 spin_unlock(&dq_data_lock
);
1465 goto out_flush_warn
;
1466 mark_all_dquot_dirty(inode
->i_dquot
);
1468 flush_warnings(inode
->i_dquot
, warntype
);
1470 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1475 int dquot_alloc_space(struct inode
*inode
, qsize_t number
, int warn
)
1477 return __dquot_alloc_space(inode
, number
, warn
, 0);
1479 EXPORT_SYMBOL(dquot_alloc_space
);
1481 int dquot_reserve_space(struct inode
*inode
, qsize_t number
, int warn
)
1483 return __dquot_alloc_space(inode
, number
, warn
, 1);
1485 EXPORT_SYMBOL(dquot_reserve_space
);
1488 * This operation can block, but only after everything is updated
1490 int dquot_alloc_inode(const struct inode
*inode
, qsize_t number
)
1492 int cnt
, ret
= NO_QUOTA
;
1493 char warntype
[MAXQUOTAS
];
1495 /* First test before acquiring mutex - solves deadlocks when we
1496 * re-enter the quota code and are already holding the mutex */
1497 if (IS_NOQUOTA(inode
))
1499 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1500 warntype
[cnt
] = QUOTA_NL_NOWARN
;
1501 down_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1502 if (IS_NOQUOTA(inode
)) {
1503 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1506 spin_lock(&dq_data_lock
);
1507 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1508 if (!inode
->i_dquot
[cnt
])
1510 if (check_idq(inode
->i_dquot
[cnt
], number
, warntype
+cnt
)
1515 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1516 if (!inode
->i_dquot
[cnt
])
1518 dquot_incr_inodes(inode
->i_dquot
[cnt
], number
);
1522 spin_unlock(&dq_data_lock
);
1523 if (ret
== QUOTA_OK
)
1524 mark_all_dquot_dirty(inode
->i_dquot
);
1525 flush_warnings(inode
->i_dquot
, warntype
);
1526 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1529 EXPORT_SYMBOL(dquot_alloc_inode
);
1531 int dquot_claim_space(struct inode
*inode
, qsize_t number
)
1536 if (IS_NOQUOTA(inode
)) {
1537 inode_claim_rsv_space(inode
, number
);
1541 down_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1542 if (IS_NOQUOTA(inode
)) {
1543 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1544 inode_claim_rsv_space(inode
, number
);
1548 spin_lock(&dq_data_lock
);
1549 /* Claim reserved quotas to allocated quotas */
1550 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1551 if (inode
->i_dquot
[cnt
])
1552 dquot_claim_reserved_space(inode
->i_dquot
[cnt
],
1555 /* Update inode bytes */
1556 inode_claim_rsv_space(inode
, number
);
1557 spin_unlock(&dq_data_lock
);
1558 mark_all_dquot_dirty(inode
->i_dquot
);
1559 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1563 EXPORT_SYMBOL(dquot_claim_space
);
1566 * This operation can block, but only after everything is updated
1568 int __dquot_free_space(struct inode
*inode
, qsize_t number
, int reserve
)
1571 char warntype
[MAXQUOTAS
];
1573 /* First test before acquiring mutex - solves deadlocks when we
1574 * re-enter the quota code and are already holding the mutex */
1575 if (IS_NOQUOTA(inode
)) {
1577 inode_decr_space(inode
, number
, reserve
);
1581 down_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1582 /* Now recheck reliably when holding dqptr_sem */
1583 if (IS_NOQUOTA(inode
)) {
1584 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1587 spin_lock(&dq_data_lock
);
1588 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1589 if (!inode
->i_dquot
[cnt
])
1591 warntype
[cnt
] = info_bdq_free(inode
->i_dquot
[cnt
], number
);
1593 dquot_free_reserved_space(inode
->i_dquot
[cnt
], number
);
1595 dquot_decr_space(inode
->i_dquot
[cnt
], number
);
1597 inode_decr_space(inode
, number
, reserve
);
1598 spin_unlock(&dq_data_lock
);
1602 mark_all_dquot_dirty(inode
->i_dquot
);
1604 flush_warnings(inode
->i_dquot
, warntype
);
1605 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1609 int dquot_free_space(struct inode
*inode
, qsize_t number
)
1611 return __dquot_free_space(inode
, number
, 0);
1613 EXPORT_SYMBOL(dquot_free_space
);
1616 * Release reserved quota space
1618 void dquot_release_reserved_space(struct inode
*inode
, qsize_t number
)
1620 __dquot_free_space(inode
, number
, 1);
1623 EXPORT_SYMBOL(dquot_release_reserved_space
);
1626 * This operation can block, but only after everything is updated
1628 int dquot_free_inode(const struct inode
*inode
, qsize_t number
)
1631 char warntype
[MAXQUOTAS
];
1633 /* First test before acquiring mutex - solves deadlocks when we
1634 * re-enter the quota code and are already holding the mutex */
1635 if (IS_NOQUOTA(inode
))
1638 down_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1639 /* Now recheck reliably when holding dqptr_sem */
1640 if (IS_NOQUOTA(inode
)) {
1641 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1644 spin_lock(&dq_data_lock
);
1645 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1646 if (!inode
->i_dquot
[cnt
])
1648 warntype
[cnt
] = info_idq_free(inode
->i_dquot
[cnt
], number
);
1649 dquot_decr_inodes(inode
->i_dquot
[cnt
], number
);
1651 spin_unlock(&dq_data_lock
);
1652 mark_all_dquot_dirty(inode
->i_dquot
);
1653 flush_warnings(inode
->i_dquot
, warntype
);
1654 up_read(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1657 EXPORT_SYMBOL(dquot_free_inode
);
1660 * Transfer the number of inode and blocks from one diskquota to an other.
1662 * This operation can block, but only after everything is updated
1663 * A transaction must be started when entering this function.
1665 int dquot_transfer(struct inode
*inode
, struct iattr
*iattr
)
1667 qsize_t space
, cur_space
;
1668 qsize_t rsv_space
= 0;
1669 struct dquot
*transfer_from
[MAXQUOTAS
];
1670 struct dquot
*transfer_to
[MAXQUOTAS
];
1671 int cnt
, ret
= QUOTA_OK
;
1672 int chuid
= iattr
->ia_valid
& ATTR_UID
&& inode
->i_uid
!= iattr
->ia_uid
,
1673 chgid
= iattr
->ia_valid
& ATTR_GID
&& inode
->i_gid
!= iattr
->ia_gid
;
1674 char warntype_to
[MAXQUOTAS
];
1675 char warntype_from_inodes
[MAXQUOTAS
], warntype_from_space
[MAXQUOTAS
];
1677 /* First test before acquiring mutex - solves deadlocks when we
1678 * re-enter the quota code and are already holding the mutex */
1679 if (IS_NOQUOTA(inode
))
1681 /* Initialize the arrays */
1682 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1683 transfer_from
[cnt
] = NULL
;
1684 transfer_to
[cnt
] = NULL
;
1685 warntype_to
[cnt
] = QUOTA_NL_NOWARN
;
1688 transfer_to
[USRQUOTA
] = dqget(inode
->i_sb
, iattr
->ia_uid
,
1691 transfer_to
[GRPQUOTA
] = dqget(inode
->i_sb
, iattr
->ia_gid
,
1694 down_write(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1695 /* Now recheck reliably when holding dqptr_sem */
1696 if (IS_NOQUOTA(inode
)) { /* File without quota accounting? */
1697 up_write(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1700 spin_lock(&dq_data_lock
);
1701 cur_space
= inode_get_bytes(inode
);
1702 rsv_space
= inode_get_rsv_space(inode
);
1703 space
= cur_space
+ rsv_space
;
1704 /* Build the transfer_from list and check the limits */
1705 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1706 if (!transfer_to
[cnt
])
1708 transfer_from
[cnt
] = inode
->i_dquot
[cnt
];
1709 if (check_idq(transfer_to
[cnt
], 1, warntype_to
+ cnt
) ==
1710 NO_QUOTA
|| check_bdq(transfer_to
[cnt
], space
, 0,
1711 warntype_to
+ cnt
) == NO_QUOTA
)
1716 * Finally perform the needed transfer from transfer_from to transfer_to
1718 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1720 * Skip changes for same uid or gid or for turned off quota-type.
1722 if (!transfer_to
[cnt
])
1725 /* Due to IO error we might not have transfer_from[] structure */
1726 if (transfer_from
[cnt
]) {
1727 warntype_from_inodes
[cnt
] =
1728 info_idq_free(transfer_from
[cnt
], 1);
1729 warntype_from_space
[cnt
] =
1730 info_bdq_free(transfer_from
[cnt
], space
);
1731 dquot_decr_inodes(transfer_from
[cnt
], 1);
1732 dquot_decr_space(transfer_from
[cnt
], cur_space
);
1733 dquot_free_reserved_space(transfer_from
[cnt
],
1737 dquot_incr_inodes(transfer_to
[cnt
], 1);
1738 dquot_incr_space(transfer_to
[cnt
], cur_space
);
1739 dquot_resv_space(transfer_to
[cnt
], rsv_space
);
1741 inode
->i_dquot
[cnt
] = transfer_to
[cnt
];
1743 spin_unlock(&dq_data_lock
);
1744 up_write(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1746 mark_all_dquot_dirty(transfer_from
);
1747 mark_all_dquot_dirty(transfer_to
);
1748 /* The reference we got is transferred to the inode */
1749 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1750 transfer_to
[cnt
] = NULL
;
1752 flush_warnings(transfer_to
, warntype_to
);
1753 flush_warnings(transfer_from
, warntype_from_inodes
);
1754 flush_warnings(transfer_from
, warntype_from_space
);
1756 dqput_all(transfer_from
);
1757 dqput_all(transfer_to
);
1760 spin_unlock(&dq_data_lock
);
1761 up_write(&sb_dqopt(inode
->i_sb
)->dqptr_sem
);
1762 /* Clear dquot pointers we don't want to dqput() */
1763 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1764 transfer_from
[cnt
] = NULL
;
1768 EXPORT_SYMBOL(dquot_transfer
);
1770 /* Wrapper for transferring ownership of an inode */
1771 int vfs_dq_transfer(struct inode
*inode
, struct iattr
*iattr
)
1773 if (sb_any_quota_active(inode
->i_sb
) && !IS_NOQUOTA(inode
)) {
1775 if (inode
->i_sb
->dq_op
->transfer(inode
, iattr
) == NO_QUOTA
)
1780 EXPORT_SYMBOL(vfs_dq_transfer
);
1783 * Write info of quota file to disk
1785 int dquot_commit_info(struct super_block
*sb
, int type
)
1788 struct quota_info
*dqopt
= sb_dqopt(sb
);
1790 mutex_lock(&dqopt
->dqio_mutex
);
1791 ret
= dqopt
->ops
[type
]->write_file_info(sb
, type
);
1792 mutex_unlock(&dqopt
->dqio_mutex
);
1795 EXPORT_SYMBOL(dquot_commit_info
);
1798 * Definitions of diskquota operations.
1800 const struct dquot_operations dquot_operations
= {
1801 .initialize
= dquot_initialize
,
1803 .alloc_space
= dquot_alloc_space
,
1804 .alloc_inode
= dquot_alloc_inode
,
1805 .free_space
= dquot_free_space
,
1806 .free_inode
= dquot_free_inode
,
1807 .transfer
= dquot_transfer
,
1808 .write_dquot
= dquot_commit
,
1809 .acquire_dquot
= dquot_acquire
,
1810 .release_dquot
= dquot_release
,
1811 .mark_dirty
= dquot_mark_dquot_dirty
,
1812 .write_info
= dquot_commit_info
,
1813 .alloc_dquot
= dquot_alloc
,
1814 .destroy_dquot
= dquot_destroy
,
1818 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
1820 int vfs_quota_disable(struct super_block
*sb
, int type
, unsigned int flags
)
1823 struct quota_info
*dqopt
= sb_dqopt(sb
);
1824 struct inode
*toputinode
[MAXQUOTAS
];
1826 /* Cannot turn off usage accounting without turning off limits, or
1827 * suspend quotas and simultaneously turn quotas off. */
1828 if ((flags
& DQUOT_USAGE_ENABLED
&& !(flags
& DQUOT_LIMITS_ENABLED
))
1829 || (flags
& DQUOT_SUSPENDED
&& flags
& (DQUOT_LIMITS_ENABLED
|
1830 DQUOT_USAGE_ENABLED
)))
1833 /* We need to serialize quota_off() for device */
1834 mutex_lock(&dqopt
->dqonoff_mutex
);
1837 * Skip everything if there's nothing to do. We have to do this because
1838 * sometimes we are called when fill_super() failed and calling
1839 * sync_fs() in such cases does no good.
1841 if (!sb_any_quota_loaded(sb
)) {
1842 mutex_unlock(&dqopt
->dqonoff_mutex
);
1845 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
1846 toputinode
[cnt
] = NULL
;
1847 if (type
!= -1 && cnt
!= type
)
1849 if (!sb_has_quota_loaded(sb
, cnt
))
1852 if (flags
& DQUOT_SUSPENDED
) {
1853 spin_lock(&dq_state_lock
);
1855 dquot_state_flag(DQUOT_SUSPENDED
, cnt
);
1856 spin_unlock(&dq_state_lock
);
1858 spin_lock(&dq_state_lock
);
1859 dqopt
->flags
&= ~dquot_state_flag(flags
, cnt
);
1860 /* Turning off suspended quotas? */
1861 if (!sb_has_quota_loaded(sb
, cnt
) &&
1862 sb_has_quota_suspended(sb
, cnt
)) {
1863 dqopt
->flags
&= ~dquot_state_flag(
1864 DQUOT_SUSPENDED
, cnt
);
1865 spin_unlock(&dq_state_lock
);
1866 iput(dqopt
->files
[cnt
]);
1867 dqopt
->files
[cnt
] = NULL
;
1870 spin_unlock(&dq_state_lock
);
1873 /* We still have to keep quota loaded? */
1874 if (sb_has_quota_loaded(sb
, cnt
) && !(flags
& DQUOT_SUSPENDED
))
1877 /* Note: these are blocking operations */
1878 drop_dquot_ref(sb
, cnt
);
1879 invalidate_dquots(sb
, cnt
);
1881 * Now all dquots should be invalidated, all writes done so we
1882 * should be only users of the info. No locks needed.
1884 if (info_dirty(&dqopt
->info
[cnt
]))
1885 sb
->dq_op
->write_info(sb
, cnt
);
1886 if (dqopt
->ops
[cnt
]->free_file_info
)
1887 dqopt
->ops
[cnt
]->free_file_info(sb
, cnt
);
1888 put_quota_format(dqopt
->info
[cnt
].dqi_format
);
1890 toputinode
[cnt
] = dqopt
->files
[cnt
];
1891 if (!sb_has_quota_loaded(sb
, cnt
))
1892 dqopt
->files
[cnt
] = NULL
;
1893 dqopt
->info
[cnt
].dqi_flags
= 0;
1894 dqopt
->info
[cnt
].dqi_igrace
= 0;
1895 dqopt
->info
[cnt
].dqi_bgrace
= 0;
1896 dqopt
->ops
[cnt
] = NULL
;
1898 mutex_unlock(&dqopt
->dqonoff_mutex
);
1900 /* Skip syncing and setting flags if quota files are hidden */
1901 if (dqopt
->flags
& DQUOT_QUOTA_SYS_FILE
)
1904 /* Sync the superblock so that buffers with quota data are written to
1905 * disk (and so userspace sees correct data afterwards). */
1906 if (sb
->s_op
->sync_fs
)
1907 sb
->s_op
->sync_fs(sb
, 1);
1908 sync_blockdev(sb
->s_bdev
);
1909 /* Now the quota files are just ordinary files and we can set the
1910 * inode flags back. Moreover we discard the pagecache so that
1911 * userspace sees the writes we did bypassing the pagecache. We
1912 * must also discard the blockdev buffers so that we see the
1913 * changes done by userspace on the next quotaon() */
1914 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1915 if (toputinode
[cnt
]) {
1916 mutex_lock(&dqopt
->dqonoff_mutex
);
1917 /* If quota was reenabled in the meantime, we have
1919 if (!sb_has_quota_loaded(sb
, cnt
)) {
1920 mutex_lock_nested(&toputinode
[cnt
]->i_mutex
,
1922 toputinode
[cnt
]->i_flags
&= ~(S_IMMUTABLE
|
1923 S_NOATIME
| S_NOQUOTA
);
1924 truncate_inode_pages(&toputinode
[cnt
]->i_data
,
1926 mutex_unlock(&toputinode
[cnt
]->i_mutex
);
1927 mark_inode_dirty(toputinode
[cnt
]);
1929 mutex_unlock(&dqopt
->dqonoff_mutex
);
1932 invalidate_bdev(sb
->s_bdev
);
1934 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++)
1935 if (toputinode
[cnt
]) {
1936 /* On remount RO, we keep the inode pointer so that we
1937 * can reenable quota on the subsequent remount RW. We
1938 * have to check 'flags' variable and not use sb_has_
1939 * function because another quotaon / quotaoff could
1940 * change global state before we got here. We refuse
1941 * to suspend quotas when there is pending delete on
1942 * the quota file... */
1943 if (!(flags
& DQUOT_SUSPENDED
))
1944 iput(toputinode
[cnt
]);
1945 else if (!toputinode
[cnt
]->i_nlink
)
1950 EXPORT_SYMBOL(vfs_quota_disable
);
1952 int vfs_quota_off(struct super_block
*sb
, int type
, int remount
)
1954 return vfs_quota_disable(sb
, type
, remount
? DQUOT_SUSPENDED
:
1955 (DQUOT_USAGE_ENABLED
| DQUOT_LIMITS_ENABLED
));
1957 EXPORT_SYMBOL(vfs_quota_off
);
1959 * Turn quotas on on a device
1963 * Helper function to turn quotas on when we already have the inode of
1964 * quota file and no quota information is loaded.
1966 static int vfs_load_quota_inode(struct inode
*inode
, int type
, int format_id
,
1969 struct quota_format_type
*fmt
= find_quota_format(format_id
);
1970 struct super_block
*sb
= inode
->i_sb
;
1971 struct quota_info
*dqopt
= sb_dqopt(sb
);
1977 if (!S_ISREG(inode
->i_mode
)) {
1981 if (IS_RDONLY(inode
)) {
1985 if (!sb
->s_op
->quota_write
|| !sb
->s_op
->quota_read
) {
1989 /* Usage always has to be set... */
1990 if (!(flags
& DQUOT_USAGE_ENABLED
)) {
1995 if (!(dqopt
->flags
& DQUOT_QUOTA_SYS_FILE
)) {
1996 /* As we bypass the pagecache we must now flush the inode so
1997 * that we see all the changes from userspace... */
1998 write_inode_now(inode
, 1);
1999 /* And now flush the block cache so that kernel sees the
2001 invalidate_bdev(sb
->s_bdev
);
2003 mutex_lock(&dqopt
->dqonoff_mutex
);
2004 if (sb_has_quota_loaded(sb
, type
)) {
2009 if (!(dqopt
->flags
& DQUOT_QUOTA_SYS_FILE
)) {
2010 /* We don't want quota and atime on quota files (deadlocks
2011 * possible) Also nobody should write to the file - we use
2012 * special IO operations which ignore the immutable bit. */
2013 down_write(&dqopt
->dqptr_sem
);
2014 mutex_lock_nested(&inode
->i_mutex
, I_MUTEX_QUOTA
);
2015 oldflags
= inode
->i_flags
& (S_NOATIME
| S_IMMUTABLE
|
2017 inode
->i_flags
|= S_NOQUOTA
| S_NOATIME
| S_IMMUTABLE
;
2018 mutex_unlock(&inode
->i_mutex
);
2019 up_write(&dqopt
->dqptr_sem
);
2020 sb
->dq_op
->drop(inode
);
2024 dqopt
->files
[type
] = igrab(inode
);
2025 if (!dqopt
->files
[type
])
2028 if (!fmt
->qf_ops
->check_quota_file(sb
, type
))
2031 dqopt
->ops
[type
] = fmt
->qf_ops
;
2032 dqopt
->info
[type
].dqi_format
= fmt
;
2033 dqopt
->info
[type
].dqi_fmt_id
= format_id
;
2034 INIT_LIST_HEAD(&dqopt
->info
[type
].dqi_dirty_list
);
2035 mutex_lock(&dqopt
->dqio_mutex
);
2036 error
= dqopt
->ops
[type
]->read_file_info(sb
, type
);
2038 mutex_unlock(&dqopt
->dqio_mutex
);
2041 mutex_unlock(&dqopt
->dqio_mutex
);
2042 spin_lock(&dq_state_lock
);
2043 dqopt
->flags
|= dquot_state_flag(flags
, type
);
2044 spin_unlock(&dq_state_lock
);
2046 add_dquot_ref(sb
, type
);
2047 mutex_unlock(&dqopt
->dqonoff_mutex
);
2052 dqopt
->files
[type
] = NULL
;
2055 if (oldflags
!= -1) {
2056 down_write(&dqopt
->dqptr_sem
);
2057 mutex_lock_nested(&inode
->i_mutex
, I_MUTEX_QUOTA
);
2058 /* Set the flags back (in the case of accidental quotaon()
2059 * on a wrong file we don't want to mess up the flags) */
2060 inode
->i_flags
&= ~(S_NOATIME
| S_NOQUOTA
| S_IMMUTABLE
);
2061 inode
->i_flags
|= oldflags
;
2062 mutex_unlock(&inode
->i_mutex
);
2063 up_write(&dqopt
->dqptr_sem
);
2065 mutex_unlock(&dqopt
->dqonoff_mutex
);
2067 put_quota_format(fmt
);
2072 /* Reenable quotas on remount RW */
2073 static int vfs_quota_on_remount(struct super_block
*sb
, int type
)
2075 struct quota_info
*dqopt
= sb_dqopt(sb
);
2076 struct inode
*inode
;
2080 mutex_lock(&dqopt
->dqonoff_mutex
);
2081 if (!sb_has_quota_suspended(sb
, type
)) {
2082 mutex_unlock(&dqopt
->dqonoff_mutex
);
2085 inode
= dqopt
->files
[type
];
2086 dqopt
->files
[type
] = NULL
;
2087 spin_lock(&dq_state_lock
);
2088 flags
= dqopt
->flags
& dquot_state_flag(DQUOT_USAGE_ENABLED
|
2089 DQUOT_LIMITS_ENABLED
, type
);
2090 dqopt
->flags
&= ~dquot_state_flag(DQUOT_STATE_FLAGS
, type
);
2091 spin_unlock(&dq_state_lock
);
2092 mutex_unlock(&dqopt
->dqonoff_mutex
);
2094 flags
= dquot_generic_flag(flags
, type
);
2095 ret
= vfs_load_quota_inode(inode
, type
, dqopt
->info
[type
].dqi_fmt_id
,
2102 int vfs_quota_on_path(struct super_block
*sb
, int type
, int format_id
,
2105 int error
= security_quota_on(path
->dentry
);
2108 /* Quota file not on the same filesystem? */
2109 if (path
->mnt
->mnt_sb
!= sb
)
2112 error
= vfs_load_quota_inode(path
->dentry
->d_inode
, type
,
2113 format_id
, DQUOT_USAGE_ENABLED
|
2114 DQUOT_LIMITS_ENABLED
);
2117 EXPORT_SYMBOL(vfs_quota_on_path
);
2119 int vfs_quota_on(struct super_block
*sb
, int type
, int format_id
, char *name
,
2126 return vfs_quota_on_remount(sb
, type
);
2128 error
= kern_path(name
, LOOKUP_FOLLOW
, &path
);
2130 error
= vfs_quota_on_path(sb
, type
, format_id
, &path
);
2135 EXPORT_SYMBOL(vfs_quota_on
);
2138 * More powerful function for turning on quotas allowing setting
2139 * of individual quota flags
2141 int vfs_quota_enable(struct inode
*inode
, int type
, int format_id
,
2145 struct super_block
*sb
= inode
->i_sb
;
2146 struct quota_info
*dqopt
= sb_dqopt(sb
);
2148 /* Just unsuspend quotas? */
2149 if (flags
& DQUOT_SUSPENDED
)
2150 return vfs_quota_on_remount(sb
, type
);
2153 /* Just updating flags needed? */
2154 if (sb_has_quota_loaded(sb
, type
)) {
2155 mutex_lock(&dqopt
->dqonoff_mutex
);
2156 /* Now do a reliable test... */
2157 if (!sb_has_quota_loaded(sb
, type
)) {
2158 mutex_unlock(&dqopt
->dqonoff_mutex
);
2161 if (flags
& DQUOT_USAGE_ENABLED
&&
2162 sb_has_quota_usage_enabled(sb
, type
)) {
2166 if (flags
& DQUOT_LIMITS_ENABLED
&&
2167 sb_has_quota_limits_enabled(sb
, type
)) {
2171 spin_lock(&dq_state_lock
);
2172 sb_dqopt(sb
)->flags
|= dquot_state_flag(flags
, type
);
2173 spin_unlock(&dq_state_lock
);
2175 mutex_unlock(&dqopt
->dqonoff_mutex
);
2180 return vfs_load_quota_inode(inode
, type
, format_id
, flags
);
2182 EXPORT_SYMBOL(vfs_quota_enable
);
2185 * This function is used when filesystem needs to initialize quotas
2186 * during mount time.
2188 int vfs_quota_on_mount(struct super_block
*sb
, char *qf_name
,
2189 int format_id
, int type
)
2191 struct dentry
*dentry
;
2194 mutex_lock(&sb
->s_root
->d_inode
->i_mutex
);
2195 dentry
= lookup_one_len(qf_name
, sb
->s_root
, strlen(qf_name
));
2196 mutex_unlock(&sb
->s_root
->d_inode
->i_mutex
);
2198 return PTR_ERR(dentry
);
2200 if (!dentry
->d_inode
) {
2205 error
= security_quota_on(dentry
);
2207 error
= vfs_load_quota_inode(dentry
->d_inode
, type
, format_id
,
2208 DQUOT_USAGE_ENABLED
| DQUOT_LIMITS_ENABLED
);
2214 EXPORT_SYMBOL(vfs_quota_on_mount
);
2216 /* Wrapper to turn on quotas when remounting rw */
2217 int vfs_dq_quota_on_remount(struct super_block
*sb
)
2222 if (!sb
->s_qcop
|| !sb
->s_qcop
->quota_on
)
2224 for (cnt
= 0; cnt
< MAXQUOTAS
; cnt
++) {
2225 err
= sb
->s_qcop
->quota_on(sb
, cnt
, 0, NULL
, 1);
2226 if (err
< 0 && !ret
)
2231 EXPORT_SYMBOL(vfs_dq_quota_on_remount
);
2233 static inline qsize_t
qbtos(qsize_t blocks
)
2235 return blocks
<< QIF_DQBLKSIZE_BITS
;
2238 static inline qsize_t
stoqb(qsize_t space
)
2240 return (space
+ QIF_DQBLKSIZE
- 1) >> QIF_DQBLKSIZE_BITS
;
2243 /* Generic routine for getting common part of quota structure */
2244 static void do_get_dqblk(struct dquot
*dquot
, struct if_dqblk
*di
)
2246 struct mem_dqblk
*dm
= &dquot
->dq_dqb
;
2248 spin_lock(&dq_data_lock
);
2249 di
->dqb_bhardlimit
= stoqb(dm
->dqb_bhardlimit
);
2250 di
->dqb_bsoftlimit
= stoqb(dm
->dqb_bsoftlimit
);
2251 di
->dqb_curspace
= dm
->dqb_curspace
+ dm
->dqb_rsvspace
;
2252 di
->dqb_ihardlimit
= dm
->dqb_ihardlimit
;
2253 di
->dqb_isoftlimit
= dm
->dqb_isoftlimit
;
2254 di
->dqb_curinodes
= dm
->dqb_curinodes
;
2255 di
->dqb_btime
= dm
->dqb_btime
;
2256 di
->dqb_itime
= dm
->dqb_itime
;
2257 di
->dqb_valid
= QIF_ALL
;
2258 spin_unlock(&dq_data_lock
);
2261 int vfs_get_dqblk(struct super_block
*sb
, int type
, qid_t id
,
2262 struct if_dqblk
*di
)
2264 struct dquot
*dquot
;
2266 dquot
= dqget(sb
, id
, type
);
2269 do_get_dqblk(dquot
, di
);
2274 EXPORT_SYMBOL(vfs_get_dqblk
);
2276 /* Generic routine for setting common part of quota structure */
2277 static int do_set_dqblk(struct dquot
*dquot
, struct if_dqblk
*di
)
2279 struct mem_dqblk
*dm
= &dquot
->dq_dqb
;
2280 int check_blim
= 0, check_ilim
= 0;
2281 struct mem_dqinfo
*dqi
= &sb_dqopt(dquot
->dq_sb
)->info
[dquot
->dq_type
];
2283 if ((di
->dqb_valid
& QIF_BLIMITS
&&
2284 (di
->dqb_bhardlimit
> dqi
->dqi_maxblimit
||
2285 di
->dqb_bsoftlimit
> dqi
->dqi_maxblimit
)) ||
2286 (di
->dqb_valid
& QIF_ILIMITS
&&
2287 (di
->dqb_ihardlimit
> dqi
->dqi_maxilimit
||
2288 di
->dqb_isoftlimit
> dqi
->dqi_maxilimit
)))
2291 spin_lock(&dq_data_lock
);
2292 if (di
->dqb_valid
& QIF_SPACE
) {
2293 dm
->dqb_curspace
= di
->dqb_curspace
- dm
->dqb_rsvspace
;
2295 __set_bit(DQ_LASTSET_B
+ QIF_SPACE_B
, &dquot
->dq_flags
);
2297 if (di
->dqb_valid
& QIF_BLIMITS
) {
2298 dm
->dqb_bsoftlimit
= qbtos(di
->dqb_bsoftlimit
);
2299 dm
->dqb_bhardlimit
= qbtos(di
->dqb_bhardlimit
);
2301 __set_bit(DQ_LASTSET_B
+ QIF_BLIMITS_B
, &dquot
->dq_flags
);
2303 if (di
->dqb_valid
& QIF_INODES
) {
2304 dm
->dqb_curinodes
= di
->dqb_curinodes
;
2306 __set_bit(DQ_LASTSET_B
+ QIF_INODES_B
, &dquot
->dq_flags
);
2308 if (di
->dqb_valid
& QIF_ILIMITS
) {
2309 dm
->dqb_isoftlimit
= di
->dqb_isoftlimit
;
2310 dm
->dqb_ihardlimit
= di
->dqb_ihardlimit
;
2312 __set_bit(DQ_LASTSET_B
+ QIF_ILIMITS_B
, &dquot
->dq_flags
);
2314 if (di
->dqb_valid
& QIF_BTIME
) {
2315 dm
->dqb_btime
= di
->dqb_btime
;
2317 __set_bit(DQ_LASTSET_B
+ QIF_BTIME_B
, &dquot
->dq_flags
);
2319 if (di
->dqb_valid
& QIF_ITIME
) {
2320 dm
->dqb_itime
= di
->dqb_itime
;
2322 __set_bit(DQ_LASTSET_B
+ QIF_ITIME_B
, &dquot
->dq_flags
);
2326 if (!dm
->dqb_bsoftlimit
||
2327 dm
->dqb_curspace
< dm
->dqb_bsoftlimit
) {
2329 clear_bit(DQ_BLKS_B
, &dquot
->dq_flags
);
2330 } else if (!(di
->dqb_valid
& QIF_BTIME
))
2331 /* Set grace only if user hasn't provided his own... */
2332 dm
->dqb_btime
= get_seconds() + dqi
->dqi_bgrace
;
2335 if (!dm
->dqb_isoftlimit
||
2336 dm
->dqb_curinodes
< dm
->dqb_isoftlimit
) {
2338 clear_bit(DQ_INODES_B
, &dquot
->dq_flags
);
2339 } else if (!(di
->dqb_valid
& QIF_ITIME
))
2340 /* Set grace only if user hasn't provided his own... */
2341 dm
->dqb_itime
= get_seconds() + dqi
->dqi_igrace
;
2343 if (dm
->dqb_bhardlimit
|| dm
->dqb_bsoftlimit
|| dm
->dqb_ihardlimit
||
2345 clear_bit(DQ_FAKE_B
, &dquot
->dq_flags
);
2347 set_bit(DQ_FAKE_B
, &dquot
->dq_flags
);
2348 spin_unlock(&dq_data_lock
);
2349 mark_dquot_dirty(dquot
);
2354 int vfs_set_dqblk(struct super_block
*sb
, int type
, qid_t id
,
2355 struct if_dqblk
*di
)
2357 struct dquot
*dquot
;
2360 dquot
= dqget(sb
, id
, type
);
2365 rc
= do_set_dqblk(dquot
, di
);
2370 EXPORT_SYMBOL(vfs_set_dqblk
);
2372 /* Generic routine for getting common part of quota file information */
2373 int vfs_get_dqinfo(struct super_block
*sb
, int type
, struct if_dqinfo
*ii
)
2375 struct mem_dqinfo
*mi
;
2377 mutex_lock(&sb_dqopt(sb
)->dqonoff_mutex
);
2378 if (!sb_has_quota_active(sb
, type
)) {
2379 mutex_unlock(&sb_dqopt(sb
)->dqonoff_mutex
);
2382 mi
= sb_dqopt(sb
)->info
+ type
;
2383 spin_lock(&dq_data_lock
);
2384 ii
->dqi_bgrace
= mi
->dqi_bgrace
;
2385 ii
->dqi_igrace
= mi
->dqi_igrace
;
2386 ii
->dqi_flags
= mi
->dqi_flags
& DQF_MASK
;
2387 ii
->dqi_valid
= IIF_ALL
;
2388 spin_unlock(&dq_data_lock
);
2389 mutex_unlock(&sb_dqopt(sb
)->dqonoff_mutex
);
2392 EXPORT_SYMBOL(vfs_get_dqinfo
);
2394 /* Generic routine for setting common part of quota file information */
2395 int vfs_set_dqinfo(struct super_block
*sb
, int type
, struct if_dqinfo
*ii
)
2397 struct mem_dqinfo
*mi
;
2400 mutex_lock(&sb_dqopt(sb
)->dqonoff_mutex
);
2401 if (!sb_has_quota_active(sb
, type
)) {
2405 mi
= sb_dqopt(sb
)->info
+ type
;
2406 spin_lock(&dq_data_lock
);
2407 if (ii
->dqi_valid
& IIF_BGRACE
)
2408 mi
->dqi_bgrace
= ii
->dqi_bgrace
;
2409 if (ii
->dqi_valid
& IIF_IGRACE
)
2410 mi
->dqi_igrace
= ii
->dqi_igrace
;
2411 if (ii
->dqi_valid
& IIF_FLAGS
)
2412 mi
->dqi_flags
= (mi
->dqi_flags
& ~DQF_MASK
) |
2413 (ii
->dqi_flags
& DQF_MASK
);
2414 spin_unlock(&dq_data_lock
);
2415 mark_info_dirty(sb
, type
);
2416 /* Force write to disk */
2417 sb
->dq_op
->write_info(sb
, type
);
2419 mutex_unlock(&sb_dqopt(sb
)->dqonoff_mutex
);
2422 EXPORT_SYMBOL(vfs_set_dqinfo
);
2424 const struct quotactl_ops vfs_quotactl_ops
= {
2425 .quota_on
= vfs_quota_on
,
2426 .quota_off
= vfs_quota_off
,
2427 .quota_sync
= vfs_quota_sync
,
2428 .get_info
= vfs_get_dqinfo
,
2429 .set_info
= vfs_set_dqinfo
,
2430 .get_dqblk
= vfs_get_dqblk
,
2431 .set_dqblk
= vfs_set_dqblk
2434 static ctl_table fs_dqstats_table
[] = {
2436 .procname
= "lookups",
2437 .data
= &dqstats
.lookups
,
2438 .maxlen
= sizeof(int),
2440 .proc_handler
= proc_dointvec
,
2443 .procname
= "drops",
2444 .data
= &dqstats
.drops
,
2445 .maxlen
= sizeof(int),
2447 .proc_handler
= proc_dointvec
,
2450 .procname
= "reads",
2451 .data
= &dqstats
.reads
,
2452 .maxlen
= sizeof(int),
2454 .proc_handler
= proc_dointvec
,
2457 .procname
= "writes",
2458 .data
= &dqstats
.writes
,
2459 .maxlen
= sizeof(int),
2461 .proc_handler
= proc_dointvec
,
2464 .procname
= "cache_hits",
2465 .data
= &dqstats
.cache_hits
,
2466 .maxlen
= sizeof(int),
2468 .proc_handler
= proc_dointvec
,
2471 .procname
= "allocated_dquots",
2472 .data
= &dqstats
.allocated_dquots
,
2473 .maxlen
= sizeof(int),
2475 .proc_handler
= proc_dointvec
,
2478 .procname
= "free_dquots",
2479 .data
= &dqstats
.free_dquots
,
2480 .maxlen
= sizeof(int),
2482 .proc_handler
= proc_dointvec
,
2485 .procname
= "syncs",
2486 .data
= &dqstats
.syncs
,
2487 .maxlen
= sizeof(int),
2489 .proc_handler
= proc_dointvec
,
2491 #ifdef CONFIG_PRINT_QUOTA_WARNING
2493 .procname
= "warnings",
2494 .data
= &flag_print_warnings
,
2495 .maxlen
= sizeof(int),
2497 .proc_handler
= proc_dointvec
,
2503 static ctl_table fs_table
[] = {
2505 .procname
= "quota",
2507 .child
= fs_dqstats_table
,
2512 static ctl_table sys_table
[] = {
2521 static int __init
dquot_init(void)
2524 unsigned long nr_hash
, order
;
2526 printk(KERN_NOTICE
"VFS: Disk quotas %s\n", __DQUOT_VERSION__
);
2528 register_sysctl_table(sys_table
);
2530 dquot_cachep
= kmem_cache_create("dquot",
2531 sizeof(struct dquot
), sizeof(unsigned long) * 4,
2532 (SLAB_HWCACHE_ALIGN
|SLAB_RECLAIM_ACCOUNT
|
2533 SLAB_MEM_SPREAD
|SLAB_PANIC
),
2537 dquot_hash
= (struct hlist_head
*)__get_free_pages(GFP_ATOMIC
, order
);
2539 panic("Cannot create dquot hash table");
2541 /* Find power-of-two hlist_heads which can fit into allocation */
2542 nr_hash
= (1UL << order
) * PAGE_SIZE
/ sizeof(struct hlist_head
);
2546 } while (nr_hash
>> dq_hash_bits
);
2549 nr_hash
= 1UL << dq_hash_bits
;
2550 dq_hash_mask
= nr_hash
- 1;
2551 for (i
= 0; i
< nr_hash
; i
++)
2552 INIT_HLIST_HEAD(dquot_hash
+ i
);
2554 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2555 nr_hash
, order
, (PAGE_SIZE
<< order
));
2557 register_shrinker(&dqcache_shrinker
);
2561 module_init(dquot_init
);