blob: b171221000fabc0baecbcea23128e40c4dc77e52 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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.
11 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070012 * Author: Marco van Wieringen <mvw@planets.elm.net>
13 *
14 * Fixes: Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
15 *
16 * Revised list management to avoid races
17 * -- Bill Hawes, <whawes@star.net>, 9/98
18 *
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
26 * quota files
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
31 *
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
39 *
40 * Added dynamic quota structure allocation
41 * Jan Kara <jack@suse.cz> 12/2000
42 *
43 * Rewritten quota interface. Implemented new quota format and
44 * formats registering.
45 * Jan Kara, <jack@suse.cz>, 2001,2002
46 *
47 * New SMP locking.
48 * Jan Kara, <jack@suse.cz>, 10/2002
49 *
50 * Added journalled quota support, fix lock inversion problems
51 * Jan Kara, <jack@suse.cz>, 2003,2004
52 *
53 * (C) Copyright 1994 - 1997 Marco van Wieringen
54 */
55
56#include <linux/errno.h>
57#include <linux/kernel.h>
58#include <linux/fs.h>
59#include <linux/mount.h>
60#include <linux/mm.h>
61#include <linux/time.h>
62#include <linux/types.h>
63#include <linux/string.h>
64#include <linux/fcntl.h>
65#include <linux/stat.h>
66#include <linux/tty.h>
67#include <linux/file.h>
68#include <linux/slab.h>
69#include <linux/sysctl.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070070#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>
Randy Dunlap16f7e0f2006-01-11 12:17:46 -080077#include <linux/capability.h>
Adrian Bunkbe586ba2005-11-07 00:59:35 -080078#include <linux/quotaops.h>
Christoph Hellwigfb58b732007-02-12 00:51:57 -080079#include <linux/writeback.h> /* for inode_lock, oddly enough.. */
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
81#include <asm/uaccess.h>
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083/*
Jan Karacc334122009-01-12 17:23:05 +010084 * There are three quota SMP locks. dq_list_lock protects all lists with quotas
Dmitry Monakhovdde95882010-04-26 20:03:33 +040085 * and quota formats.
Jan Karacc334122009-01-12 17:23:05 +010086 * dq_data_lock protects data from dq_dqb and also mem_dqinfo structures and
87 * also guards consistency of dquot->dq_dqb with inode->i_blocks, i_bytes.
Linus Torvalds1da177e2005-04-16 15:20:36 -070088 * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly
Jan Karacc334122009-01-12 17:23:05 +010089 * in inode_add_bytes() and inode_sub_bytes(). dq_state_lock protects
90 * modifications of quota state (on quotaon and quotaoff) and readers who care
91 * about latest values take it as well.
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 *
Jan Karacc334122009-01-12 17:23:05 +010093 * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock,
94 * dq_list_lock > dq_state_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 *
96 * Note that some things (eg. sb pointer, type, id) doesn't change during
97 * the life of the dquot structure and so needn't to be protected by a lock
98 *
99 * Any operation working on dquots via inode pointers must hold dqptr_sem. If
100 * operation is just reading pointers from inode (or not using them at all) the
Jan Kara26245c92010-01-06 17:20:35 +0100101 * read lock is enough. If pointers are altered function must hold write lock.
102 * Special care needs to be taken about S_NOQUOTA inode flag (marking that
103 * inode is a quota file). Functions adding pointers from inode to dquots have
104 * to check this flag under dqptr_sem and then (if S_NOQUOTA is not set) they
105 * have to do all pointer modifications before dropping dqptr_sem. This makes
106 * sure they cannot race with quotaon which first sets S_NOQUOTA flag and
107 * then drops all pointers to dquots from an inode.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108 *
Ingo Molnard3be9152006-03-23 03:00:29 -0800109 * Each dquot has its dq_lock mutex. Locked dquots might not be referenced
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110 * from inodes (dquot_alloc_space() and such don't check the dq_lock).
111 * Currently dquot is locked only when it is being read to memory (or space for
112 * it is being allocated) on the first dqget() and when it is being released on
113 * the last dqput(). The allocation and release oparations are serialized by
114 * the dq_lock and by checking the use count in dquot_release(). Write
115 * operations on dquots don't hold dq_lock as they copy data under dq_data_lock
116 * spinlock to internal buffers before writing.
117 *
118 * Lock ordering (including related VFS locks) is the following:
Ingo Molnard3be9152006-03-23 03:00:29 -0800119 * i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock >
120 * dqio_mutex
Jan Karacc334122009-01-12 17:23:05 +0100121 * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem >
122 * dqptr_sem. But filesystem has to count with the fact that functions such as
123 * dquot_alloc_space() acquire dqptr_sem and they usually have to be called
124 * from inside a transaction to keep filesystem consistency after a crash. Also
125 * filesystems usually want to do some IO on dquot from ->mark_dirty which is
126 * called with dqptr_sem held.
Ingo Molnard3be9152006-03-23 03:00:29 -0800127 * i_mutex on quota files is special (it's below dqio_mutex)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 */
129
Jan Karac5166102009-01-26 15:32:46 +0100130static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock);
131static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
132__cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
Mingming Cao08d03502009-01-14 16:19:32 +0100133EXPORT_SYMBOL(dq_data_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200135void __quota_error(struct super_block *sb, const char *func,
136 const char *fmt, ...)
137{
138 va_list args;
139
140 if (printk_ratelimit()) {
141 va_start(args, fmt);
142 printk(KERN_ERR "Quota error (device %s): %s: ",
143 sb->s_id, func);
144 vprintk(fmt, args);
145 printk("\n");
146 va_end(args);
147 }
148}
149EXPORT_SYMBOL(__quota_error);
150
Sergey Senozhatskyda8d1ba2010-04-26 12:09:26 +0200151#if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152static char *quotatypes[] = INITQFNAMES;
Sergey Senozhatskyda8d1ba2010-04-26 12:09:26 +0200153#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154static struct quota_format_type *quota_formats; /* List of registered formats */
155static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
156
157/* SLAB cache for dquot structures */
Christoph Lametere18b8902006-12-06 20:33:20 -0800158static struct kmem_cache *dquot_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
160int register_quota_format(struct quota_format_type *fmt)
161{
162 spin_lock(&dq_list_lock);
163 fmt->qf_next = quota_formats;
164 quota_formats = fmt;
165 spin_unlock(&dq_list_lock);
166 return 0;
167}
Mingming Cao08d03502009-01-14 16:19:32 +0100168EXPORT_SYMBOL(register_quota_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169
170void unregister_quota_format(struct quota_format_type *fmt)
171{
172 struct quota_format_type **actqf;
173
174 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100175 for (actqf = &quota_formats; *actqf && *actqf != fmt;
176 actqf = &(*actqf)->qf_next)
177 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178 if (*actqf)
179 *actqf = (*actqf)->qf_next;
180 spin_unlock(&dq_list_lock);
181}
Mingming Cao08d03502009-01-14 16:19:32 +0100182EXPORT_SYMBOL(unregister_quota_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183
184static struct quota_format_type *find_quota_format(int id)
185{
186 struct quota_format_type *actqf;
187
188 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100189 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
190 actqf = actqf->qf_next)
191 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 if (!actqf || !try_module_get(actqf->qf_owner)) {
193 int qm;
194
195 spin_unlock(&dq_list_lock);
196
Jan Kara268157b2009-01-27 15:47:22 +0100197 for (qm = 0; module_names[qm].qm_fmt_id &&
198 module_names[qm].qm_fmt_id != id; qm++)
199 ;
200 if (!module_names[qm].qm_fmt_id ||
201 request_module(module_names[qm].qm_mod_name))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 return NULL;
203
204 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100205 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
206 actqf = actqf->qf_next)
207 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 if (actqf && !try_module_get(actqf->qf_owner))
209 actqf = NULL;
210 }
211 spin_unlock(&dq_list_lock);
212 return actqf;
213}
214
215static void put_quota_format(struct quota_format_type *fmt)
216{
217 module_put(fmt->qf_owner);
218}
219
220/*
221 * Dquot List Management:
222 * The quota code uses three lists for dquot management: the inuse_list,
223 * free_dquots, and dquot_hash[] array. A single dquot structure may be
224 * on all three lists, depending on its current state.
225 *
226 * All dquots are placed to the end of inuse_list when first created, and this
227 * list is used for invalidate operation, which must look at every dquot.
228 *
229 * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
230 * and this list is searched whenever we need an available dquot. Dquots are
231 * removed from the list as soon as they are used again, and
232 * dqstats.free_dquots gives the number of dquots on the list. When
233 * dquot is invalidated it's completely released from memory.
234 *
235 * Dquots with a specific identity (device, type and id) are placed on
236 * one of the dquot_hash[] hash chains. The provides an efficient search
237 * mechanism to locate a specific dquot.
238 */
239
240static LIST_HEAD(inuse_list);
241static LIST_HEAD(free_dquots);
242static unsigned int dq_hash_bits, dq_hash_mask;
243static struct hlist_head *dquot_hash;
244
245struct dqstats dqstats;
Mingming Cao08d03502009-01-14 16:19:32 +0100246EXPORT_SYMBOL(dqstats);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247
Jan Kara0a5a9c72010-02-09 18:20:39 +0100248static qsize_t inode_get_rsv_space(struct inode *inode);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500249static void __dquot_initialize(struct inode *inode, int type);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100250
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251static inline unsigned int
252hashfn(const struct super_block *sb, unsigned int id, int type)
253{
254 unsigned long tmp;
255
256 tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
257 return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
258}
259
260/*
261 * Following list functions expect dq_list_lock to be held
262 */
263static inline void insert_dquot_hash(struct dquot *dquot)
264{
Jan Kara268157b2009-01-27 15:47:22 +0100265 struct hlist_head *head;
266 head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 hlist_add_head(&dquot->dq_hash, head);
268}
269
270static inline void remove_dquot_hash(struct dquot *dquot)
271{
272 hlist_del_init(&dquot->dq_hash);
273}
274
Jan Kara7a2435d2009-01-27 01:47:11 +0100275static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
276 unsigned int id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277{
278 struct hlist_node *node;
279 struct dquot *dquot;
280
281 hlist_for_each (node, dquot_hash+hashent) {
282 dquot = hlist_entry(node, struct dquot, dq_hash);
Jan Kara268157b2009-01-27 15:47:22 +0100283 if (dquot->dq_sb == sb && dquot->dq_id == id &&
284 dquot->dq_type == type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285 return dquot;
286 }
Jan Karadd6f3c62009-01-26 16:01:43 +0100287 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288}
289
290/* Add a dquot to the tail of the free list */
291static inline void put_dquot_last(struct dquot *dquot)
292{
Akinobu Mita8e130592006-06-26 00:24:37 -0700293 list_add_tail(&dquot->dq_free, &free_dquots);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400294 dqstats_inc(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295}
296
297static inline void remove_free_dquot(struct dquot *dquot)
298{
299 if (list_empty(&dquot->dq_free))
300 return;
301 list_del_init(&dquot->dq_free);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400302 dqstats_dec(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700303}
304
305static inline void put_inuse(struct dquot *dquot)
306{
307 /* We add to the back of inuse list so we don't have to restart
308 * when traversing this list and we block */
Akinobu Mita8e130592006-06-26 00:24:37 -0700309 list_add_tail(&dquot->dq_inuse, &inuse_list);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400310 dqstats_inc(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311}
312
313static inline void remove_inuse(struct dquot *dquot)
314{
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400315 dqstats_dec(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316 list_del(&dquot->dq_inuse);
317}
318/*
319 * End of list functions needing dq_list_lock
320 */
321
322static void wait_on_dquot(struct dquot *dquot)
323{
Ingo Molnard3be9152006-03-23 03:00:29 -0800324 mutex_lock(&dquot->dq_lock);
325 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
Jan Kara03f6e922008-04-28 02:14:32 -0700328static inline int dquot_dirty(struct dquot *dquot)
329{
330 return test_bit(DQ_MOD_B, &dquot->dq_flags);
331}
332
333static inline int mark_dquot_dirty(struct dquot *dquot)
334{
335 return dquot->dq_sb->dq_op->mark_dirty(dquot);
336}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300338/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339int dquot_mark_dquot_dirty(struct dquot *dquot)
340{
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300341 int ret = 1;
342
343 /* If quota is dirty already, we don't have to acquire dq_list_lock */
344 if (test_bit(DQ_MOD_B, &dquot->dq_flags))
345 return 1;
346
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 spin_lock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300348 if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700349 list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
350 info[dquot->dq_type].dqi_dirty_list);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300351 ret = 0;
352 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 spin_unlock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300354 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355}
Mingming Cao08d03502009-01-14 16:19:32 +0100356EXPORT_SYMBOL(dquot_mark_dquot_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +0300358/* Dirtify all the dquots - this can block when journalling */
359static inline int mark_all_dquot_dirty(struct dquot * const *dquot)
360{
361 int ret, err, cnt;
362
363 ret = err = 0;
364 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
365 if (dquot[cnt])
366 /* Even in case of error we have to continue */
367 ret = mark_dquot_dirty(dquot[cnt]);
368 if (!err)
369 err = ret;
370 }
371 return err;
372}
373
374static inline void dqput_all(struct dquot **dquot)
375{
376 unsigned int cnt;
377
378 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
379 dqput(dquot[cnt]);
380}
381
Linus Torvalds1da177e2005-04-16 15:20:36 -0700382/* This function needs dq_list_lock */
383static inline int clear_dquot_dirty(struct dquot *dquot)
384{
385 if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags))
386 return 0;
387 list_del_init(&dquot->dq_dirty);
388 return 1;
389}
390
391void mark_info_dirty(struct super_block *sb, int type)
392{
393 set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags);
394}
395EXPORT_SYMBOL(mark_info_dirty);
396
397/*
398 * Read dquot from disk and alloc space for it
399 */
400
401int dquot_acquire(struct dquot *dquot)
402{
403 int ret = 0, ret2 = 0;
404 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
405
Ingo Molnard3be9152006-03-23 03:00:29 -0800406 mutex_lock(&dquot->dq_lock);
407 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408 if (!test_bit(DQ_READ_B, &dquot->dq_flags))
409 ret = dqopt->ops[dquot->dq_type]->read_dqblk(dquot);
410 if (ret < 0)
411 goto out_iolock;
412 set_bit(DQ_READ_B, &dquot->dq_flags);
413 /* Instantiate dquot if needed */
414 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
415 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
416 /* Write the info if needed */
Jan Kara268157b2009-01-27 15:47:22 +0100417 if (info_dirty(&dqopt->info[dquot->dq_type])) {
418 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
419 dquot->dq_sb, dquot->dq_type);
420 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 if (ret < 0)
422 goto out_iolock;
423 if (ret2 < 0) {
424 ret = ret2;
425 goto out_iolock;
426 }
427 }
428 set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
429out_iolock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800430 mutex_unlock(&dqopt->dqio_mutex);
431 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 return ret;
433}
Mingming Cao08d03502009-01-14 16:19:32 +0100434EXPORT_SYMBOL(dquot_acquire);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700435
436/*
437 * Write dquot to disk
438 */
439int dquot_commit(struct dquot *dquot)
440{
441 int ret = 0, ret2 = 0;
442 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
443
Ingo Molnard3be9152006-03-23 03:00:29 -0800444 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 spin_lock(&dq_list_lock);
446 if (!clear_dquot_dirty(dquot)) {
447 spin_unlock(&dq_list_lock);
448 goto out_sem;
449 }
450 spin_unlock(&dq_list_lock);
451 /* Inactive dquot can be only if there was error during read/init
452 * => we have better not writing it */
453 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
454 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
Jan Kara268157b2009-01-27 15:47:22 +0100455 if (info_dirty(&dqopt->info[dquot->dq_type])) {
456 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
457 dquot->dq_sb, dquot->dq_type);
458 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 if (ret >= 0)
460 ret = ret2;
461 }
462out_sem:
Ingo Molnard3be9152006-03-23 03:00:29 -0800463 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 return ret;
465}
Mingming Cao08d03502009-01-14 16:19:32 +0100466EXPORT_SYMBOL(dquot_commit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468/*
469 * Release dquot
470 */
471int dquot_release(struct dquot *dquot)
472{
473 int ret = 0, ret2 = 0;
474 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
475
Ingo Molnard3be9152006-03-23 03:00:29 -0800476 mutex_lock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /* Check whether we are not racing with some other dqget() */
478 if (atomic_read(&dquot->dq_count) > 1)
479 goto out_dqlock;
Ingo Molnard3be9152006-03-23 03:00:29 -0800480 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 if (dqopt->ops[dquot->dq_type]->release_dqblk) {
482 ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot);
483 /* Write the info */
Jan Kara268157b2009-01-27 15:47:22 +0100484 if (info_dirty(&dqopt->info[dquot->dq_type])) {
485 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
486 dquot->dq_sb, dquot->dq_type);
487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 if (ret >= 0)
489 ret = ret2;
490 }
491 clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
Ingo Molnard3be9152006-03-23 03:00:29 -0800492 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493out_dqlock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800494 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return ret;
496}
Mingming Cao08d03502009-01-14 16:19:32 +0100497EXPORT_SYMBOL(dquot_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Jan Kara7d9056b2008-11-25 15:31:32 +0100499void dquot_destroy(struct dquot *dquot)
Jan Kara74f783a2008-08-19 14:51:22 +0200500{
501 kmem_cache_free(dquot_cachep, dquot);
502}
Jan Kara7d9056b2008-11-25 15:31:32 +0100503EXPORT_SYMBOL(dquot_destroy);
Jan Kara74f783a2008-08-19 14:51:22 +0200504
505static inline void do_destroy_dquot(struct dquot *dquot)
506{
507 dquot->dq_sb->dq_op->destroy_dquot(dquot);
508}
509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510/* Invalidate all dquots on the list. Note that this function is called after
511 * quota is disabled and pointers from inodes removed so there cannot be new
Jan Kara6362e4d2006-03-23 03:00:17 -0800512 * quota users. There can still be some users of quotas due to inodes being
513 * just deleted or pruned by prune_icache() (those are not attached to any
Jan Karacc334122009-01-12 17:23:05 +0100514 * list) or parallel quotactl call. We have to wait for such users.
Jan Kara6362e4d2006-03-23 03:00:17 -0800515 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516static void invalidate_dquots(struct super_block *sb, int type)
517{
Domen Puncerc33ed272005-06-25 14:59:36 -0700518 struct dquot *dquot, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Jan Kara6362e4d2006-03-23 03:00:17 -0800520restart:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 spin_lock(&dq_list_lock);
Domen Puncerc33ed272005-06-25 14:59:36 -0700522 list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (dquot->dq_sb != sb)
524 continue;
525 if (dquot->dq_type != type)
526 continue;
Jan Kara6362e4d2006-03-23 03:00:17 -0800527 /* Wait for dquot users */
528 if (atomic_read(&dquot->dq_count)) {
529 DEFINE_WAIT(wait);
530
531 atomic_inc(&dquot->dq_count);
532 prepare_to_wait(&dquot->dq_wait_unused, &wait,
533 TASK_UNINTERRUPTIBLE);
534 spin_unlock(&dq_list_lock);
535 /* Once dqput() wakes us up, we know it's time to free
536 * the dquot.
537 * IMPORTANT: we rely on the fact that there is always
538 * at most one process waiting for dquot to free.
539 * Otherwise dq_count would be > 1 and we would never
540 * wake up.
541 */
542 if (atomic_read(&dquot->dq_count) > 1)
543 schedule();
544 finish_wait(&dquot->dq_wait_unused, &wait);
545 dqput(dquot);
546 /* At this moment dquot() need not exist (it could be
547 * reclaimed by prune_dqcache(). Hence we must
548 * restart. */
549 goto restart;
550 }
551 /*
552 * Quota now has no users and it has been written on last
553 * dqput()
554 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 remove_dquot_hash(dquot);
556 remove_free_dquot(dquot);
557 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200558 do_destroy_dquot(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
560 spin_unlock(&dq_list_lock);
561}
562
Jan Kara12c77522008-10-20 17:05:00 +0200563/* Call callback for every active dquot on given filesystem */
564int dquot_scan_active(struct super_block *sb,
565 int (*fn)(struct dquot *dquot, unsigned long priv),
566 unsigned long priv)
567{
568 struct dquot *dquot, *old_dquot = NULL;
569 int ret = 0;
570
571 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
572 spin_lock(&dq_list_lock);
573 list_for_each_entry(dquot, &inuse_list, dq_inuse) {
574 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
575 continue;
576 if (dquot->dq_sb != sb)
577 continue;
578 /* Now we have active dquot so we can just increase use count */
579 atomic_inc(&dquot->dq_count);
Jan Kara12c77522008-10-20 17:05:00 +0200580 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400581 dqstats_inc(DQST_LOOKUPS);
Jan Kara12c77522008-10-20 17:05:00 +0200582 dqput(old_dquot);
583 old_dquot = dquot;
584 ret = fn(dquot, priv);
585 if (ret < 0)
586 goto out;
587 spin_lock(&dq_list_lock);
588 /* We are safe to continue now because our dquot could not
589 * be moved out of the inuse list while we hold the reference */
590 }
591 spin_unlock(&dq_list_lock);
592out:
593 dqput(old_dquot);
594 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
595 return ret;
596}
Mingming Cao08d03502009-01-14 16:19:32 +0100597EXPORT_SYMBOL(dquot_scan_active);
Jan Kara12c77522008-10-20 17:05:00 +0200598
Christoph Hellwig287a8092010-05-19 07:16:45 -0400599int dquot_quota_sync(struct super_block *sb, int type, int wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
601 struct list_head *dirty;
602 struct dquot *dquot;
603 struct quota_info *dqopt = sb_dqopt(sb);
604 int cnt;
605
Ingo Molnard3be9152006-03-23 03:00:29 -0800606 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
608 if (type != -1 && cnt != type)
609 continue;
Jan Karaf55abc02008-08-20 17:50:32 +0200610 if (!sb_has_quota_active(sb, cnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 continue;
612 spin_lock(&dq_list_lock);
613 dirty = &dqopt->info[cnt].dqi_dirty_list;
614 while (!list_empty(dirty)) {
Jan Kara268157b2009-01-27 15:47:22 +0100615 dquot = list_first_entry(dirty, struct dquot,
616 dq_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 /* Dirty and inactive can be only bad dquot... */
618 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
619 clear_dquot_dirty(dquot);
620 continue;
621 }
622 /* Now we have active dquot from which someone is
623 * holding reference so we can safely just increase
624 * use count */
625 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400627 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 sb->dq_op->write_dquot(dquot);
629 dqput(dquot);
630 spin_lock(&dq_list_lock);
631 }
632 spin_unlock(&dq_list_lock);
633 }
634
635 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karaf55abc02008-08-20 17:50:32 +0200636 if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
637 && info_dirty(&dqopt->info[cnt]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 sb->dq_op->write_info(sb, cnt);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400639 dqstats_inc(DQST_SYNCS);
Ingo Molnard3be9152006-03-23 03:00:29 -0800640 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500642 if (!wait || (sb_dqopt(sb)->flags & DQUOT_QUOTA_SYS_FILE))
643 return 0;
644
645 /* This is not very clever (and fast) but currently I don't know about
646 * any other simple way of getting quota data to disk and we must get
647 * them there for userspace to be visible... */
648 if (sb->s_op->sync_fs)
649 sb->s_op->sync_fs(sb, 1);
650 sync_blockdev(sb->s_bdev);
651
652 /*
653 * Now when everything is written we can discard the pagecache so
654 * that userspace sees the changes.
655 */
656 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
657 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
658 if (type != -1 && cnt != type)
659 continue;
660 if (!sb_has_quota_active(sb, cnt))
661 continue;
662 mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex,
663 I_MUTEX_QUOTA);
664 truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0);
665 mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex);
666 }
667 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
668
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 return 0;
670}
Christoph Hellwig287a8092010-05-19 07:16:45 -0400671EXPORT_SYMBOL(dquot_quota_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672
673/* Free unused dquots from cache */
674static void prune_dqcache(int count)
675{
676 struct list_head *head;
677 struct dquot *dquot;
678
679 head = free_dquots.prev;
680 while (head != &free_dquots && count) {
681 dquot = list_entry(head, struct dquot, dq_free);
682 remove_dquot_hash(dquot);
683 remove_free_dquot(dquot);
684 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200685 do_destroy_dquot(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 count--;
687 head = free_dquots.prev;
688 }
689}
690
691/*
692 * This is called from kswapd when we think we need some
693 * more memory
694 */
Al Viro27496a82005-10-21 03:20:48 -0400695static int shrink_dqcache_memory(int nr, gfp_t gfp_mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696{
697 if (nr) {
698 spin_lock(&dq_list_lock);
699 prune_dqcache(nr);
700 spin_unlock(&dq_list_lock);
701 }
Dmitry Monakhovf32764b2010-05-26 23:21:58 +0200702 return ((unsigned)
703 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])
704 /100) * sysctl_vfs_cache_pressure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705}
706
Rusty Russell8e1f9362007-07-17 04:03:17 -0700707static struct shrinker dqcache_shrinker = {
708 .shrink = shrink_dqcache_memory,
709 .seeks = DEFAULT_SEEKS,
710};
711
Linus Torvalds1da177e2005-04-16 15:20:36 -0700712/*
713 * Put reference to dquot
714 * NOTE: If you change this function please check whether dqput_blocks() works right...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200716void dqput(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717{
Jan Karab48d3802008-07-25 01:46:49 -0700718 int ret;
719
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 if (!dquot)
721 return;
Jan Kara62af9b52010-04-19 16:47:20 +0200722#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 if (!atomic_read(&dquot->dq_count)) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200724 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
725 quotatypes[dquot->dq_type], dquot->dq_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 BUG();
727 }
728#endif
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400729 dqstats_inc(DQST_DROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730we_slept:
731 spin_lock(&dq_list_lock);
732 if (atomic_read(&dquot->dq_count) > 1) {
733 /* We have more than one user... nothing to do */
734 atomic_dec(&dquot->dq_count);
Jan Kara6362e4d2006-03-23 03:00:17 -0800735 /* Releasing dquot during quotaoff phase? */
Jan Karaf55abc02008-08-20 17:50:32 +0200736 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) &&
Jan Kara6362e4d2006-03-23 03:00:17 -0800737 atomic_read(&dquot->dq_count) == 1)
738 wake_up(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 spin_unlock(&dq_list_lock);
740 return;
741 }
742 /* Need to release dquot? */
743 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
744 spin_unlock(&dq_list_lock);
745 /* Commit dquot before releasing */
Jan Karab48d3802008-07-25 01:46:49 -0700746 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
747 if (ret < 0) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200748 quota_error(dquot->dq_sb, "Can't write quota structure"
749 " (error %d). Quota may get out of sync!",
750 ret);
Jan Karab48d3802008-07-25 01:46:49 -0700751 /*
752 * We clear dirty bit anyway, so that we avoid
753 * infinite loop here
754 */
755 spin_lock(&dq_list_lock);
756 clear_dquot_dirty(dquot);
757 spin_unlock(&dq_list_lock);
758 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 goto we_slept;
760 }
761 /* Clear flag in case dquot was inactive (something bad happened) */
762 clear_dquot_dirty(dquot);
763 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
764 spin_unlock(&dq_list_lock);
765 dquot->dq_sb->dq_op->release_dquot(dquot);
766 goto we_slept;
767 }
768 atomic_dec(&dquot->dq_count);
Jan Kara62af9b52010-04-19 16:47:20 +0200769#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 /* sanity check */
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200771 BUG_ON(!list_empty(&dquot->dq_free));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772#endif
773 put_dquot_last(dquot);
774 spin_unlock(&dq_list_lock);
775}
Mingming Cao08d03502009-01-14 16:19:32 +0100776EXPORT_SYMBOL(dqput);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Jan Kara7d9056b2008-11-25 15:31:32 +0100778struct dquot *dquot_alloc(struct super_block *sb, int type)
Jan Kara74f783a2008-08-19 14:51:22 +0200779{
780 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
781}
Jan Kara7d9056b2008-11-25 15:31:32 +0100782EXPORT_SYMBOL(dquot_alloc);
Jan Kara74f783a2008-08-19 14:51:22 +0200783
Linus Torvalds1da177e2005-04-16 15:20:36 -0700784static struct dquot *get_empty_dquot(struct super_block *sb, int type)
785{
786 struct dquot *dquot;
787
Jan Kara74f783a2008-08-19 14:51:22 +0200788 dquot = sb->dq_op->alloc_dquot(sb, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 if(!dquot)
Jan Karadd6f3c62009-01-26 16:01:43 +0100790 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791
Ingo Molnard3be9152006-03-23 03:00:29 -0800792 mutex_init(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 INIT_LIST_HEAD(&dquot->dq_free);
794 INIT_LIST_HEAD(&dquot->dq_inuse);
795 INIT_HLIST_NODE(&dquot->dq_hash);
796 INIT_LIST_HEAD(&dquot->dq_dirty);
Jan Kara6362e4d2006-03-23 03:00:17 -0800797 init_waitqueue_head(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700798 dquot->dq_sb = sb;
799 dquot->dq_type = type;
800 atomic_set(&dquot->dq_count, 1);
801
802 return dquot;
803}
804
805/*
806 * Get reference to dquot
Jan Karacc334122009-01-12 17:23:05 +0100807 *
808 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
809 * destroying our dquot by:
810 * a) checking for quota flags under dq_list_lock and
811 * b) getting a reference to dquot before we release dq_list_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200813struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814{
815 unsigned int hashent = hashfn(sb, id, type);
Jan Karadd6f3c62009-01-26 16:01:43 +0100816 struct dquot *dquot = NULL, *empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817
Jan Karaf55abc02008-08-20 17:50:32 +0200818 if (!sb_has_quota_active(sb, type))
Jan Karadd6f3c62009-01-26 16:01:43 +0100819 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820we_slept:
821 spin_lock(&dq_list_lock);
Jan Karacc334122009-01-12 17:23:05 +0100822 spin_lock(&dq_state_lock);
823 if (!sb_has_quota_active(sb, type)) {
824 spin_unlock(&dq_state_lock);
825 spin_unlock(&dq_list_lock);
826 goto out;
827 }
828 spin_unlock(&dq_state_lock);
829
Jan Karadd6f3c62009-01-26 16:01:43 +0100830 dquot = find_dquot(hashent, sb, id, type);
831 if (!dquot) {
832 if (!empty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833 spin_unlock(&dq_list_lock);
Jan Karadd6f3c62009-01-26 16:01:43 +0100834 empty = get_empty_dquot(sb, type);
835 if (!empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 schedule(); /* Try to wait for a moment... */
837 goto we_slept;
838 }
839 dquot = empty;
Jan Karadd6f3c62009-01-26 16:01:43 +0100840 empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 dquot->dq_id = id;
842 /* all dquots go on the inuse_list */
843 put_inuse(dquot);
844 /* hash it first so it can be found */
845 insert_dquot_hash(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400847 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 } else {
849 if (!atomic_read(&dquot->dq_count))
850 remove_free_dquot(dquot);
851 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400853 dqstats_inc(DQST_CACHE_HITS);
854 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 }
Jan Kara268157b2009-01-27 15:47:22 +0100856 /* Wait for dq_lock - after this we know that either dquot_release() is
857 * already finished or it will be canceled due to dq_count > 1 test */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 wait_on_dquot(dquot);
Jan Kara268157b2009-01-27 15:47:22 +0100859 /* Read the dquot / allocate space in quota file */
860 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
861 sb->dq_op->acquire_dquot(dquot) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700862 dqput(dquot);
Jan Karadd6f3c62009-01-26 16:01:43 +0100863 dquot = NULL;
Jan Karacc334122009-01-12 17:23:05 +0100864 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 }
Jan Kara62af9b52010-04-19 16:47:20 +0200866#ifdef CONFIG_QUOTA_DEBUG
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200867 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868#endif
Jan Karacc334122009-01-12 17:23:05 +0100869out:
870 if (empty)
871 do_destroy_dquot(empty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
873 return dquot;
874}
Mingming Cao08d03502009-01-14 16:19:32 +0100875EXPORT_SYMBOL(dqget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876
877static int dqinit_needed(struct inode *inode, int type)
878{
879 int cnt;
880
881 if (IS_NOQUOTA(inode))
882 return 0;
883 if (type != -1)
Jan Karadd6f3c62009-01-26 16:01:43 +0100884 return !inode->i_dquot[type];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karadd6f3c62009-01-26 16:01:43 +0100886 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 return 1;
888 return 0;
889}
890
Ingo Molnard3be9152006-03-23 03:00:29 -0800891/* This routine is guarded by dqonoff_mutex mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700892static void add_dquot_ref(struct super_block *sb, int type)
893{
Jan Kara941d2382008-02-06 01:37:36 -0800894 struct inode *inode, *old_inode = NULL;
Jan Kara62af9b52010-04-19 16:47:20 +0200895#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100896 int reserved = 0;
Jan Kara4c5e6c02010-04-06 18:52:47 +0200897#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800899 spin_lock(&inode_lock);
900 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Wu Fengguangb6fac632009-04-02 16:56:34 -0700901 if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW))
Nick Pigginaabb8fd2009-03-11 13:17:36 -0700902 continue;
Jan Kara62af9b52010-04-19 16:47:20 +0200903#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100904 if (unlikely(inode_get_rsv_space(inode) > 0))
905 reserved = 1;
Jan Kara4c5e6c02010-04-06 18:52:47 +0200906#endif
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800907 if (!atomic_read(&inode->i_writecount))
908 continue;
909 if (!dqinit_needed(inode, type))
910 continue;
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800911
912 __iget(inode);
913 spin_unlock(&inode_lock);
914
Jan Kara941d2382008-02-06 01:37:36 -0800915 iput(old_inode);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500916 __dquot_initialize(inode, type);
Jan Kara941d2382008-02-06 01:37:36 -0800917 /* We hold a reference to 'inode' so it couldn't have been
918 * removed from s_inodes list while we dropped the inode_lock.
919 * We cannot iput the inode now as we can be holding the last
920 * reference and we cannot iput it under inode_lock. So we
921 * keep the reference and iput it later. */
922 old_inode = inode;
923 spin_lock(&inode_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700924 }
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800925 spin_unlock(&inode_lock);
Jan Kara941d2382008-02-06 01:37:36 -0800926 iput(old_inode);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100927
Jan Kara62af9b52010-04-19 16:47:20 +0200928#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100929 if (reserved) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200930 quota_error(sb, "Writes happened before quota was turned on "
931 "thus quota information is probably inconsistent. "
932 "Please run quotacheck(8)");
Jan Kara0a5a9c72010-02-09 18:20:39 +0100933 }
Jan Kara4c5e6c02010-04-06 18:52:47 +0200934#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935}
936
Jan Kara268157b2009-01-27 15:47:22 +0100937/*
938 * Return 0 if dqput() won't block.
939 * (note that 1 doesn't necessarily mean blocking)
940 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941static inline int dqput_blocks(struct dquot *dquot)
942{
943 if (atomic_read(&dquot->dq_count) <= 1)
944 return 1;
945 return 0;
946}
947
Jan Kara268157b2009-01-27 15:47:22 +0100948/*
949 * Remove references to dquots from inode and add dquot to list for freeing
950 * if we have the last referece to dquot
951 * We can't race with anybody because we hold dqptr_sem for writing...
952 */
Adrian Bunke5f00f42007-05-08 00:27:22 -0700953static int remove_inode_dquot_ref(struct inode *inode, int type,
954 struct list_head *tofree_head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700955{
956 struct dquot *dquot = inode->i_dquot[type];
957
Jan Karadd6f3c62009-01-26 16:01:43 +0100958 inode->i_dquot[type] = NULL;
959 if (dquot) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700960 if (dqput_blocks(dquot)) {
Jan Kara62af9b52010-04-19 16:47:20 +0200961#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 if (atomic_read(&dquot->dq_count) != 1)
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200963 quota_error(inode->i_sb, "Adding dquot with "
964 "dq_count %d to dispose list",
965 atomic_read(&dquot->dq_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966#endif
967 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100968 /* As dquot must have currently users it can't be on
969 * the free list... */
970 list_add(&dquot->dq_free, tofree_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971 spin_unlock(&dq_list_lock);
972 return 1;
973 }
974 else
975 dqput(dquot); /* We have guaranteed we won't block */
976 }
977 return 0;
978}
979
Jan Kara268157b2009-01-27 15:47:22 +0100980/*
981 * Free list of dquots
982 * Dquots are removed from inodes and no new references can be got so we are
983 * the only ones holding reference
984 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700985static void put_dquot_list(struct list_head *tofree_head)
986{
987 struct list_head *act_head;
988 struct dquot *dquot;
989
990 act_head = tofree_head->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700991 while (act_head != tofree_head) {
992 dquot = list_entry(act_head, struct dquot, dq_free);
993 act_head = act_head->next;
Jan Kara268157b2009-01-27 15:47:22 +0100994 /* Remove dquot from the list so we won't have problems... */
995 list_del_init(&dquot->dq_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 dqput(dquot);
997 }
998}
999
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001000static void remove_dquot_ref(struct super_block *sb, int type,
1001 struct list_head *tofree_head)
1002{
1003 struct inode *inode;
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001004 int reserved = 0;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001005
1006 spin_lock(&inode_lock);
1007 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Nick Pigginaabb8fd2009-03-11 13:17:36 -07001008 /*
1009 * We have to scan also I_NEW inodes because they can already
1010 * have quota pointer initialized. Luckily, we need to touch
1011 * only quota pointers and these have separate locking
1012 * (dqptr_sem).
1013 */
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001014 if (!IS_NOQUOTA(inode)) {
1015 if (unlikely(inode_get_rsv_space(inode) > 0))
1016 reserved = 1;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001017 remove_inode_dquot_ref(inode, type, tofree_head);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001018 }
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001019 }
1020 spin_unlock(&inode_lock);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001021#ifdef CONFIG_QUOTA_DEBUG
1022 if (reserved) {
1023 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1024 " was disabled thus quota information is probably "
1025 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1026 }
1027#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001028}
1029
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030/* Gather all references from inodes and drop them */
1031static void drop_dquot_ref(struct super_block *sb, int type)
1032{
1033 LIST_HEAD(tofree_head);
1034
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001035 if (sb->dq_op) {
1036 down_write(&sb_dqopt(sb)->dqptr_sem);
1037 remove_dquot_ref(sb, type, &tofree_head);
1038 up_write(&sb_dqopt(sb)->dqptr_sem);
1039 put_dquot_list(&tofree_head);
1040 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041}
1042
Jan Kara12095462008-08-20 14:45:12 +02001043static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044{
1045 dquot->dq_dqb.dqb_curinodes += number;
1046}
1047
1048static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
1049{
1050 dquot->dq_dqb.dqb_curspace += number;
1051}
1052
Mingming Caof18df222009-01-13 16:43:09 +01001053static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
1054{
1055 dquot->dq_dqb.dqb_rsvspace += number;
1056}
1057
Mingming Cao740d9dc2009-01-13 16:43:14 +01001058/*
1059 * Claim reserved quota space
1060 */
Jan Kara0a5a9c72010-02-09 18:20:39 +01001061static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001062{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001063 if (dquot->dq_dqb.dqb_rsvspace < number) {
1064 WARN_ON_ONCE(1);
1065 number = dquot->dq_dqb.dqb_rsvspace;
1066 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001067 dquot->dq_dqb.dqb_curspace += number;
1068 dquot->dq_dqb.dqb_rsvspace -= number;
1069}
1070
1071static inline
1072void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1073{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001074 if (dquot->dq_dqb.dqb_rsvspace >= number)
1075 dquot->dq_dqb.dqb_rsvspace -= number;
1076 else {
1077 WARN_ON_ONCE(1);
1078 dquot->dq_dqb.dqb_rsvspace = 0;
1079 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001080}
1081
Jan Kara7a2435d2009-01-27 01:47:11 +01001082static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083{
Jan Karadb49d2d2008-10-01 18:21:39 +02001084 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1085 dquot->dq_dqb.dqb_curinodes >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001086 dquot->dq_dqb.dqb_curinodes -= number;
1087 else
1088 dquot->dq_dqb.dqb_curinodes = 0;
1089 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1090 dquot->dq_dqb.dqb_itime = (time_t) 0;
1091 clear_bit(DQ_INODES_B, &dquot->dq_flags);
1092}
1093
Jan Kara7a2435d2009-01-27 01:47:11 +01001094static void dquot_decr_space(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001095{
Jan Karadb49d2d2008-10-01 18:21:39 +02001096 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1097 dquot->dq_dqb.dqb_curspace >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 dquot->dq_dqb.dqb_curspace -= number;
1099 else
1100 dquot->dq_dqb.dqb_curspace = 0;
Jan Kara12095462008-08-20 14:45:12 +02001101 if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 dquot->dq_dqb.dqb_btime = (time_t) 0;
1103 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1104}
1105
Jan Karac5254602007-12-22 14:03:25 -08001106static int warning_issued(struct dquot *dquot, const int warntype)
1107{
1108 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1109 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1110 ((warntype == QUOTA_NL_IHARDWARN ||
1111 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1112
1113 if (!flag)
1114 return 0;
1115 return test_and_set_bit(flag, &dquot->dq_flags);
1116}
1117
Jan Kara8e893462007-10-16 23:29:31 -07001118#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119static int flag_print_warnings = 1;
1120
Jan Kara7a2435d2009-01-27 01:47:11 +01001121static int need_print_warning(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122{
1123 if (!flag_print_warnings)
1124 return 0;
1125
1126 switch (dquot->dq_type) {
1127 case USRQUOTA:
David Howellsda9592e2008-11-14 10:39:05 +11001128 return current_fsuid() == dquot->dq_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129 case GRPQUOTA:
1130 return in_group_p(dquot->dq_id);
1131 }
1132 return 0;
1133}
1134
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135/* Print warning to user which exceeded quota */
Jan Karac5254602007-12-22 14:03:25 -08001136static void print_warning(struct dquot *dquot, const int warntype)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137{
1138 char *msg = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001139 struct tty_struct *tty;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Jan Kara657d3bf2008-07-25 01:46:52 -07001141 if (warntype == QUOTA_NL_IHARDBELOW ||
1142 warntype == QUOTA_NL_ISOFTBELOW ||
1143 warntype == QUOTA_NL_BHARDBELOW ||
1144 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(dquot))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001145 return;
1146
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001147 tty = get_current_tty();
1148 if (!tty)
Alan Cox452a00d2008-10-13 10:39:13 +01001149 return;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001150 tty_write_message(tty, dquot->dq_sb->s_id);
Jan Kara8e893462007-10-16 23:29:31 -07001151 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001152 tty_write_message(tty, ": warning, ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153 else
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001154 tty_write_message(tty, ": write failed, ");
1155 tty_write_message(tty, quotatypes[dquot->dq_type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 switch (warntype) {
Jan Kara8e893462007-10-16 23:29:31 -07001157 case QUOTA_NL_IHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 msg = " file limit reached.\r\n";
1159 break;
Jan Kara8e893462007-10-16 23:29:31 -07001160 case QUOTA_NL_ISOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 msg = " file quota exceeded too long.\r\n";
1162 break;
Jan Kara8e893462007-10-16 23:29:31 -07001163 case QUOTA_NL_ISOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164 msg = " file quota exceeded.\r\n";
1165 break;
Jan Kara8e893462007-10-16 23:29:31 -07001166 case QUOTA_NL_BHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001167 msg = " block limit reached.\r\n";
1168 break;
Jan Kara8e893462007-10-16 23:29:31 -07001169 case QUOTA_NL_BSOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001170 msg = " block quota exceeded too long.\r\n";
1171 break;
Jan Kara8e893462007-10-16 23:29:31 -07001172 case QUOTA_NL_BSOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001173 msg = " block quota exceeded.\r\n";
1174 break;
1175 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001176 tty_write_message(tty, msg);
Alan Cox452a00d2008-10-13 10:39:13 +01001177 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001178}
Jan Kara8e893462007-10-16 23:29:31 -07001179#endif
1180
Mingming Caof18df222009-01-13 16:43:09 +01001181/*
1182 * Write warnings to the console and send warning messages over netlink.
1183 *
1184 * Note that this function can sleep.
1185 */
Jan Kara7a2435d2009-01-27 01:47:11 +01001186static void flush_warnings(struct dquot *const *dquots, char *warntype)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001187{
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001188 struct dquot *dq;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 int i;
1190
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001191 for (i = 0; i < MAXQUOTAS; i++) {
1192 dq = dquots[i];
1193 if (dq && warntype[i] != QUOTA_NL_NOWARN &&
1194 !warning_issued(dq, warntype[i])) {
Jan Kara8e893462007-10-16 23:29:31 -07001195#ifdef CONFIG_PRINT_QUOTA_WARNING
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001196 print_warning(dq, warntype[i]);
Jan Kara8e893462007-10-16 23:29:31 -07001197#endif
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001198 quota_send_warning(dq->dq_type, dq->dq_id,
1199 dq->dq_sb->s_dev, warntype[i]);
Jan Kara8e893462007-10-16 23:29:31 -07001200 }
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001201 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202}
1203
Jan Kara7a2435d2009-01-27 01:47:11 +01001204static int ignore_hardlimit(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205{
1206 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];
1207
1208 return capable(CAP_SYS_RESOURCE) &&
Jan Kara268157b2009-01-27 15:47:22 +01001209 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1210 !(info->dqi_flags & V1_DQF_RSQUASH));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211}
1212
1213/* needs dq_data_lock */
Jan Kara12095462008-08-20 14:45:12 +02001214static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215{
Jan Kara268157b2009-01-27 15:47:22 +01001216 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1217
Jan Kara8e893462007-10-16 23:29:31 -07001218 *warntype = QUOTA_NL_NOWARN;
Jan Karaf55abc02008-08-20 17:50:32 +02001219 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) ||
1220 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001221 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001222
1223 if (dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001224 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001225 !ignore_hardlimit(dquot)) {
Jan Kara8e893462007-10-16 23:29:31 -07001226 *warntype = QUOTA_NL_IHARDWARN;
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001227 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001228 }
1229
1230 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001231 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1232 dquot->dq_dqb.dqb_itime &&
1233 get_seconds() >= dquot->dq_dqb.dqb_itime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 !ignore_hardlimit(dquot)) {
Jan Kara8e893462007-10-16 23:29:31 -07001235 *warntype = QUOTA_NL_ISOFTLONGWARN;
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001236 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237 }
1238
1239 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001240 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 dquot->dq_dqb.dqb_itime == 0) {
Jan Kara8e893462007-10-16 23:29:31 -07001242 *warntype = QUOTA_NL_ISOFTWARN;
Jan Kara268157b2009-01-27 15:47:22 +01001243 dquot->dq_dqb.dqb_itime = get_seconds() +
1244 sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 }
1246
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001247 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001248}
1249
1250/* needs dq_data_lock */
1251static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype)
1252{
Mingming Caof18df222009-01-13 16:43:09 +01001253 qsize_t tspace;
Jan Kara268157b2009-01-27 15:47:22 +01001254 struct super_block *sb = dquot->dq_sb;
Mingming Caof18df222009-01-13 16:43:09 +01001255
Jan Kara8e893462007-10-16 23:29:31 -07001256 *warntype = QUOTA_NL_NOWARN;
Jan Kara268157b2009-01-27 15:47:22 +01001257 if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001258 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001259 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260
Mingming Caof18df222009-01-13 16:43:09 +01001261 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1262 + space;
1263
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 if (dquot->dq_dqb.dqb_bhardlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001265 tspace > dquot->dq_dqb.dqb_bhardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266 !ignore_hardlimit(dquot)) {
1267 if (!prealloc)
Jan Kara8e893462007-10-16 23:29:31 -07001268 *warntype = QUOTA_NL_BHARDWARN;
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001269 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 }
1271
1272 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001273 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001274 dquot->dq_dqb.dqb_btime &&
1275 get_seconds() >= dquot->dq_dqb.dqb_btime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 !ignore_hardlimit(dquot)) {
1277 if (!prealloc)
Jan Kara8e893462007-10-16 23:29:31 -07001278 *warntype = QUOTA_NL_BSOFTLONGWARN;
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001279 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
1281
1282 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001283 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 dquot->dq_dqb.dqb_btime == 0) {
1285 if (!prealloc) {
Jan Kara8e893462007-10-16 23:29:31 -07001286 *warntype = QUOTA_NL_BSOFTWARN;
Jan Kara268157b2009-01-27 15:47:22 +01001287 dquot->dq_dqb.dqb_btime = get_seconds() +
1288 sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 }
1290 else
1291 /*
1292 * We don't allow preallocation to exceed softlimit so exceeding will
1293 * be always printed
1294 */
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001295 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296 }
1297
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001298 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299}
1300
Jan Kara12095462008-08-20 14:45:12 +02001301static int info_idq_free(struct dquot *dquot, qsize_t inodes)
Jan Kara657d3bf2008-07-25 01:46:52 -07001302{
Jan Kara268157b2009-01-27 15:47:22 +01001303 qsize_t newinodes;
1304
Jan Kara657d3bf2008-07-25 01:46:52 -07001305 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001306 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
1307 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type))
Jan Kara657d3bf2008-07-25 01:46:52 -07001308 return QUOTA_NL_NOWARN;
1309
Jan Kara268157b2009-01-27 15:47:22 +01001310 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1311 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001312 return QUOTA_NL_ISOFTBELOW;
1313 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001314 newinodes < dquot->dq_dqb.dqb_ihardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001315 return QUOTA_NL_IHARDBELOW;
1316 return QUOTA_NL_NOWARN;
1317}
1318
1319static int info_bdq_free(struct dquot *dquot, qsize_t space)
1320{
1321 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Kara12095462008-08-20 14:45:12 +02001322 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001323 return QUOTA_NL_NOWARN;
1324
Jan Kara12095462008-08-20 14:45:12 +02001325 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001326 return QUOTA_NL_BSOFTBELOW;
Jan Kara12095462008-08-20 14:45:12 +02001327 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
1328 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001329 return QUOTA_NL_BHARDBELOW;
1330 return QUOTA_NL_NOWARN;
1331}
Jan Kara0a5a9c72010-02-09 18:20:39 +01001332
Christoph Hellwig189eef52010-06-04 10:56:29 +02001333static int dquot_active(const struct inode *inode)
1334{
1335 struct super_block *sb = inode->i_sb;
1336
1337 if (IS_NOQUOTA(inode))
1338 return 0;
1339 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1340}
1341
Linus Torvalds1da177e2005-04-16 15:20:36 -07001342/*
Christoph Hellwig871a2932010-03-03 09:05:07 -05001343 * Initialize quota pointers in inode
1344 *
1345 * We do things in a bit complicated way but by that we avoid calling
1346 * dqget() and thus filesystem callbacks under dqptr_sem.
1347 *
1348 * It is better to call this function outside of any transaction as it
1349 * might need a lot of space in journal for dquot structure allocation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001350 */
Christoph Hellwig871a2932010-03-03 09:05:07 -05001351static void __dquot_initialize(struct inode *inode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001352{
1353 unsigned int id = 0;
Christoph Hellwig871a2932010-03-03 09:05:07 -05001354 int cnt;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001355 struct dquot *got[MAXQUOTAS];
Jan Karacc334122009-01-12 17:23:05 +01001356 struct super_block *sb = inode->i_sb;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001357 qsize_t rsv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358
Ingo Molnard3be9152006-03-23 03:00:29 -08001359 /* First test before acquiring mutex - solves deadlocks when we
1360 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001361 if (!dquot_active(inode))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001362 return;
Jan Karacc334122009-01-12 17:23:05 +01001363
1364 /* First get references to structures we might need. */
1365 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001366 got[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001367 if (type != -1 && cnt != type)
1368 continue;
1369 switch (cnt) {
1370 case USRQUOTA:
1371 id = inode->i_uid;
1372 break;
1373 case GRPQUOTA:
1374 id = inode->i_gid;
1375 break;
1376 }
1377 got[cnt] = dqget(sb, id, cnt);
1378 }
1379
1380 down_write(&sb_dqopt(sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381 if (IS_NOQUOTA(inode))
1382 goto out_err;
1383 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1384 if (type != -1 && cnt != type)
1385 continue;
Jan Karacc334122009-01-12 17:23:05 +01001386 /* Avoid races with quotaoff() */
1387 if (!sb_has_quota_active(sb, cnt))
1388 continue;
Jan Karadd6f3c62009-01-26 16:01:43 +01001389 if (!inode->i_dquot[cnt]) {
Jan Karacc334122009-01-12 17:23:05 +01001390 inode->i_dquot[cnt] = got[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001391 got[cnt] = NULL;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001392 /*
1393 * Make quota reservation system happy if someone
1394 * did a write before quota was turned on
1395 */
1396 rsv = inode_get_rsv_space(inode);
1397 if (unlikely(rsv))
1398 dquot_resv_space(inode->i_dquot[cnt], rsv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 }
1400 }
1401out_err:
Jan Karacc334122009-01-12 17:23:05 +01001402 up_write(&sb_dqopt(sb)->dqptr_sem);
1403 /* Drop unused references */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001404 dqput_all(got);
Christoph Hellwig871a2932010-03-03 09:05:07 -05001405}
1406
1407void dquot_initialize(struct inode *inode)
1408{
1409 __dquot_initialize(inode, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410}
Mingming Cao08d03502009-01-14 16:19:32 +01001411EXPORT_SYMBOL(dquot_initialize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001412
1413/*
1414 * Release all quotas referenced by inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001415 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05001416static void __dquot_drop(struct inode *inode)
Jan Kara3d9ea252008-10-10 16:12:23 +02001417{
Jan Karacc334122009-01-12 17:23:05 +01001418 int cnt;
1419 struct dquot *put[MAXQUOTAS];
1420
Jan Kara3d9ea252008-10-10 16:12:23 +02001421 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001422 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1423 put[cnt] = inode->i_dquot[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001424 inode->i_dquot[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001425 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001427 dqput_all(put);
Christoph Hellwig9f754752010-03-03 09:05:05 -05001428}
1429
1430void dquot_drop(struct inode *inode)
1431{
1432 int cnt;
1433
1434 if (IS_NOQUOTA(inode))
1435 return;
1436
1437 /*
1438 * Test before calling to rule out calls from proc and such
1439 * where we are not allowed to block. Note that this is
1440 * actually reliable test even without the lock - the caller
1441 * must assure that nobody can come after the DQUOT_DROP and
1442 * add quota pointers back anyway.
1443 */
1444 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1445 if (inode->i_dquot[cnt])
1446 break;
1447 }
1448
1449 if (cnt < MAXQUOTAS)
1450 __dquot_drop(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001451}
Mingming Cao08d03502009-01-14 16:19:32 +01001452EXPORT_SYMBOL(dquot_drop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453
1454/*
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001455 * inode_reserved_space is managed internally by quota, and protected by
1456 * i_lock similar to i_blocks+i_bytes.
1457 */
1458static qsize_t *inode_reserved_space(struct inode * inode)
1459{
1460 /* Filesystem must explicitly define it's own method in order to use
1461 * quota reservation interface */
1462 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1463 return inode->i_sb->dq_op->get_reserved_space(inode);
1464}
1465
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001466void inode_add_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001467{
1468 spin_lock(&inode->i_lock);
1469 *inode_reserved_space(inode) += number;
1470 spin_unlock(&inode->i_lock);
1471}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001472EXPORT_SYMBOL(inode_add_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001473
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001474void inode_claim_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001475{
1476 spin_lock(&inode->i_lock);
1477 *inode_reserved_space(inode) -= number;
1478 __inode_add_bytes(inode, number);
1479 spin_unlock(&inode->i_lock);
1480}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001481EXPORT_SYMBOL(inode_claim_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001482
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001483void inode_sub_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001484{
1485 spin_lock(&inode->i_lock);
1486 *inode_reserved_space(inode) -= number;
1487 spin_unlock(&inode->i_lock);
1488}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001489EXPORT_SYMBOL(inode_sub_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001490
1491static qsize_t inode_get_rsv_space(struct inode *inode)
1492{
1493 qsize_t ret;
Jan Kara05b5d892010-01-06 18:03:36 +01001494
1495 if (!inode->i_sb->dq_op->get_reserved_space)
1496 return 0;
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001497 spin_lock(&inode->i_lock);
1498 ret = *inode_reserved_space(inode);
1499 spin_unlock(&inode->i_lock);
1500 return ret;
1501}
1502
1503static void inode_incr_space(struct inode *inode, qsize_t number,
1504 int reserve)
1505{
1506 if (reserve)
1507 inode_add_rsv_space(inode, number);
1508 else
1509 inode_add_bytes(inode, number);
1510}
1511
1512static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1513{
1514 if (reserve)
1515 inode_sub_rsv_space(inode, number);
1516 else
1517 inode_sub_bytes(inode, number);
1518}
1519
1520/*
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001521 * This functions updates i_blocks+i_bytes fields and quota information
1522 * (together with appropriate checks).
1523 *
1524 * NOTE: We absolutely rely on the fact that caller dirties the inode
1525 * (usually helpers in quotaops.h care about this) and holds a handle for
1526 * the current transaction so that dquot write and inode write go into the
1527 * same transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528 */
1529
1530/*
1531 * This operation can block, but only after everything is updated
1532 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001533int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534{
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001535 int cnt, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001536 char warntype[MAXQUOTAS];
Eric Sandeen56246f92010-05-16 09:00:00 -04001537 int warn = flags & DQUOT_SPACE_WARN;
1538 int reserve = flags & DQUOT_SPACE_RESERVE;
Eric Sandeen0e058422010-05-16 10:00:00 -04001539 int nofail = flags & DQUOT_SPACE_NOFAIL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001541 /*
1542 * First test before acquiring mutex - solves deadlocks when we
1543 * re-enter the quota code and are already holding the mutex
1544 */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001545 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001546 inode_incr_space(inode, number, reserve);
1547 goto out;
1548 }
1549
1550 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Kara8e893462007-10-16 23:29:31 -07001552 warntype[cnt] = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 spin_lock(&dq_data_lock);
1555 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001556 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557 continue;
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001558 ret = check_bdq(inode->i_dquot[cnt], number, !warn,
1559 warntype+cnt);
Eric Sandeen0e058422010-05-16 10:00:00 -04001560 if (ret && !nofail) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001561 spin_unlock(&dq_data_lock);
1562 goto out_flush_warn;
Mingming Caof18df222009-01-13 16:43:09 +01001563 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001564 }
1565 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001566 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567 continue;
Mingming Caof18df222009-01-13 16:43:09 +01001568 if (reserve)
1569 dquot_resv_space(inode->i_dquot[cnt], number);
1570 else
1571 dquot_incr_space(inode->i_dquot[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001573 inode_incr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001575
1576 if (reserve)
1577 goto out_flush_warn;
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001578 mark_all_dquot_dirty(inode->i_dquot);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001579out_flush_warn:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 flush_warnings(inode->i_dquot, warntype);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001581 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1582out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001583 return ret;
1584}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001585EXPORT_SYMBOL(__dquot_alloc_space);
Mingming Caof18df222009-01-13 16:43:09 +01001586
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587/*
1588 * This operation can block, but only after everything is updated
1589 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001590int dquot_alloc_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591{
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001592 int cnt, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001593 char warntype[MAXQUOTAS];
1594
Ingo Molnard3be9152006-03-23 03:00:29 -08001595 /* First test before acquiring mutex - solves deadlocks when we
1596 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001597 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001598 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Kara8e893462007-10-16 23:29:31 -07001600 warntype[cnt] = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602 spin_lock(&dq_data_lock);
1603 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001604 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 continue;
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001606 ret = check_idq(inode->i_dquot[cnt], 1, warntype + cnt);
1607 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 goto warn_put_all;
1609 }
1610
1611 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001612 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 continue;
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001614 dquot_incr_inodes(inode->i_dquot[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615 }
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001616
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617warn_put_all:
1618 spin_unlock(&dq_data_lock);
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001619 if (ret == 0)
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001620 mark_all_dquot_dirty(inode->i_dquot);
Jan Kara087ee8d2007-12-17 16:20:26 -08001621 flush_warnings(inode->i_dquot, warntype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1623 return ret;
1624}
Mingming Cao08d03502009-01-14 16:19:32 +01001625EXPORT_SYMBOL(dquot_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001626
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001627/*
1628 * Convert in-memory reserved quotas to real consumed quotas
1629 */
1630int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001631{
1632 int cnt;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001633
Christoph Hellwig189eef52010-06-04 10:56:29 +02001634 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001635 inode_claim_rsv_space(inode, number);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001636 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001637 }
1638
1639 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001640 spin_lock(&dq_data_lock);
1641 /* Claim reserved quotas to allocated quotas */
1642 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001643 if (inode->i_dquot[cnt])
Mingming Cao740d9dc2009-01-13 16:43:14 +01001644 dquot_claim_reserved_space(inode->i_dquot[cnt],
1645 number);
1646 }
1647 /* Update inode bytes */
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001648 inode_claim_rsv_space(inode, number);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001649 spin_unlock(&dq_data_lock);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001650 mark_all_dquot_dirty(inode->i_dquot);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001651 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001652 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001653}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001654EXPORT_SYMBOL(dquot_claim_space_nodirty);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001655
1656/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657 * This operation can block, but only after everything is updated
1658 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001659void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660{
1661 unsigned int cnt;
Jan Kara657d3bf2008-07-25 01:46:52 -07001662 char warntype[MAXQUOTAS];
Eric Sandeen56246f92010-05-16 09:00:00 -04001663 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664
Ingo Molnard3be9152006-03-23 03:00:29 -08001665 /* First test before acquiring mutex - solves deadlocks when we
1666 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001667 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001668 inode_decr_space(inode, number, reserve);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001669 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 }
Jan Kara657d3bf2008-07-25 01:46:52 -07001671
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 spin_lock(&dq_data_lock);
1674 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001675 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001676 continue;
Jan Kara657d3bf2008-07-25 01:46:52 -07001677 warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001678 if (reserve)
1679 dquot_free_reserved_space(inode->i_dquot[cnt], number);
1680 else
1681 dquot_decr_space(inode->i_dquot[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001683 inode_decr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001685
1686 if (reserve)
1687 goto out_unlock;
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001688 mark_all_dquot_dirty(inode->i_dquot);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001689out_unlock:
Jan Kara657d3bf2008-07-25 01:46:52 -07001690 flush_warnings(inode->i_dquot, warntype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001693EXPORT_SYMBOL(__dquot_free_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001694
1695/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001696 * This operation can block, but only after everything is updated
1697 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001698void dquot_free_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001699{
1700 unsigned int cnt;
Jan Kara657d3bf2008-07-25 01:46:52 -07001701 char warntype[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001702
Ingo Molnard3be9152006-03-23 03:00:29 -08001703 /* First test before acquiring mutex - solves deadlocks when we
1704 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001705 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001706 return;
Jan Kara657d3bf2008-07-25 01:46:52 -07001707
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709 spin_lock(&dq_data_lock);
1710 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001711 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 continue;
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001713 warntype[cnt] = info_idq_free(inode->i_dquot[cnt], 1);
1714 dquot_decr_inodes(inode->i_dquot[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 }
1716 spin_unlock(&dq_data_lock);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001717 mark_all_dquot_dirty(inode->i_dquot);
Jan Kara657d3bf2008-07-25 01:46:52 -07001718 flush_warnings(inode->i_dquot, warntype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001719 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720}
Mingming Cao08d03502009-01-14 16:19:32 +01001721EXPORT_SYMBOL(dquot_free_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001722
1723/*
1724 * Transfer the number of inode and blocks from one diskquota to an other.
Jan Karabc8e5f02010-05-13 19:58:50 +02001725 * On success, dquot references in transfer_to are consumed and references
1726 * to original dquots that need to be released are placed there. On failure,
1727 * references are kept untouched.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 *
1729 * This operation can block, but only after everything is updated
1730 * A transaction must be started when entering this function.
Jan Karabc8e5f02010-05-13 19:58:50 +02001731 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 */
Jan Karabc8e5f02010-05-13 19:58:50 +02001733int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734{
Mingming Cao740d9dc2009-01-13 16:43:14 +01001735 qsize_t space, cur_space;
1736 qsize_t rsv_space = 0;
Jan Karabc8e5f02010-05-13 19:58:50 +02001737 struct dquot *transfer_from[MAXQUOTAS] = {};
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001738 int cnt, ret = 0;
Jan Kara657d3bf2008-07-25 01:46:52 -07001739 char warntype_to[MAXQUOTAS];
1740 char warntype_from_inodes[MAXQUOTAS], warntype_from_space[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741
Ingo Molnard3be9152006-03-23 03:00:29 -08001742 /* First test before acquiring mutex - solves deadlocks when we
1743 * re-enter the quota code and are already holding the mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744 if (IS_NOQUOTA(inode))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001745 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001746 /* Initialize the arrays */
Jan Karabc8e5f02010-05-13 19:58:50 +02001747 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Kara657d3bf2008-07-25 01:46:52 -07001748 warntype_to[cnt] = QUOTA_NL_NOWARN;
Jan Karacc334122009-01-12 17:23:05 +01001749 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001750 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
1751 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabc8e5f02010-05-13 19:58:50 +02001752 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001753 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 spin_lock(&dq_data_lock);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001755 cur_space = inode_get_bytes(inode);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001756 rsv_space = inode_get_rsv_space(inode);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001757 space = cur_space + rsv_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 /* Build the transfer_from list and check the limits */
1759 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001760 if (!transfer_to[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761 continue;
1762 transfer_from[cnt] = inode->i_dquot[cnt];
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001763 ret = check_idq(transfer_to[cnt], 1, warntype_to + cnt);
1764 if (ret)
1765 goto over_quota;
1766 ret = check_bdq(transfer_to[cnt], space, 0, warntype_to + cnt);
1767 if (ret)
Jan Karacc334122009-01-12 17:23:05 +01001768 goto over_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 }
1770
1771 /*
1772 * Finally perform the needed transfer from transfer_from to transfer_to
1773 */
1774 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1775 /*
1776 * Skip changes for same uid or gid or for turned off quota-type.
1777 */
Jan Karadd6f3c62009-01-26 16:01:43 +01001778 if (!transfer_to[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 continue;
1780
1781 /* Due to IO error we might not have transfer_from[] structure */
1782 if (transfer_from[cnt]) {
Jan Kara657d3bf2008-07-25 01:46:52 -07001783 warntype_from_inodes[cnt] =
1784 info_idq_free(transfer_from[cnt], 1);
1785 warntype_from_space[cnt] =
1786 info_bdq_free(transfer_from[cnt], space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 dquot_decr_inodes(transfer_from[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001788 dquot_decr_space(transfer_from[cnt], cur_space);
1789 dquot_free_reserved_space(transfer_from[cnt],
1790 rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 }
1792
1793 dquot_incr_inodes(transfer_to[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001794 dquot_incr_space(transfer_to[cnt], cur_space);
1795 dquot_resv_space(transfer_to[cnt], rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796
1797 inode->i_dquot[cnt] = transfer_to[cnt];
1798 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 spin_unlock(&dq_data_lock);
Jan Karacc334122009-01-12 17:23:05 +01001800 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1801
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001802 mark_all_dquot_dirty(transfer_from);
1803 mark_all_dquot_dirty(transfer_to);
Jan Karabc8e5f02010-05-13 19:58:50 +02001804 /* Pass back references to put */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001805 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabc8e5f02010-05-13 19:58:50 +02001806 transfer_to[cnt] = transfer_from[cnt];
1807warn:
Jan Kara657d3bf2008-07-25 01:46:52 -07001808 flush_warnings(transfer_to, warntype_to);
1809 flush_warnings(transfer_from, warntype_from_inodes);
1810 flush_warnings(transfer_from, warntype_from_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 return ret;
Jan Karacc334122009-01-12 17:23:05 +01001812over_quota:
1813 spin_unlock(&dq_data_lock);
1814 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabc8e5f02010-05-13 19:58:50 +02001815 goto warn;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816}
Jan Karabc8e5f02010-05-13 19:58:50 +02001817EXPORT_SYMBOL(__dquot_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001819/* Wrapper for transferring ownership of an inode for uid/gid only
1820 * Called from FSXXX_setattr()
1821 */
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001822int dquot_transfer(struct inode *inode, struct iattr *iattr)
Jan Karab85f4b82008-07-25 01:46:50 -07001823{
Jan Karabc8e5f02010-05-13 19:58:50 +02001824 struct dquot *transfer_to[MAXQUOTAS] = {};
1825 struct super_block *sb = inode->i_sb;
1826 int ret;
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001827
Christoph Hellwig189eef52010-06-04 10:56:29 +02001828 if (!dquot_active(inode))
Jan Karabc8e5f02010-05-13 19:58:50 +02001829 return 0;
Dmitry Monakhov12755622010-04-08 22:04:20 +04001830
Jan Karabc8e5f02010-05-13 19:58:50 +02001831 if (iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid)
1832 transfer_to[USRQUOTA] = dqget(sb, iattr->ia_uid, USRQUOTA);
1833 if (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)
Jan Kara4dea4962010-05-24 12:39:49 +02001834 transfer_to[GRPQUOTA] = dqget(sb, iattr->ia_gid, GRPQUOTA);
Jan Karabc8e5f02010-05-13 19:58:50 +02001835
1836 ret = __dquot_transfer(inode, transfer_to);
1837 dqput_all(transfer_to);
1838 return ret;
Jan Karab85f4b82008-07-25 01:46:50 -07001839}
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001840EXPORT_SYMBOL(dquot_transfer);
Jan Karab85f4b82008-07-25 01:46:50 -07001841
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842/*
1843 * Write info of quota file to disk
1844 */
1845int dquot_commit_info(struct super_block *sb, int type)
1846{
1847 int ret;
1848 struct quota_info *dqopt = sb_dqopt(sb);
1849
Ingo Molnard3be9152006-03-23 03:00:29 -08001850 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851 ret = dqopt->ops[type]->write_file_info(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08001852 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 return ret;
1854}
Mingming Cao08d03502009-01-14 16:19:32 +01001855EXPORT_SYMBOL(dquot_commit_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856
1857/*
1858 * Definitions of diskquota operations.
1859 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -07001860const struct dquot_operations dquot_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 .write_dquot = dquot_commit,
1862 .acquire_dquot = dquot_acquire,
1863 .release_dquot = dquot_release,
1864 .mark_dirty = dquot_mark_dquot_dirty,
Jan Kara74f783a2008-08-19 14:51:22 +02001865 .write_info = dquot_commit_info,
1866 .alloc_dquot = dquot_alloc,
1867 .destroy_dquot = dquot_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868};
Christoph Hellwig123e9ca2010-05-19 07:16:44 -04001869EXPORT_SYMBOL(dquot_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001870
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871/*
Christoph Hellwig907f4552010-03-03 09:05:06 -05001872 * Generic helper for ->open on filesystems supporting disk quotas.
1873 */
1874int dquot_file_open(struct inode *inode, struct file *file)
1875{
1876 int error;
1877
1878 error = generic_file_open(inode, file);
1879 if (!error && (file->f_mode & FMODE_WRITE))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001880 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -05001881 return error;
1882}
1883EXPORT_SYMBOL(dquot_file_open);
1884
1885/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
1887 */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04001888int dquot_disable(struct super_block *sb, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889{
Jan Kara0ff5af82008-04-28 02:14:33 -07001890 int cnt, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 struct quota_info *dqopt = sb_dqopt(sb);
1892 struct inode *toputinode[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
Jan Karaf55abc02008-08-20 17:50:32 +02001894 /* Cannot turn off usage accounting without turning off limits, or
1895 * suspend quotas and simultaneously turn quotas off. */
1896 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
1897 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
1898 DQUOT_USAGE_ENABLED)))
1899 return -EINVAL;
1900
Linus Torvalds1da177e2005-04-16 15:20:36 -07001901 /* We need to serialize quota_off() for device */
Ingo Molnard3be9152006-03-23 03:00:29 -08001902 mutex_lock(&dqopt->dqonoff_mutex);
Jan Kara9377abd2008-05-12 14:02:08 -07001903
1904 /*
1905 * Skip everything if there's nothing to do. We have to do this because
1906 * sometimes we are called when fill_super() failed and calling
1907 * sync_fs() in such cases does no good.
1908 */
Jan Karaf55abc02008-08-20 17:50:32 +02001909 if (!sb_any_quota_loaded(sb)) {
Jan Kara9377abd2008-05-12 14:02:08 -07001910 mutex_unlock(&dqopt->dqonoff_mutex);
1911 return 0;
1912 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1914 toputinode[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915 if (type != -1 && cnt != type)
1916 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02001917 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07001918 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02001919
1920 if (flags & DQUOT_SUSPENDED) {
Jan Karacc334122009-01-12 17:23:05 +01001921 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02001922 dqopt->flags |=
1923 dquot_state_flag(DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01001924 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02001925 } else {
Jan Karacc334122009-01-12 17:23:05 +01001926 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02001927 dqopt->flags &= ~dquot_state_flag(flags, cnt);
1928 /* Turning off suspended quotas? */
1929 if (!sb_has_quota_loaded(sb, cnt) &&
1930 sb_has_quota_suspended(sb, cnt)) {
1931 dqopt->flags &= ~dquot_state_flag(
1932 DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01001933 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02001934 iput(dqopt->files[cnt]);
1935 dqopt->files[cnt] = NULL;
1936 continue;
1937 }
Jan Karacc334122009-01-12 17:23:05 +01001938 spin_unlock(&dq_state_lock);
Jan Kara0ff5af82008-04-28 02:14:33 -07001939 }
Jan Karaf55abc02008-08-20 17:50:32 +02001940
1941 /* We still have to keep quota loaded? */
1942 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001944
1945 /* Note: these are blocking operations */
1946 drop_dquot_ref(sb, cnt);
1947 invalidate_dquots(sb, cnt);
1948 /*
Jan Kara268157b2009-01-27 15:47:22 +01001949 * Now all dquots should be invalidated, all writes done so we
1950 * should be only users of the info. No locks needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951 */
1952 if (info_dirty(&dqopt->info[cnt]))
1953 sb->dq_op->write_info(sb, cnt);
1954 if (dqopt->ops[cnt]->free_file_info)
1955 dqopt->ops[cnt]->free_file_info(sb, cnt);
1956 put_quota_format(dqopt->info[cnt].dqi_format);
1957
1958 toputinode[cnt] = dqopt->files[cnt];
Jan Karaf55abc02008-08-20 17:50:32 +02001959 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07001960 dqopt->files[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001961 dqopt->info[cnt].dqi_flags = 0;
1962 dqopt->info[cnt].dqi_igrace = 0;
1963 dqopt->info[cnt].dqi_bgrace = 0;
1964 dqopt->ops[cnt] = NULL;
1965 }
Ingo Molnard3be9152006-03-23 03:00:29 -08001966 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02001967
1968 /* Skip syncing and setting flags if quota files are hidden */
1969 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
1970 goto put_inodes;
1971
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972 /* Sync the superblock so that buffers with quota data are written to
Al Viro7b7b1ac2005-11-07 17:13:39 -05001973 * disk (and so userspace sees correct data afterwards). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001974 if (sb->s_op->sync_fs)
1975 sb->s_op->sync_fs(sb, 1);
1976 sync_blockdev(sb->s_bdev);
1977 /* Now the quota files are just ordinary files and we can set the
1978 * inode flags back. Moreover we discard the pagecache so that
1979 * userspace sees the writes we did bypassing the pagecache. We
1980 * must also discard the blockdev buffers so that we see the
1981 * changes done by userspace on the next quotaon() */
1982 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1983 if (toputinode[cnt]) {
Ingo Molnard3be9152006-03-23 03:00:29 -08001984 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 /* If quota was reenabled in the meantime, we have
1986 * nothing to do */
Jan Karaf55abc02008-08-20 17:50:32 +02001987 if (!sb_has_quota_loaded(sb, cnt)) {
Jan Kara268157b2009-01-27 15:47:22 +01001988 mutex_lock_nested(&toputinode[cnt]->i_mutex,
1989 I_MUTEX_QUOTA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
1991 S_NOATIME | S_NOQUOTA);
Jan Kara268157b2009-01-27 15:47:22 +01001992 truncate_inode_pages(&toputinode[cnt]->i_data,
1993 0);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08001994 mutex_unlock(&toputinode[cnt]->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 mark_inode_dirty(toputinode[cnt]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 }
Ingo Molnard3be9152006-03-23 03:00:29 -08001997 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02001998 }
1999 if (sb->s_bdev)
2000 invalidate_bdev(sb->s_bdev);
2001put_inodes:
2002 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2003 if (toputinode[cnt]) {
Jan Kara0ff5af82008-04-28 02:14:33 -07002004 /* On remount RO, we keep the inode pointer so that we
Jan Karaf55abc02008-08-20 17:50:32 +02002005 * can reenable quota on the subsequent remount RW. We
2006 * have to check 'flags' variable and not use sb_has_
2007 * function because another quotaon / quotaoff could
2008 * change global state before we got here. We refuse
2009 * to suspend quotas when there is pending delete on
2010 * the quota file... */
2011 if (!(flags & DQUOT_SUSPENDED))
Jan Kara0ff5af82008-04-28 02:14:33 -07002012 iput(toputinode[cnt]);
2013 else if (!toputinode[cnt]->i_nlink)
2014 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002016 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002018EXPORT_SYMBOL(dquot_disable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002019
Christoph Hellwig287a8092010-05-19 07:16:45 -04002020int dquot_quota_off(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +02002021{
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002022 return dquot_disable(sb, type,
2023 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Jan Karaf55abc02008-08-20 17:50:32 +02002024}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002025EXPORT_SYMBOL(dquot_quota_off);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002026
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027/*
2028 * Turn quotas on on a device
2029 */
2030
Jan Karaf55abc02008-08-20 17:50:32 +02002031/*
2032 * Helper function to turn quotas on when we already have the inode of
2033 * quota file and no quota information is loaded.
2034 */
2035static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2036 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037{
2038 struct quota_format_type *fmt = find_quota_format(format_id);
2039 struct super_block *sb = inode->i_sb;
2040 struct quota_info *dqopt = sb_dqopt(sb);
2041 int error;
2042 int oldflags = -1;
2043
2044 if (!fmt)
2045 return -ESRCH;
2046 if (!S_ISREG(inode->i_mode)) {
2047 error = -EACCES;
2048 goto out_fmt;
2049 }
2050 if (IS_RDONLY(inode)) {
2051 error = -EROFS;
2052 goto out_fmt;
2053 }
2054 if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
2055 error = -EINVAL;
2056 goto out_fmt;
2057 }
Jan Karaf55abc02008-08-20 17:50:32 +02002058 /* Usage always has to be set... */
2059 if (!(flags & DQUOT_USAGE_ENABLED)) {
2060 error = -EINVAL;
2061 goto out_fmt;
2062 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063
Jan Karaca785ec2008-09-30 17:53:37 +02002064 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
Jan Karaab94c392010-02-22 21:07:17 +01002065 /* As we bypass the pagecache we must now flush all the
2066 * dirty data and invalidate caches so that kernel sees
2067 * changes from userspace. It is not enough to just flush
2068 * the quota file since if blocksize < pagesize, invalidation
2069 * of the cache could fail because of other unrelated dirty
2070 * data */
2071 sync_filesystem(sb);
Jan Karaca785ec2008-09-30 17:53:37 +02002072 invalidate_bdev(sb->s_bdev);
2073 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002074 mutex_lock(&dqopt->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002075 if (sb_has_quota_loaded(sb, type)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002076 error = -EBUSY;
2077 goto out_lock;
2078 }
Jan Karaca785ec2008-09-30 17:53:37 +02002079
2080 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2081 /* We don't want quota and atime on quota files (deadlocks
2082 * possible) Also nobody should write to the file - we use
2083 * special IO operations which ignore the immutable bit. */
Jan Karadee86562009-07-22 18:12:17 +02002084 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
Jan Kara268157b2009-01-27 15:47:22 +01002085 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2086 S_NOQUOTA);
Jan Karaca785ec2008-09-30 17:53:37 +02002087 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
Jan Karadee86562009-07-22 18:12:17 +02002088 mutex_unlock(&inode->i_mutex);
Jan Kara26245c92010-01-06 17:20:35 +01002089 /*
2090 * When S_NOQUOTA is set, remove dquot references as no more
2091 * references can be added
2092 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05002093 __dquot_drop(inode);
Jan Karaca785ec2008-09-30 17:53:37 +02002094 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095
2096 error = -EIO;
2097 dqopt->files[type] = igrab(inode);
2098 if (!dqopt->files[type])
2099 goto out_lock;
2100 error = -EINVAL;
2101 if (!fmt->qf_ops->check_quota_file(sb, type))
2102 goto out_file_init;
2103
2104 dqopt->ops[type] = fmt->qf_ops;
2105 dqopt->info[type].dqi_format = fmt;
Jan Kara0ff5af82008-04-28 02:14:33 -07002106 dqopt->info[type].dqi_fmt_id = format_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
Ingo Molnard3be9152006-03-23 03:00:29 -08002108 mutex_lock(&dqopt->dqio_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002109 error = dqopt->ops[type]->read_file_info(sb, type);
2110 if (error < 0) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002111 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 goto out_file_init;
2113 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002114 mutex_unlock(&dqopt->dqio_mutex);
Jan Karacc334122009-01-12 17:23:05 +01002115 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002116 dqopt->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002117 spin_unlock(&dq_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002118
2119 add_dquot_ref(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08002120 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121
2122 return 0;
2123
2124out_file_init:
2125 dqopt->files[type] = NULL;
2126 iput(inode);
2127out_lock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 if (oldflags != -1) {
Jan Karadee86562009-07-22 18:12:17 +02002129 mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 /* Set the flags back (in the case of accidental quotaon()
2131 * on a wrong file we don't want to mess up the flags) */
2132 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2133 inode->i_flags |= oldflags;
Jan Karadee86562009-07-22 18:12:17 +02002134 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002135 }
Jiaying Zhangd01730d2009-07-07 18:15:21 +02002136 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137out_fmt:
2138 put_quota_format(fmt);
2139
2140 return error;
2141}
2142
Jan Kara0ff5af82008-04-28 02:14:33 -07002143/* Reenable quotas on remount RW */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002144int dquot_resume(struct super_block *sb, int type)
Jan Kara0ff5af82008-04-28 02:14:33 -07002145{
2146 struct quota_info *dqopt = sb_dqopt(sb);
2147 struct inode *inode;
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002148 int ret = 0, cnt;
Jan Karaf55abc02008-08-20 17:50:32 +02002149 unsigned int flags;
Jan Kara0ff5af82008-04-28 02:14:33 -07002150
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002151 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2152 if (type != -1 && cnt != type)
2153 continue;
Jan Kara0ff5af82008-04-28 02:14:33 -07002154
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002155 mutex_lock(&dqopt->dqonoff_mutex);
2156 if (!sb_has_quota_suspended(sb, cnt)) {
2157 mutex_unlock(&dqopt->dqonoff_mutex);
2158 continue;
2159 }
2160 inode = dqopt->files[cnt];
2161 dqopt->files[cnt] = NULL;
2162 spin_lock(&dq_state_lock);
2163 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2164 DQUOT_LIMITS_ENABLED,
2165 cnt);
2166 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2167 spin_unlock(&dq_state_lock);
2168 mutex_unlock(&dqopt->dqonoff_mutex);
2169
2170 flags = dquot_generic_flag(flags, cnt);
2171 ret = vfs_load_quota_inode(inode, cnt,
2172 dqopt->info[cnt].dqi_fmt_id, flags);
2173 iput(inode);
2174 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002175
2176 return ret;
2177}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002178EXPORT_SYMBOL(dquot_resume);
Jan Kara0ff5af82008-04-28 02:14:33 -07002179
Christoph Hellwig287a8092010-05-19 07:16:45 -04002180int dquot_quota_on_path(struct super_block *sb, int type, int format_id,
Al Viro77e69da2008-08-01 04:29:18 -04002181 struct path *path)
2182{
2183 int error = security_quota_on(path->dentry);
2184 if (error)
2185 return error;
2186 /* Quota file not on the same filesystem? */
2187 if (path->mnt->mnt_sb != sb)
2188 error = -EXDEV;
2189 else
Jan Karaf55abc02008-08-20 17:50:32 +02002190 error = vfs_load_quota_inode(path->dentry->d_inode, type,
2191 format_id, DQUOT_USAGE_ENABLED |
2192 DQUOT_LIMITS_ENABLED);
Al Viro77e69da2008-08-01 04:29:18 -04002193 return error;
2194}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002195EXPORT_SYMBOL(dquot_quota_on_path);
Al Viro77e69da2008-08-01 04:29:18 -04002196
Christoph Hellwig287a8092010-05-19 07:16:45 -04002197int dquot_quota_on(struct super_block *sb, int type, int format_id, char *name)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198{
Al Viro82646132008-08-02 00:57:06 -04002199 struct path path;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 int error;
2201
Al Viro82646132008-08-02 00:57:06 -04002202 error = kern_path(name, LOOKUP_FOLLOW, &path);
Al Viro77e69da2008-08-01 04:29:18 -04002203 if (!error) {
Christoph Hellwig287a8092010-05-19 07:16:45 -04002204 error = dquot_quota_on_path(sb, type, format_id, &path);
Al Viro82646132008-08-02 00:57:06 -04002205 path_put(&path);
Al Viro77e69da2008-08-01 04:29:18 -04002206 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207 return error;
2208}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002209EXPORT_SYMBOL(dquot_quota_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210
2211/*
Jan Karaf55abc02008-08-20 17:50:32 +02002212 * More powerful function for turning on quotas allowing setting
2213 * of individual quota flags
2214 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002215int dquot_enable(struct inode *inode, int type, int format_id,
2216 unsigned int flags)
Jan Karaf55abc02008-08-20 17:50:32 +02002217{
2218 int ret = 0;
2219 struct super_block *sb = inode->i_sb;
2220 struct quota_info *dqopt = sb_dqopt(sb);
2221
2222 /* Just unsuspend quotas? */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002223 BUG_ON(flags & DQUOT_SUSPENDED);
2224
Jan Karaf55abc02008-08-20 17:50:32 +02002225 if (!flags)
2226 return 0;
2227 /* Just updating flags needed? */
2228 if (sb_has_quota_loaded(sb, type)) {
2229 mutex_lock(&dqopt->dqonoff_mutex);
2230 /* Now do a reliable test... */
2231 if (!sb_has_quota_loaded(sb, type)) {
2232 mutex_unlock(&dqopt->dqonoff_mutex);
2233 goto load_quota;
2234 }
2235 if (flags & DQUOT_USAGE_ENABLED &&
2236 sb_has_quota_usage_enabled(sb, type)) {
2237 ret = -EBUSY;
2238 goto out_lock;
2239 }
2240 if (flags & DQUOT_LIMITS_ENABLED &&
2241 sb_has_quota_limits_enabled(sb, type)) {
2242 ret = -EBUSY;
2243 goto out_lock;
2244 }
Jan Karacc334122009-01-12 17:23:05 +01002245 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002246 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002247 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002248out_lock:
2249 mutex_unlock(&dqopt->dqonoff_mutex);
2250 return ret;
2251 }
2252
2253load_quota:
2254 return vfs_load_quota_inode(inode, type, format_id, flags);
2255}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002256EXPORT_SYMBOL(dquot_enable);
Jan Karaf55abc02008-08-20 17:50:32 +02002257
2258/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002259 * This function is used when filesystem needs to initialize quotas
2260 * during mount time.
2261 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002262int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Christoph Hellwig84de8562005-06-23 00:09:16 -07002263 int format_id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264{
Christoph Hellwig84de8562005-06-23 00:09:16 -07002265 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 int error;
2267
Jan Karac56818d2009-11-12 15:42:08 +01002268 mutex_lock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig2fa389c2005-06-23 00:09:16 -07002269 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
Jan Karac56818d2009-11-12 15:42:08 +01002270 mutex_unlock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002271 if (IS_ERR(dentry))
2272 return PTR_ERR(dentry);
2273
Jan Kara154f4842005-11-28 13:44:14 -08002274 if (!dentry->d_inode) {
2275 error = -ENOENT;
2276 goto out;
2277 }
2278
Linus Torvalds1da177e2005-04-16 15:20:36 -07002279 error = security_quota_on(dentry);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002280 if (!error)
Jan Karaf55abc02008-08-20 17:50:32 +02002281 error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
2282 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002283
Jan Kara154f4842005-11-28 13:44:14 -08002284out:
Christoph Hellwig84de8562005-06-23 00:09:16 -07002285 dput(dentry);
2286 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002288EXPORT_SYMBOL(dquot_quota_on_mount);
Jan Karab85f4b82008-07-25 01:46:50 -07002289
Jan Kara12095462008-08-20 14:45:12 +02002290static inline qsize_t qbtos(qsize_t blocks)
2291{
2292 return blocks << QIF_DQBLKSIZE_BITS;
2293}
2294
2295static inline qsize_t stoqb(qsize_t space)
2296{
2297 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
2298}
2299
Linus Torvalds1da177e2005-04-16 15:20:36 -07002300/* Generic routine for getting common part of quota structure */
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002301static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002302{
2303 struct mem_dqblk *dm = &dquot->dq_dqb;
2304
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002305 memset(di, 0, sizeof(*di));
2306 di->d_version = FS_DQUOT_VERSION;
2307 di->d_flags = dquot->dq_type == USRQUOTA ?
Christoph Hellwigade7ce32010-06-04 10:56:01 +02002308 FS_USER_QUOTA : FS_GROUP_QUOTA;
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002309 di->d_id = dquot->dq_id;
2310
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 spin_lock(&dq_data_lock);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002312 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
2313 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
2314 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2315 di->d_ino_softlimit = dm->dqb_isoftlimit;
2316 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
2317 di->d_icount = dm->dqb_curinodes;
2318 di->d_btimer = dm->dqb_btime;
2319 di->d_itimer = dm->dqb_itime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320 spin_unlock(&dq_data_lock);
2321}
2322
Christoph Hellwig287a8092010-05-19 07:16:45 -04002323int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
2324 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002325{
2326 struct dquot *dquot;
2327
Jan Karacc334122009-01-12 17:23:05 +01002328 dquot = dqget(sb, id, type);
Jan Karadd6f3c62009-01-26 16:01:43 +01002329 if (!dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 return -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331 do_get_dqblk(dquot, di);
2332 dqput(dquot);
Jan Karacc334122009-01-12 17:23:05 +01002333
Linus Torvalds1da177e2005-04-16 15:20:36 -07002334 return 0;
2335}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002336EXPORT_SYMBOL(dquot_get_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
Christoph Hellwigc472b432010-05-06 17:05:17 -04002338#define VFS_FS_DQ_MASK \
2339 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
2340 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
2341 FS_DQ_BTIMER | FS_DQ_ITIMER)
2342
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343/* Generic routine for setting common part of quota structure */
Christoph Hellwigc472b432010-05-06 17:05:17 -04002344static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345{
2346 struct mem_dqblk *dm = &dquot->dq_dqb;
2347 int check_blim = 0, check_ilim = 0;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002348 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];
2349
Christoph Hellwigc472b432010-05-06 17:05:17 -04002350 if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
2351 return -EINVAL;
2352
2353 if (((di->d_fieldmask & FS_DQ_BSOFT) &&
2354 (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
2355 ((di->d_fieldmask & FS_DQ_BHARD) &&
2356 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
2357 ((di->d_fieldmask & FS_DQ_ISOFT) &&
2358 (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
2359 ((di->d_fieldmask & FS_DQ_IHARD) &&
2360 (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002361 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362
2363 spin_lock(&dq_data_lock);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002364 if (di->d_fieldmask & FS_DQ_BCOUNT) {
2365 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002366 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002367 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002369
2370 if (di->d_fieldmask & FS_DQ_BSOFT)
2371 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
2372 if (di->d_fieldmask & FS_DQ_BHARD)
2373 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
2374 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002376 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002378
2379 if (di->d_fieldmask & FS_DQ_ICOUNT) {
2380 dm->dqb_curinodes = di->d_icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002382 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002383 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002384
2385 if (di->d_fieldmask & FS_DQ_ISOFT)
2386 dm->dqb_isoftlimit = di->d_ino_softlimit;
2387 if (di->d_fieldmask & FS_DQ_IHARD)
2388 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2389 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002391 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002393
2394 if (di->d_fieldmask & FS_DQ_BTIMER) {
2395 dm->dqb_btime = di->d_btimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002396 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002397 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002398 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002399
2400 if (di->d_fieldmask & FS_DQ_ITIMER) {
2401 dm->dqb_itime = di->d_itimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002402 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002403 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002404 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002405
2406 if (check_blim) {
Jan Kara268157b2009-01-27 15:47:22 +01002407 if (!dm->dqb_bsoftlimit ||
2408 dm->dqb_curspace < dm->dqb_bsoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409 dm->dqb_btime = 0;
2410 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002411 } else if (!(di->d_fieldmask & FS_DQ_BTIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002412 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002413 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002414 }
2415 if (check_ilim) {
Jan Kara268157b2009-01-27 15:47:22 +01002416 if (!dm->dqb_isoftlimit ||
2417 dm->dqb_curinodes < dm->dqb_isoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418 dm->dqb_itime = 0;
2419 clear_bit(DQ_INODES_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002420 } else if (!(di->d_fieldmask & FS_DQ_ITIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002421 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002422 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002423 }
Jan Kara268157b2009-01-27 15:47:22 +01002424 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2425 dm->dqb_isoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002426 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2427 else
2428 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2429 spin_unlock(&dq_data_lock);
2430 mark_dquot_dirty(dquot);
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002431
2432 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433}
2434
Christoph Hellwig287a8092010-05-19 07:16:45 -04002435int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
Christoph Hellwigc472b432010-05-06 17:05:17 -04002436 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437{
2438 struct dquot *dquot;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002439 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440
Jan Karaf55abc02008-08-20 17:50:32 +02002441 dquot = dqget(sb, id, type);
2442 if (!dquot) {
2443 rc = -ESRCH;
2444 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445 }
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002446 rc = do_set_dqblk(dquot, di);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447 dqput(dquot);
Jan Karaf55abc02008-08-20 17:50:32 +02002448out:
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002449 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002451EXPORT_SYMBOL(dquot_set_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452
2453/* Generic routine for getting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002454int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002455{
2456 struct mem_dqinfo *mi;
2457
Ingo Molnard3be9152006-03-23 03:00:29 -08002458 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002459 if (!sb_has_quota_active(sb, type)) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002460 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461 return -ESRCH;
2462 }
2463 mi = sb_dqopt(sb)->info + type;
2464 spin_lock(&dq_data_lock);
2465 ii->dqi_bgrace = mi->dqi_bgrace;
2466 ii->dqi_igrace = mi->dqi_igrace;
2467 ii->dqi_flags = mi->dqi_flags & DQF_MASK;
2468 ii->dqi_valid = IIF_ALL;
2469 spin_unlock(&dq_data_lock);
Ingo Molnard3be9152006-03-23 03:00:29 -08002470 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 return 0;
2472}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002473EXPORT_SYMBOL(dquot_get_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474
2475/* Generic routine for setting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002476int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477{
2478 struct mem_dqinfo *mi;
Jan Karaf55abc02008-08-20 17:50:32 +02002479 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480
Ingo Molnard3be9152006-03-23 03:00:29 -08002481 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002482 if (!sb_has_quota_active(sb, type)) {
2483 err = -ESRCH;
2484 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002485 }
2486 mi = sb_dqopt(sb)->info + type;
2487 spin_lock(&dq_data_lock);
2488 if (ii->dqi_valid & IIF_BGRACE)
2489 mi->dqi_bgrace = ii->dqi_bgrace;
2490 if (ii->dqi_valid & IIF_IGRACE)
2491 mi->dqi_igrace = ii->dqi_igrace;
2492 if (ii->dqi_valid & IIF_FLAGS)
Jan Kara268157b2009-01-27 15:47:22 +01002493 mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) |
2494 (ii->dqi_flags & DQF_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002495 spin_unlock(&dq_data_lock);
2496 mark_info_dirty(sb, type);
2497 /* Force write to disk */
2498 sb->dq_op->write_info(sb, type);
Jan Karaf55abc02008-08-20 17:50:32 +02002499out:
Ingo Molnard3be9152006-03-23 03:00:29 -08002500 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002501 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002502}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002503EXPORT_SYMBOL(dquot_set_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504
Christoph Hellwig287a8092010-05-19 07:16:45 -04002505const struct quotactl_ops dquot_quotactl_ops = {
2506 .quota_on = dquot_quota_on,
2507 .quota_off = dquot_quota_off,
2508 .quota_sync = dquot_quota_sync,
2509 .get_info = dquot_get_dqinfo,
2510 .set_info = dquot_set_dqinfo,
2511 .get_dqblk = dquot_get_dqblk,
2512 .set_dqblk = dquot_set_dqblk
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513};
Christoph Hellwig287a8092010-05-19 07:16:45 -04002514EXPORT_SYMBOL(dquot_quotactl_ops);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002515
2516static int do_proc_dqstats(struct ctl_table *table, int write,
2517 void __user *buffer, size_t *lenp, loff_t *ppos)
2518{
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002519 unsigned int type = (int *)table->data - dqstats.stat;
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002520
2521 /* Update global table */
2522 dqstats.stat[type] =
2523 percpu_counter_sum_positive(&dqstats.counter[type]);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002524 return proc_dointvec(table, write, buffer, lenp, ppos);
2525}
2526
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527static ctl_table fs_dqstats_table[] = {
2528 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002529 .procname = "lookups",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002530 .data = &dqstats.stat[DQST_LOOKUPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 .maxlen = sizeof(int),
2532 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002533 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534 },
2535 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 .procname = "drops",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002537 .data = &dqstats.stat[DQST_DROPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002538 .maxlen = sizeof(int),
2539 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002540 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 },
2542 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002543 .procname = "reads",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002544 .data = &dqstats.stat[DQST_READS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 .maxlen = sizeof(int),
2546 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002547 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 },
2549 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002550 .procname = "writes",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002551 .data = &dqstats.stat[DQST_WRITES],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002552 .maxlen = sizeof(int),
2553 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002554 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555 },
2556 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002557 .procname = "cache_hits",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002558 .data = &dqstats.stat[DQST_CACHE_HITS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559 .maxlen = sizeof(int),
2560 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002561 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562 },
2563 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564 .procname = "allocated_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002565 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566 .maxlen = sizeof(int),
2567 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002568 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 },
2570 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002571 .procname = "free_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002572 .data = &dqstats.stat[DQST_FREE_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573 .maxlen = sizeof(int),
2574 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002575 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576 },
2577 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002578 .procname = "syncs",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002579 .data = &dqstats.stat[DQST_SYNCS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 .maxlen = sizeof(int),
2581 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002582 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 },
Jan Kara8e893462007-10-16 23:29:31 -07002584#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586 .procname = "warnings",
2587 .data = &flag_print_warnings,
2588 .maxlen = sizeof(int),
2589 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08002590 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002591 },
Jan Kara8e893462007-10-16 23:29:31 -07002592#endif
Eric W. Biedermanab092032009-11-05 14:25:10 -08002593 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594};
2595
2596static ctl_table fs_table[] = {
2597 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002598 .procname = "quota",
2599 .mode = 0555,
2600 .child = fs_dqstats_table,
2601 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002602 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603};
2604
2605static ctl_table sys_table[] = {
2606 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 .procname = "fs",
2608 .mode = 0555,
2609 .child = fs_table,
2610 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002611 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612};
2613
2614static int __init dquot_init(void)
2615{
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002616 int i, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 unsigned long nr_hash, order;
2618
2619 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2620
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08002621 register_sysctl_table(sys_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622
Paul Mundt20c2df82007-07-20 10:11:58 +09002623 dquot_cachep = kmem_cache_create("dquot",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624 sizeof(struct dquot), sizeof(unsigned long) * 4,
Paul Jacksonfffb60f2006-03-24 03:16:06 -08002625 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2626 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +09002627 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628
2629 order = 0;
2630 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2631 if (!dquot_hash)
2632 panic("Cannot create dquot hash table");
2633
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002634 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2635 ret = percpu_counter_init(&dqstats.counter[i], 0);
2636 if (ret)
2637 panic("Cannot create dquot stat counters");
2638 }
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002639
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 /* Find power-of-two hlist_heads which can fit into allocation */
2641 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2642 dq_hash_bits = 0;
2643 do {
2644 dq_hash_bits++;
2645 } while (nr_hash >> dq_hash_bits);
2646 dq_hash_bits--;
2647
2648 nr_hash = 1UL << dq_hash_bits;
2649 dq_hash_mask = nr_hash - 1;
2650 for (i = 0; i < nr_hash; i++)
2651 INIT_HLIST_HEAD(dquot_hash + i);
2652
2653 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2654 nr_hash, order, (PAGE_SIZE << order));
2655
Rusty Russell8e1f9362007-07-17 04:03:17 -07002656 register_shrinker(&dqcache_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 return 0;
2659}
2660module_init(dquot_init);