blob: c495a3055e2a3be9b5e471afebdf53ac00c6fe51 [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>
Al Viro40401532012-02-13 03:58:52 +000074#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070075#include <linux/kmod.h>
76#include <linux/namei.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>
Dave Chinner55fa6092011-03-22 22:23:40 +110079#include "../internal.h" /* ugh */
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Jeff Liuf3da9312012-05-28 23:40:17 +080081#include <linux/uaccess.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070082
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:
Jan Karaa80b12c2012-04-25 21:15:53 +0200119 * dqonoff_mutex > i_mutex > journal_lock > dqptr_sem > dquot->dq_lock >
Ingo Molnard3be9152006-03-23 03:00:29 -0800120 * dqio_mutex
Jan Karaa80b12c2012-04-25 21:15:53 +0200121 * dqonoff_mutex > i_mutex comes from dquot_quota_sync, dquot_enable, etc.
Jan Karacc334122009-01-12 17:23:05 +0100122 * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem >
123 * dqptr_sem. But filesystem has to count with the fact that functions such as
124 * dquot_alloc_space() acquire dqptr_sem and they usually have to be called
125 * from inside a transaction to keep filesystem consistency after a crash. Also
126 * filesystems usually want to do some IO on dquot from ->mark_dirty which is
127 * called with dqptr_sem held.
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,
Joe Perches055adcb2010-11-23 18:49:54 -0800136 const char *fmt, ...)
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200137{
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200138 if (printk_ratelimit()) {
Joe Perches055adcb2010-11-23 18:49:54 -0800139 va_list args;
140 struct va_format vaf;
141
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200142 va_start(args, fmt);
Joe Perches055adcb2010-11-23 18:49:54 -0800143
144 vaf.fmt = fmt;
145 vaf.va = &args;
146
147 printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
148 sb->s_id, func, &vaf);
149
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200150 va_end(args);
151 }
152}
153EXPORT_SYMBOL(__quota_error);
154
Sergey Senozhatskyda8d1ba2010-04-26 12:09:26 +0200155#if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156static char *quotatypes[] = INITQFNAMES;
Sergey Senozhatskyda8d1ba2010-04-26 12:09:26 +0200157#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700158static struct quota_format_type *quota_formats; /* List of registered formats */
159static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
160
161/* SLAB cache for dquot structures */
Christoph Lametere18b8902006-12-06 20:33:20 -0800162static struct kmem_cache *dquot_cachep;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163
164int register_quota_format(struct quota_format_type *fmt)
165{
166 spin_lock(&dq_list_lock);
167 fmt->qf_next = quota_formats;
168 quota_formats = fmt;
169 spin_unlock(&dq_list_lock);
170 return 0;
171}
Mingming Cao08d03502009-01-14 16:19:32 +0100172EXPORT_SYMBOL(register_quota_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173
174void unregister_quota_format(struct quota_format_type *fmt)
175{
176 struct quota_format_type **actqf;
177
178 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100179 for (actqf = &quota_formats; *actqf && *actqf != fmt;
180 actqf = &(*actqf)->qf_next)
181 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182 if (*actqf)
183 *actqf = (*actqf)->qf_next;
184 spin_unlock(&dq_list_lock);
185}
Mingming Cao08d03502009-01-14 16:19:32 +0100186EXPORT_SYMBOL(unregister_quota_format);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700187
188static struct quota_format_type *find_quota_format(int id)
189{
190 struct quota_format_type *actqf;
191
192 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100193 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
194 actqf = actqf->qf_next)
195 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700196 if (!actqf || !try_module_get(actqf->qf_owner)) {
197 int qm;
198
199 spin_unlock(&dq_list_lock);
200
Jan Kara268157b2009-01-27 15:47:22 +0100201 for (qm = 0; module_names[qm].qm_fmt_id &&
202 module_names[qm].qm_fmt_id != id; qm++)
203 ;
204 if (!module_names[qm].qm_fmt_id ||
205 request_module(module_names[qm].qm_mod_name))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 return NULL;
207
208 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100209 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
210 actqf = actqf->qf_next)
211 ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 if (actqf && !try_module_get(actqf->qf_owner))
213 actqf = NULL;
214 }
215 spin_unlock(&dq_list_lock);
216 return actqf;
217}
218
219static void put_quota_format(struct quota_format_type *fmt)
220{
221 module_put(fmt->qf_owner);
222}
223
224/*
225 * Dquot List Management:
226 * The quota code uses three lists for dquot management: the inuse_list,
227 * free_dquots, and dquot_hash[] array. A single dquot structure may be
228 * on all three lists, depending on its current state.
229 *
230 * All dquots are placed to the end of inuse_list when first created, and this
231 * list is used for invalidate operation, which must look at every dquot.
232 *
233 * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
234 * and this list is searched whenever we need an available dquot. Dquots are
235 * removed from the list as soon as they are used again, and
236 * dqstats.free_dquots gives the number of dquots on the list. When
237 * dquot is invalidated it's completely released from memory.
238 *
239 * Dquots with a specific identity (device, type and id) are placed on
240 * one of the dquot_hash[] hash chains. The provides an efficient search
241 * mechanism to locate a specific dquot.
242 */
243
244static LIST_HEAD(inuse_list);
245static LIST_HEAD(free_dquots);
246static unsigned int dq_hash_bits, dq_hash_mask;
247static struct hlist_head *dquot_hash;
248
249struct dqstats dqstats;
Mingming Cao08d03502009-01-14 16:19:32 +0100250EXPORT_SYMBOL(dqstats);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251
Jan Kara0a5a9c72010-02-09 18:20:39 +0100252static qsize_t inode_get_rsv_space(struct inode *inode);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500253static void __dquot_initialize(struct inode *inode, int type);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255static inline unsigned int
256hashfn(const struct super_block *sb, unsigned int id, int type)
257{
258 unsigned long tmp;
259
260 tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
261 return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
262}
263
264/*
265 * Following list functions expect dq_list_lock to be held
266 */
267static inline void insert_dquot_hash(struct dquot *dquot)
268{
Jan Kara268157b2009-01-27 15:47:22 +0100269 struct hlist_head *head;
270 head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 hlist_add_head(&dquot->dq_hash, head);
272}
273
274static inline void remove_dquot_hash(struct dquot *dquot)
275{
276 hlist_del_init(&dquot->dq_hash);
277}
278
Jan Kara7a2435d2009-01-27 01:47:11 +0100279static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
280 unsigned int id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281{
282 struct hlist_node *node;
283 struct dquot *dquot;
284
285 hlist_for_each (node, dquot_hash+hashent) {
286 dquot = hlist_entry(node, struct dquot, dq_hash);
Jan Kara268157b2009-01-27 15:47:22 +0100287 if (dquot->dq_sb == sb && dquot->dq_id == id &&
288 dquot->dq_type == type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 return dquot;
290 }
Jan Karadd6f3c62009-01-26 16:01:43 +0100291 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292}
293
294/* Add a dquot to the tail of the free list */
295static inline void put_dquot_last(struct dquot *dquot)
296{
Akinobu Mita8e130592006-06-26 00:24:37 -0700297 list_add_tail(&dquot->dq_free, &free_dquots);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400298 dqstats_inc(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700299}
300
301static inline void remove_free_dquot(struct dquot *dquot)
302{
303 if (list_empty(&dquot->dq_free))
304 return;
305 list_del_init(&dquot->dq_free);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400306 dqstats_dec(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307}
308
309static inline void put_inuse(struct dquot *dquot)
310{
311 /* We add to the back of inuse list so we don't have to restart
312 * when traversing this list and we block */
Akinobu Mita8e130592006-06-26 00:24:37 -0700313 list_add_tail(&dquot->dq_inuse, &inuse_list);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400314 dqstats_inc(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315}
316
317static inline void remove_inuse(struct dquot *dquot)
318{
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400319 dqstats_dec(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700320 list_del(&dquot->dq_inuse);
321}
322/*
323 * End of list functions needing dq_list_lock
324 */
325
326static void wait_on_dquot(struct dquot *dquot)
327{
Ingo Molnard3be9152006-03-23 03:00:29 -0800328 mutex_lock(&dquot->dq_lock);
329 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700330}
331
Jan Kara03f6e922008-04-28 02:14:32 -0700332static inline int dquot_dirty(struct dquot *dquot)
333{
334 return test_bit(DQ_MOD_B, &dquot->dq_flags);
335}
336
337static inline int mark_dquot_dirty(struct dquot *dquot)
338{
339 return dquot->dq_sb->dq_op->mark_dirty(dquot);
340}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300342/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700343int dquot_mark_dquot_dirty(struct dquot *dquot)
344{
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300345 int ret = 1;
346
347 /* If quota is dirty already, we don't have to acquire dq_list_lock */
348 if (test_bit(DQ_MOD_B, &dquot->dq_flags))
349 return 1;
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 spin_lock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300352 if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700353 list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
354 info[dquot->dq_type].dqi_dirty_list);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300355 ret = 0;
356 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357 spin_unlock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300358 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359}
Mingming Cao08d03502009-01-14 16:19:32 +0100360EXPORT_SYMBOL(dquot_mark_dquot_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +0300362/* Dirtify all the dquots - this can block when journalling */
363static inline int mark_all_dquot_dirty(struct dquot * const *dquot)
364{
365 int ret, err, cnt;
366
367 ret = err = 0;
368 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
369 if (dquot[cnt])
370 /* Even in case of error we have to continue */
371 ret = mark_dquot_dirty(dquot[cnt]);
372 if (!err)
373 err = ret;
374 }
375 return err;
376}
377
378static inline void dqput_all(struct dquot **dquot)
379{
380 unsigned int cnt;
381
382 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
383 dqput(dquot[cnt]);
384}
385
Linus Torvalds1da177e2005-04-16 15:20:36 -0700386/* This function needs dq_list_lock */
387static inline int clear_dquot_dirty(struct dquot *dquot)
388{
389 if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags))
390 return 0;
391 list_del_init(&dquot->dq_dirty);
392 return 1;
393}
394
395void mark_info_dirty(struct super_block *sb, int type)
396{
397 set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags);
398}
399EXPORT_SYMBOL(mark_info_dirty);
400
401/*
402 * Read dquot from disk and alloc space for it
403 */
404
405int dquot_acquire(struct dquot *dquot)
406{
407 int ret = 0, ret2 = 0;
408 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
409
Ingo Molnard3be9152006-03-23 03:00:29 -0800410 mutex_lock(&dquot->dq_lock);
411 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700412 if (!test_bit(DQ_READ_B, &dquot->dq_flags))
413 ret = dqopt->ops[dquot->dq_type]->read_dqblk(dquot);
414 if (ret < 0)
415 goto out_iolock;
416 set_bit(DQ_READ_B, &dquot->dq_flags);
417 /* Instantiate dquot if needed */
418 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
419 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
420 /* Write the info if needed */
Jan Kara268157b2009-01-27 15:47:22 +0100421 if (info_dirty(&dqopt->info[dquot->dq_type])) {
422 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
423 dquot->dq_sb, dquot->dq_type);
424 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 if (ret < 0)
426 goto out_iolock;
427 if (ret2 < 0) {
428 ret = ret2;
429 goto out_iolock;
430 }
431 }
432 set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
433out_iolock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800434 mutex_unlock(&dqopt->dqio_mutex);
435 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436 return ret;
437}
Mingming Cao08d03502009-01-14 16:19:32 +0100438EXPORT_SYMBOL(dquot_acquire);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439
440/*
441 * Write dquot to disk
442 */
443int dquot_commit(struct dquot *dquot)
444{
Jan Karab03f2452011-03-31 18:36:52 +0200445 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
447
Ingo Molnard3be9152006-03-23 03:00:29 -0800448 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 spin_lock(&dq_list_lock);
450 if (!clear_dquot_dirty(dquot)) {
451 spin_unlock(&dq_list_lock);
452 goto out_sem;
453 }
454 spin_unlock(&dq_list_lock);
455 /* Inactive dquot can be only if there was error during read/init
456 * => we have better not writing it */
Jan Karab03f2452011-03-31 18:36:52 +0200457 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
Jan Karab03f2452011-03-31 18:36:52 +0200459 else
460 ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461out_sem:
Ingo Molnard3be9152006-03-23 03:00:29 -0800462 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return ret;
464}
Mingming Cao08d03502009-01-14 16:19:32 +0100465EXPORT_SYMBOL(dquot_commit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466
467/*
468 * Release dquot
469 */
470int dquot_release(struct dquot *dquot)
471{
472 int ret = 0, ret2 = 0;
473 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
474
Ingo Molnard3be9152006-03-23 03:00:29 -0800475 mutex_lock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476 /* Check whether we are not racing with some other dqget() */
477 if (atomic_read(&dquot->dq_count) > 1)
478 goto out_dqlock;
Ingo Molnard3be9152006-03-23 03:00:29 -0800479 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 if (dqopt->ops[dquot->dq_type]->release_dqblk) {
481 ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot);
482 /* Write the info */
Jan Kara268157b2009-01-27 15:47:22 +0100483 if (info_dirty(&dqopt->info[dquot->dq_type])) {
484 ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
485 dquot->dq_sb, dquot->dq_type);
486 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 if (ret >= 0)
488 ret = ret2;
489 }
490 clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
Ingo Molnard3be9152006-03-23 03:00:29 -0800491 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492out_dqlock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800493 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 return ret;
495}
Mingming Cao08d03502009-01-14 16:19:32 +0100496EXPORT_SYMBOL(dquot_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497
Jan Kara7d9056b2008-11-25 15:31:32 +0100498void dquot_destroy(struct dquot *dquot)
Jan Kara74f783a2008-08-19 14:51:22 +0200499{
500 kmem_cache_free(dquot_cachep, dquot);
501}
Jan Kara7d9056b2008-11-25 15:31:32 +0100502EXPORT_SYMBOL(dquot_destroy);
Jan Kara74f783a2008-08-19 14:51:22 +0200503
504static inline void do_destroy_dquot(struct dquot *dquot)
505{
506 dquot->dq_sb->dq_op->destroy_dquot(dquot);
507}
508
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509/* Invalidate all dquots on the list. Note that this function is called after
510 * quota is disabled and pointers from inodes removed so there cannot be new
Jan Kara6362e4d2006-03-23 03:00:17 -0800511 * quota users. There can still be some users of quotas due to inodes being
512 * just deleted or pruned by prune_icache() (those are not attached to any
Jan Karacc334122009-01-12 17:23:05 +0100513 * list) or parallel quotactl call. We have to wait for such users.
Jan Kara6362e4d2006-03-23 03:00:17 -0800514 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515static void invalidate_dquots(struct super_block *sb, int type)
516{
Domen Puncerc33ed272005-06-25 14:59:36 -0700517 struct dquot *dquot, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518
Jan Kara6362e4d2006-03-23 03:00:17 -0800519restart:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700520 spin_lock(&dq_list_lock);
Domen Puncerc33ed272005-06-25 14:59:36 -0700521 list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 if (dquot->dq_sb != sb)
523 continue;
524 if (dquot->dq_type != type)
525 continue;
Jan Kara6362e4d2006-03-23 03:00:17 -0800526 /* Wait for dquot users */
527 if (atomic_read(&dquot->dq_count)) {
528 DEFINE_WAIT(wait);
529
530 atomic_inc(&dquot->dq_count);
531 prepare_to_wait(&dquot->dq_wait_unused, &wait,
532 TASK_UNINTERRUPTIBLE);
533 spin_unlock(&dq_list_lock);
534 /* Once dqput() wakes us up, we know it's time to free
535 * the dquot.
536 * IMPORTANT: we rely on the fact that there is always
537 * at most one process waiting for dquot to free.
538 * Otherwise dq_count would be > 1 and we would never
539 * wake up.
540 */
541 if (atomic_read(&dquot->dq_count) > 1)
542 schedule();
543 finish_wait(&dquot->dq_wait_unused, &wait);
544 dqput(dquot);
545 /* At this moment dquot() need not exist (it could be
546 * reclaimed by prune_dqcache(). Hence we must
547 * restart. */
548 goto restart;
549 }
550 /*
551 * Quota now has no users and it has been written on last
552 * dqput()
553 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 remove_dquot_hash(dquot);
555 remove_free_dquot(dquot);
556 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200557 do_destroy_dquot(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 }
559 spin_unlock(&dq_list_lock);
560}
561
Jan Kara12c77522008-10-20 17:05:00 +0200562/* Call callback for every active dquot on given filesystem */
563int dquot_scan_active(struct super_block *sb,
564 int (*fn)(struct dquot *dquot, unsigned long priv),
565 unsigned long priv)
566{
567 struct dquot *dquot, *old_dquot = NULL;
568 int ret = 0;
569
570 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
571 spin_lock(&dq_list_lock);
572 list_for_each_entry(dquot, &inuse_list, dq_inuse) {
573 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
574 continue;
575 if (dquot->dq_sb != sb)
576 continue;
577 /* Now we have active dquot so we can just increase use count */
578 atomic_inc(&dquot->dq_count);
Jan Kara12c77522008-10-20 17:05:00 +0200579 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400580 dqstats_inc(DQST_LOOKUPS);
Jan Kara12c77522008-10-20 17:05:00 +0200581 dqput(old_dquot);
582 old_dquot = dquot;
583 ret = fn(dquot, priv);
584 if (ret < 0)
585 goto out;
586 spin_lock(&dq_list_lock);
587 /* We are safe to continue now because our dquot could not
588 * be moved out of the inuse list while we hold the reference */
589 }
590 spin_unlock(&dq_list_lock);
591out:
592 dqput(old_dquot);
593 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
594 return ret;
595}
Mingming Cao08d03502009-01-14 16:19:32 +0100596EXPORT_SYMBOL(dquot_scan_active);
Jan Kara12c77522008-10-20 17:05:00 +0200597
Jan Karaceed1722012-07-03 16:45:28 +0200598/* Write all dquot structures to quota files */
599int dquot_writeback_dquots(struct super_block *sb, int type)
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;
Jan Karaceed1722012-07-03 16:45:28 +0200605 int err, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
Ingo Molnard3be9152006-03-23 03:00:29 -0800607 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
609 if (type != -1 && cnt != type)
610 continue;
Jan Karaf55abc02008-08-20 17:50:32 +0200611 if (!sb_has_quota_active(sb, cnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 continue;
613 spin_lock(&dq_list_lock);
614 dirty = &dqopt->info[cnt].dqi_dirty_list;
615 while (!list_empty(dirty)) {
Jan Kara268157b2009-01-27 15:47:22 +0100616 dquot = list_first_entry(dirty, struct dquot,
617 dq_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 /* Dirty and inactive can be only bad dquot... */
619 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
620 clear_dquot_dirty(dquot);
621 continue;
622 }
623 /* Now we have active dquot from which someone is
624 * holding reference so we can safely just increase
625 * use count */
626 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400628 dqstats_inc(DQST_LOOKUPS);
Jan Karaceed1722012-07-03 16:45:28 +0200629 err = sb->dq_op->write_dquot(dquot);
630 if (!ret && err)
631 err = ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 dqput(dquot);
633 spin_lock(&dq_list_lock);
634 }
635 spin_unlock(&dq_list_lock);
636 }
637
638 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karaf55abc02008-08-20 17:50:32 +0200639 if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
640 && info_dirty(&dqopt->info[cnt]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 sb->dq_op->write_info(sb, cnt);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400642 dqstats_inc(DQST_SYNCS);
Ingo Molnard3be9152006-03-23 03:00:29 -0800643 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644
Jan Karaceed1722012-07-03 16:45:28 +0200645 return ret;
646}
647EXPORT_SYMBOL(dquot_writeback_dquots);
648
649/* Write all dquot structures to disk and make them visible from userspace */
650int dquot_quota_sync(struct super_block *sb, int type)
651{
652 struct quota_info *dqopt = sb_dqopt(sb);
653 int cnt;
654 int ret;
655
656 ret = dquot_writeback_dquots(sb, type);
657 if (ret)
658 return ret;
659 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500660 return 0;
661
662 /* This is not very clever (and fast) but currently I don't know about
663 * any other simple way of getting quota data to disk and we must get
664 * them there for userspace to be visible... */
665 if (sb->s_op->sync_fs)
666 sb->s_op->sync_fs(sb, 1);
667 sync_blockdev(sb->s_bdev);
668
669 /*
670 * Now when everything is written we can discard the pagecache so
671 * that userspace sees the changes.
672 */
Jan Karaf9ef1782012-04-25 21:10:31 +0200673 mutex_lock(&dqopt->dqonoff_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500674 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
675 if (type != -1 && cnt != type)
676 continue;
677 if (!sb_has_quota_active(sb, cnt))
678 continue;
Jan Karaa80b12c2012-04-25 21:15:53 +0200679 mutex_lock(&dqopt->files[cnt]->i_mutex);
Jan Karaf9ef1782012-04-25 21:10:31 +0200680 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
681 mutex_unlock(&dqopt->files[cnt]->i_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500682 }
Jan Karaf9ef1782012-04-25 21:10:31 +0200683 mutex_unlock(&dqopt->dqonoff_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500684
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685 return 0;
686}
Christoph Hellwig287a8092010-05-19 07:16:45 -0400687EXPORT_SYMBOL(dquot_quota_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688
689/* Free unused dquots from cache */
690static void prune_dqcache(int count)
691{
692 struct list_head *head;
693 struct dquot *dquot;
694
695 head = free_dquots.prev;
696 while (head != &free_dquots && count) {
697 dquot = list_entry(head, struct dquot, dq_free);
698 remove_dquot_hash(dquot);
699 remove_free_dquot(dquot);
700 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200701 do_destroy_dquot(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 count--;
703 head = free_dquots.prev;
704 }
705}
706
707/*
708 * This is called from kswapd when we think we need some
709 * more memory
710 */
Ying Han1495f232011-05-24 17:12:27 -0700711static int shrink_dqcache_memory(struct shrinker *shrink,
712 struct shrink_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
Ying Han1495f232011-05-24 17:12:27 -0700714 int nr = sc->nr_to_scan;
715
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716 if (nr) {
717 spin_lock(&dq_list_lock);
718 prune_dqcache(nr);
719 spin_unlock(&dq_list_lock);
720 }
Dmitry Monakhovf32764b2010-05-26 23:21:58 +0200721 return ((unsigned)
722 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])
723 /100) * sysctl_vfs_cache_pressure;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724}
725
Rusty Russell8e1f9362007-07-17 04:03:17 -0700726static struct shrinker dqcache_shrinker = {
727 .shrink = shrink_dqcache_memory,
728 .seeks = DEFAULT_SEEKS,
729};
730
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731/*
732 * Put reference to dquot
733 * NOTE: If you change this function please check whether dqput_blocks() works right...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200735void dqput(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736{
Jan Karab48d3802008-07-25 01:46:49 -0700737 int ret;
738
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 if (!dquot)
740 return;
Jan Kara62af9b52010-04-19 16:47:20 +0200741#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 if (!atomic_read(&dquot->dq_count)) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200743 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
744 quotatypes[dquot->dq_type], dquot->dq_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 BUG();
746 }
747#endif
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400748 dqstats_inc(DQST_DROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749we_slept:
750 spin_lock(&dq_list_lock);
751 if (atomic_read(&dquot->dq_count) > 1) {
752 /* We have more than one user... nothing to do */
753 atomic_dec(&dquot->dq_count);
Jan Kara6362e4d2006-03-23 03:00:17 -0800754 /* Releasing dquot during quotaoff phase? */
Jan Karaf55abc02008-08-20 17:50:32 +0200755 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) &&
Jan Kara6362e4d2006-03-23 03:00:17 -0800756 atomic_read(&dquot->dq_count) == 1)
757 wake_up(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 spin_unlock(&dq_list_lock);
759 return;
760 }
761 /* Need to release dquot? */
762 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
763 spin_unlock(&dq_list_lock);
764 /* Commit dquot before releasing */
Jan Karab48d3802008-07-25 01:46:49 -0700765 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
766 if (ret < 0) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200767 quota_error(dquot->dq_sb, "Can't write quota structure"
768 " (error %d). Quota may get out of sync!",
769 ret);
Jan Karab48d3802008-07-25 01:46:49 -0700770 /*
771 * We clear dirty bit anyway, so that we avoid
772 * infinite loop here
773 */
774 spin_lock(&dq_list_lock);
775 clear_dquot_dirty(dquot);
776 spin_unlock(&dq_list_lock);
777 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778 goto we_slept;
779 }
780 /* Clear flag in case dquot was inactive (something bad happened) */
781 clear_dquot_dirty(dquot);
782 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
783 spin_unlock(&dq_list_lock);
784 dquot->dq_sb->dq_op->release_dquot(dquot);
785 goto we_slept;
786 }
787 atomic_dec(&dquot->dq_count);
Jan Kara62af9b52010-04-19 16:47:20 +0200788#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 /* sanity check */
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200790 BUG_ON(!list_empty(&dquot->dq_free));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791#endif
792 put_dquot_last(dquot);
793 spin_unlock(&dq_list_lock);
794}
Mingming Cao08d03502009-01-14 16:19:32 +0100795EXPORT_SYMBOL(dqput);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
Jan Kara7d9056b2008-11-25 15:31:32 +0100797struct dquot *dquot_alloc(struct super_block *sb, int type)
Jan Kara74f783a2008-08-19 14:51:22 +0200798{
799 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
800}
Jan Kara7d9056b2008-11-25 15:31:32 +0100801EXPORT_SYMBOL(dquot_alloc);
Jan Kara74f783a2008-08-19 14:51:22 +0200802
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803static struct dquot *get_empty_dquot(struct super_block *sb, int type)
804{
805 struct dquot *dquot;
806
Jan Kara74f783a2008-08-19 14:51:22 +0200807 dquot = sb->dq_op->alloc_dquot(sb, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808 if(!dquot)
Jan Karadd6f3c62009-01-26 16:01:43 +0100809 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810
Ingo Molnard3be9152006-03-23 03:00:29 -0800811 mutex_init(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 INIT_LIST_HEAD(&dquot->dq_free);
813 INIT_LIST_HEAD(&dquot->dq_inuse);
814 INIT_HLIST_NODE(&dquot->dq_hash);
815 INIT_LIST_HEAD(&dquot->dq_dirty);
Jan Kara6362e4d2006-03-23 03:00:17 -0800816 init_waitqueue_head(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700817 dquot->dq_sb = sb;
818 dquot->dq_type = type;
819 atomic_set(&dquot->dq_count, 1);
820
821 return dquot;
822}
823
824/*
825 * Get reference to dquot
Jan Karacc334122009-01-12 17:23:05 +0100826 *
827 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
828 * destroying our dquot by:
829 * a) checking for quota flags under dq_list_lock and
830 * b) getting a reference to dquot before we release dq_list_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700831 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200832struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833{
834 unsigned int hashent = hashfn(sb, id, type);
Jan Karadd6f3c62009-01-26 16:01:43 +0100835 struct dquot *dquot = NULL, *empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836
Jan Karaf55abc02008-08-20 17:50:32 +0200837 if (!sb_has_quota_active(sb, type))
Jan Karadd6f3c62009-01-26 16:01:43 +0100838 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839we_slept:
840 spin_lock(&dq_list_lock);
Jan Karacc334122009-01-12 17:23:05 +0100841 spin_lock(&dq_state_lock);
842 if (!sb_has_quota_active(sb, type)) {
843 spin_unlock(&dq_state_lock);
844 spin_unlock(&dq_list_lock);
845 goto out;
846 }
847 spin_unlock(&dq_state_lock);
848
Jan Karadd6f3c62009-01-26 16:01:43 +0100849 dquot = find_dquot(hashent, sb, id, type);
850 if (!dquot) {
851 if (!empty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 spin_unlock(&dq_list_lock);
Jan Karadd6f3c62009-01-26 16:01:43 +0100853 empty = get_empty_dquot(sb, type);
854 if (!empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 schedule(); /* Try to wait for a moment... */
856 goto we_slept;
857 }
858 dquot = empty;
Jan Karadd6f3c62009-01-26 16:01:43 +0100859 empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860 dquot->dq_id = id;
861 /* all dquots go on the inuse_list */
862 put_inuse(dquot);
863 /* hash it first so it can be found */
864 insert_dquot_hash(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400866 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 } else {
868 if (!atomic_read(&dquot->dq_count))
869 remove_free_dquot(dquot);
870 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400872 dqstats_inc(DQST_CACHE_HITS);
873 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 }
Jan Kara268157b2009-01-27 15:47:22 +0100875 /* Wait for dq_lock - after this we know that either dquot_release() is
876 * already finished or it will be canceled due to dq_count > 1 test */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 wait_on_dquot(dquot);
Jan Kara268157b2009-01-27 15:47:22 +0100878 /* Read the dquot / allocate space in quota file */
879 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
880 sb->dq_op->acquire_dquot(dquot) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 dqput(dquot);
Jan Karadd6f3c62009-01-26 16:01:43 +0100882 dquot = NULL;
Jan Karacc334122009-01-12 17:23:05 +0100883 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
Jan Kara62af9b52010-04-19 16:47:20 +0200885#ifdef CONFIG_QUOTA_DEBUG
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200886 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887#endif
Jan Karacc334122009-01-12 17:23:05 +0100888out:
889 if (empty)
890 do_destroy_dquot(empty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891
892 return dquot;
893}
Mingming Cao08d03502009-01-14 16:19:32 +0100894EXPORT_SYMBOL(dqget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896static int dqinit_needed(struct inode *inode, int type)
897{
898 int cnt;
899
900 if (IS_NOQUOTA(inode))
901 return 0;
902 if (type != -1)
Jan Karadd6f3c62009-01-26 16:01:43 +0100903 return !inode->i_dquot[type];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karadd6f3c62009-01-26 16:01:43 +0100905 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906 return 1;
907 return 0;
908}
909
Ingo Molnard3be9152006-03-23 03:00:29 -0800910/* This routine is guarded by dqonoff_mutex mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911static void add_dquot_ref(struct super_block *sb, int type)
912{
Jan Kara941d2382008-02-06 01:37:36 -0800913 struct inode *inode, *old_inode = NULL;
Jan Kara62af9b52010-04-19 16:47:20 +0200914#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100915 int reserved = 0;
Jan Kara4c5e6c02010-04-06 18:52:47 +0200916#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917
Dave Chinner55fa6092011-03-22 22:23:40 +1100918 spin_lock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800919 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Dave Chinner250df6e2011-03-22 22:23:36 +1100920 spin_lock(&inode->i_lock);
921 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
922 !atomic_read(&inode->i_writecount) ||
923 !dqinit_needed(inode, type)) {
924 spin_unlock(&inode->i_lock);
Nick Pigginaabb8fd2009-03-11 13:17:36 -0700925 continue;
Dave Chinner250df6e2011-03-22 22:23:36 +1100926 }
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800927 __iget(inode);
Dave Chinner250df6e2011-03-22 22:23:36 +1100928 spin_unlock(&inode->i_lock);
Dave Chinner55fa6092011-03-22 22:23:40 +1100929 spin_unlock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800930
Jan Karad7e97112012-04-24 17:08:41 +0200931#ifdef CONFIG_QUOTA_DEBUG
932 if (unlikely(inode_get_rsv_space(inode) > 0))
933 reserved = 1;
934#endif
Jan Kara941d2382008-02-06 01:37:36 -0800935 iput(old_inode);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500936 __dquot_initialize(inode, type);
Dave Chinner55fa6092011-03-22 22:23:40 +1100937
938 /*
939 * We hold a reference to 'inode' so it couldn't have been
940 * removed from s_inodes list while we dropped the
941 * inode_sb_list_lock We cannot iput the inode now as we can be
942 * holding the last reference and we cannot iput it under
943 * inode_sb_list_lock. So we keep the reference and iput it
944 * later.
945 */
Jan Kara941d2382008-02-06 01:37:36 -0800946 old_inode = inode;
Dave Chinner55fa6092011-03-22 22:23:40 +1100947 spin_lock(&inode_sb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700948 }
Dave Chinner55fa6092011-03-22 22:23:40 +1100949 spin_unlock(&inode_sb_list_lock);
Jan Kara941d2382008-02-06 01:37:36 -0800950 iput(old_inode);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100951
Jan Kara62af9b52010-04-19 16:47:20 +0200952#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100953 if (reserved) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200954 quota_error(sb, "Writes happened before quota was turned on "
955 "thus quota information is probably inconsistent. "
956 "Please run quotacheck(8)");
Jan Kara0a5a9c72010-02-09 18:20:39 +0100957 }
Jan Kara4c5e6c02010-04-06 18:52:47 +0200958#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959}
960
Jan Kara268157b2009-01-27 15:47:22 +0100961/*
962 * Return 0 if dqput() won't block.
963 * (note that 1 doesn't necessarily mean blocking)
964 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700965static inline int dqput_blocks(struct dquot *dquot)
966{
967 if (atomic_read(&dquot->dq_count) <= 1)
968 return 1;
969 return 0;
970}
971
Jan Kara268157b2009-01-27 15:47:22 +0100972/*
973 * Remove references to dquots from inode and add dquot to list for freeing
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300974 * if we have the last reference to dquot
Jan Kara268157b2009-01-27 15:47:22 +0100975 * We can't race with anybody because we hold dqptr_sem for writing...
976 */
Adrian Bunke5f00f42007-05-08 00:27:22 -0700977static int remove_inode_dquot_ref(struct inode *inode, int type,
978 struct list_head *tofree_head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979{
980 struct dquot *dquot = inode->i_dquot[type];
981
Jan Karadd6f3c62009-01-26 16:01:43 +0100982 inode->i_dquot[type] = NULL;
983 if (dquot) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 if (dqput_blocks(dquot)) {
Jan Kara62af9b52010-04-19 16:47:20 +0200985#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 if (atomic_read(&dquot->dq_count) != 1)
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200987 quota_error(inode->i_sb, "Adding dquot with "
988 "dq_count %d to dispose list",
989 atomic_read(&dquot->dq_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990#endif
991 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100992 /* As dquot must have currently users it can't be on
993 * the free list... */
994 list_add(&dquot->dq_free, tofree_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 spin_unlock(&dq_list_lock);
996 return 1;
997 }
998 else
999 dqput(dquot); /* We have guaranteed we won't block */
1000 }
1001 return 0;
1002}
1003
Jan Kara268157b2009-01-27 15:47:22 +01001004/*
1005 * Free list of dquots
1006 * Dquots are removed from inodes and no new references can be got so we are
1007 * the only ones holding reference
1008 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009static void put_dquot_list(struct list_head *tofree_head)
1010{
1011 struct list_head *act_head;
1012 struct dquot *dquot;
1013
1014 act_head = tofree_head->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 while (act_head != tofree_head) {
1016 dquot = list_entry(act_head, struct dquot, dq_free);
1017 act_head = act_head->next;
Jan Kara268157b2009-01-27 15:47:22 +01001018 /* Remove dquot from the list so we won't have problems... */
1019 list_del_init(&dquot->dq_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001020 dqput(dquot);
1021 }
1022}
1023
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001024static void remove_dquot_ref(struct super_block *sb, int type,
1025 struct list_head *tofree_head)
1026{
1027 struct inode *inode;
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001028 int reserved = 0;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001029
Dave Chinner55fa6092011-03-22 22:23:40 +11001030 spin_lock(&inode_sb_list_lock);
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001031 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Nick Pigginaabb8fd2009-03-11 13:17:36 -07001032 /*
1033 * We have to scan also I_NEW inodes because they can already
1034 * have quota pointer initialized. Luckily, we need to touch
1035 * only quota pointers and these have separate locking
1036 * (dqptr_sem).
1037 */
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001038 if (!IS_NOQUOTA(inode)) {
1039 if (unlikely(inode_get_rsv_space(inode) > 0))
1040 reserved = 1;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001041 remove_inode_dquot_ref(inode, type, tofree_head);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001042 }
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001043 }
Dave Chinner55fa6092011-03-22 22:23:40 +11001044 spin_unlock(&inode_sb_list_lock);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001045#ifdef CONFIG_QUOTA_DEBUG
1046 if (reserved) {
1047 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1048 " was disabled thus quota information is probably "
1049 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1050 }
1051#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001052}
1053
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054/* Gather all references from inodes and drop them */
1055static void drop_dquot_ref(struct super_block *sb, int type)
1056{
1057 LIST_HEAD(tofree_head);
1058
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001059 if (sb->dq_op) {
1060 down_write(&sb_dqopt(sb)->dqptr_sem);
1061 remove_dquot_ref(sb, type, &tofree_head);
1062 up_write(&sb_dqopt(sb)->dqptr_sem);
1063 put_dquot_list(&tofree_head);
1064 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065}
1066
Jan Kara12095462008-08-20 14:45:12 +02001067static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068{
1069 dquot->dq_dqb.dqb_curinodes += number;
1070}
1071
1072static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
1073{
1074 dquot->dq_dqb.dqb_curspace += number;
1075}
1076
Mingming Caof18df222009-01-13 16:43:09 +01001077static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
1078{
1079 dquot->dq_dqb.dqb_rsvspace += number;
1080}
1081
Mingming Cao740d9dc2009-01-13 16:43:14 +01001082/*
1083 * Claim reserved quota space
1084 */
Jan Kara0a5a9c72010-02-09 18:20:39 +01001085static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001086{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001087 if (dquot->dq_dqb.dqb_rsvspace < number) {
1088 WARN_ON_ONCE(1);
1089 number = dquot->dq_dqb.dqb_rsvspace;
1090 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001091 dquot->dq_dqb.dqb_curspace += number;
1092 dquot->dq_dqb.dqb_rsvspace -= number;
1093}
1094
1095static inline
1096void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1097{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001098 if (dquot->dq_dqb.dqb_rsvspace >= number)
1099 dquot->dq_dqb.dqb_rsvspace -= number;
1100 else {
1101 WARN_ON_ONCE(1);
1102 dquot->dq_dqb.dqb_rsvspace = 0;
1103 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001104}
1105
Jan Kara7a2435d2009-01-27 01:47:11 +01001106static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107{
Jan Karadb49d2d2008-10-01 18:21:39 +02001108 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1109 dquot->dq_dqb.dqb_curinodes >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001110 dquot->dq_dqb.dqb_curinodes -= number;
1111 else
1112 dquot->dq_dqb.dqb_curinodes = 0;
1113 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1114 dquot->dq_dqb.dqb_itime = (time_t) 0;
1115 clear_bit(DQ_INODES_B, &dquot->dq_flags);
1116}
1117
Jan Kara7a2435d2009-01-27 01:47:11 +01001118static void dquot_decr_space(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119{
Jan Karadb49d2d2008-10-01 18:21:39 +02001120 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1121 dquot->dq_dqb.dqb_curspace >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 dquot->dq_dqb.dqb_curspace -= number;
1123 else
1124 dquot->dq_dqb.dqb_curspace = 0;
Jan Kara12095462008-08-20 14:45:12 +02001125 if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001126 dquot->dq_dqb.dqb_btime = (time_t) 0;
1127 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1128}
1129
Jan Karabf097aa2012-02-14 13:28:01 +01001130struct dquot_warn {
1131 struct super_block *w_sb;
1132 qid_t w_dq_id;
1133 short w_dq_type;
1134 short w_type;
1135};
1136
Jan Karac5254602007-12-22 14:03:25 -08001137static int warning_issued(struct dquot *dquot, const int warntype)
1138{
1139 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1140 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1141 ((warntype == QUOTA_NL_IHARDWARN ||
1142 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1143
1144 if (!flag)
1145 return 0;
1146 return test_and_set_bit(flag, &dquot->dq_flags);
1147}
1148
Jan Kara8e893462007-10-16 23:29:31 -07001149#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001150static int flag_print_warnings = 1;
1151
Jan Karabf097aa2012-02-14 13:28:01 +01001152static int need_print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153{
1154 if (!flag_print_warnings)
1155 return 0;
1156
Jan Karabf097aa2012-02-14 13:28:01 +01001157 switch (warn->w_dq_type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 case USRQUOTA:
Jan Karabf097aa2012-02-14 13:28:01 +01001159 return current_fsuid() == warn->w_dq_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001160 case GRPQUOTA:
Jan Karabf097aa2012-02-14 13:28:01 +01001161 return in_group_p(warn->w_dq_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 }
1163 return 0;
1164}
1165
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166/* Print warning to user which exceeded quota */
Jan Karabf097aa2012-02-14 13:28:01 +01001167static void print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168{
1169 char *msg = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001170 struct tty_struct *tty;
Jan Karabf097aa2012-02-14 13:28:01 +01001171 int warntype = warn->w_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
Jan Kara657d3bf2008-07-25 01:46:52 -07001173 if (warntype == QUOTA_NL_IHARDBELOW ||
1174 warntype == QUOTA_NL_ISOFTBELOW ||
1175 warntype == QUOTA_NL_BHARDBELOW ||
Jan Karabf097aa2012-02-14 13:28:01 +01001176 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 return;
1178
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001179 tty = get_current_tty();
1180 if (!tty)
Alan Cox452a00d2008-10-13 10:39:13 +01001181 return;
Jan Karabf097aa2012-02-14 13:28:01 +01001182 tty_write_message(tty, warn->w_sb->s_id);
Jan Kara8e893462007-10-16 23:29:31 -07001183 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001184 tty_write_message(tty, ": warning, ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 else
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001186 tty_write_message(tty, ": write failed, ");
Jan Karabf097aa2012-02-14 13:28:01 +01001187 tty_write_message(tty, quotatypes[warn->w_dq_type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 switch (warntype) {
Jan Kara8e893462007-10-16 23:29:31 -07001189 case QUOTA_NL_IHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 msg = " file limit reached.\r\n";
1191 break;
Jan Kara8e893462007-10-16 23:29:31 -07001192 case QUOTA_NL_ISOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 msg = " file quota exceeded too long.\r\n";
1194 break;
Jan Kara8e893462007-10-16 23:29:31 -07001195 case QUOTA_NL_ISOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 msg = " file quota exceeded.\r\n";
1197 break;
Jan Kara8e893462007-10-16 23:29:31 -07001198 case QUOTA_NL_BHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 msg = " block limit reached.\r\n";
1200 break;
Jan Kara8e893462007-10-16 23:29:31 -07001201 case QUOTA_NL_BSOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 msg = " block quota exceeded too long.\r\n";
1203 break;
Jan Kara8e893462007-10-16 23:29:31 -07001204 case QUOTA_NL_BSOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 msg = " block quota exceeded.\r\n";
1206 break;
1207 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001208 tty_write_message(tty, msg);
Alan Cox452a00d2008-10-13 10:39:13 +01001209 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210}
Jan Kara8e893462007-10-16 23:29:31 -07001211#endif
1212
Jan Karabf097aa2012-02-14 13:28:01 +01001213static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1214 int warntype)
1215{
1216 if (warning_issued(dquot, warntype))
1217 return;
1218 warn->w_type = warntype;
1219 warn->w_sb = dquot->dq_sb;
1220 warn->w_dq_id = dquot->dq_id;
1221 warn->w_dq_type = dquot->dq_type;
1222}
1223
Mingming Caof18df222009-01-13 16:43:09 +01001224/*
1225 * Write warnings to the console and send warning messages over netlink.
1226 *
Jan Karabf097aa2012-02-14 13:28:01 +01001227 * Note that this function can call into tty and networking code.
Mingming Caof18df222009-01-13 16:43:09 +01001228 */
Jan Karabf097aa2012-02-14 13:28:01 +01001229static void flush_warnings(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230{
1231 int i;
1232
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001233 for (i = 0; i < MAXQUOTAS; i++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001234 if (warn[i].w_type == QUOTA_NL_NOWARN)
1235 continue;
Jan Kara8e893462007-10-16 23:29:31 -07001236#ifdef CONFIG_PRINT_QUOTA_WARNING
Jan Karabf097aa2012-02-14 13:28:01 +01001237 print_warning(&warn[i]);
Jan Kara8e893462007-10-16 23:29:31 -07001238#endif
Jan Karabf097aa2012-02-14 13:28:01 +01001239 quota_send_warning(warn[i].w_dq_type, warn[i].w_dq_id,
1240 warn[i].w_sb->s_dev, warn[i].w_type);
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001241 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242}
1243
Jan Kara7a2435d2009-01-27 01:47:11 +01001244static int ignore_hardlimit(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245{
1246 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];
1247
1248 return capable(CAP_SYS_RESOURCE) &&
Jan Kara268157b2009-01-27 15:47:22 +01001249 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1250 !(info->dqi_flags & V1_DQF_RSQUASH));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251}
1252
1253/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001254static int check_idq(struct dquot *dquot, qsize_t inodes,
1255 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256{
Jan Kara268157b2009-01-27 15:47:22 +01001257 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1258
Jan Karaf55abc02008-08-20 17:50:32 +02001259 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) ||
1260 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001261 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
1263 if (dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001264 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001266 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001267 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268 }
1269
1270 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001271 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1272 dquot->dq_dqb.dqb_itime &&
1273 get_seconds() >= dquot->dq_dqb.dqb_itime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001275 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001276 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 }
1278
1279 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001280 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281 dquot->dq_dqb.dqb_itime == 0) {
Jan Karabf097aa2012-02-14 13:28:01 +01001282 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001283 dquot->dq_dqb.dqb_itime = get_seconds() +
1284 sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 }
1286
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001287 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288}
1289
1290/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001291static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc,
1292 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293{
Mingming Caof18df222009-01-13 16:43:09 +01001294 qsize_t tspace;
Jan Kara268157b2009-01-27 15:47:22 +01001295 struct super_block *sb = dquot->dq_sb;
Mingming Caof18df222009-01-13 16:43:09 +01001296
Jan Kara268157b2009-01-27 15:47:22 +01001297 if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001298 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001299 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300
Mingming Caof18df222009-01-13 16:43:09 +01001301 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1302 + space;
1303
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304 if (dquot->dq_dqb.dqb_bhardlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001305 tspace > dquot->dq_dqb.dqb_bhardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 !ignore_hardlimit(dquot)) {
1307 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001308 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001309 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001310 }
1311
1312 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001313 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001314 dquot->dq_dqb.dqb_btime &&
1315 get_seconds() >= dquot->dq_dqb.dqb_btime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 !ignore_hardlimit(dquot)) {
1317 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001318 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001319 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001320 }
1321
1322 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001323 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 dquot->dq_dqb.dqb_btime == 0) {
1325 if (!prealloc) {
Jan Karabf097aa2012-02-14 13:28:01 +01001326 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001327 dquot->dq_dqb.dqb_btime = get_seconds() +
1328 sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001329 }
1330 else
1331 /*
1332 * We don't allow preallocation to exceed softlimit so exceeding will
1333 * be always printed
1334 */
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001335 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 }
1337
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001338 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001339}
1340
Jan Kara12095462008-08-20 14:45:12 +02001341static int info_idq_free(struct dquot *dquot, qsize_t inodes)
Jan Kara657d3bf2008-07-25 01:46:52 -07001342{
Jan Kara268157b2009-01-27 15:47:22 +01001343 qsize_t newinodes;
1344
Jan Kara657d3bf2008-07-25 01:46:52 -07001345 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001346 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
1347 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type))
Jan Kara657d3bf2008-07-25 01:46:52 -07001348 return QUOTA_NL_NOWARN;
1349
Jan Kara268157b2009-01-27 15:47:22 +01001350 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1351 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001352 return QUOTA_NL_ISOFTBELOW;
1353 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001354 newinodes < dquot->dq_dqb.dqb_ihardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001355 return QUOTA_NL_IHARDBELOW;
1356 return QUOTA_NL_NOWARN;
1357}
1358
1359static int info_bdq_free(struct dquot *dquot, qsize_t space)
1360{
1361 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Kara12095462008-08-20 14:45:12 +02001362 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001363 return QUOTA_NL_NOWARN;
1364
Jan Kara12095462008-08-20 14:45:12 +02001365 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001366 return QUOTA_NL_BSOFTBELOW;
Jan Kara12095462008-08-20 14:45:12 +02001367 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
1368 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001369 return QUOTA_NL_BHARDBELOW;
1370 return QUOTA_NL_NOWARN;
1371}
Jan Kara0a5a9c72010-02-09 18:20:39 +01001372
Christoph Hellwig189eef52010-06-04 10:56:29 +02001373static int dquot_active(const struct inode *inode)
1374{
1375 struct super_block *sb = inode->i_sb;
1376
1377 if (IS_NOQUOTA(inode))
1378 return 0;
1379 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1380}
1381
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382/*
Christoph Hellwig871a2932010-03-03 09:05:07 -05001383 * Initialize quota pointers in inode
1384 *
1385 * We do things in a bit complicated way but by that we avoid calling
1386 * dqget() and thus filesystem callbacks under dqptr_sem.
1387 *
1388 * It is better to call this function outside of any transaction as it
1389 * might need a lot of space in journal for dquot structure allocation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 */
Christoph Hellwig871a2932010-03-03 09:05:07 -05001391static void __dquot_initialize(struct inode *inode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392{
1393 unsigned int id = 0;
Christoph Hellwig871a2932010-03-03 09:05:07 -05001394 int cnt;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001395 struct dquot *got[MAXQUOTAS];
Jan Karacc334122009-01-12 17:23:05 +01001396 struct super_block *sb = inode->i_sb;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001397 qsize_t rsv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001398
Ingo Molnard3be9152006-03-23 03:00:29 -08001399 /* First test before acquiring mutex - solves deadlocks when we
1400 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001401 if (!dquot_active(inode))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001402 return;
Jan Karacc334122009-01-12 17:23:05 +01001403
1404 /* First get references to structures we might need. */
1405 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001406 got[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001407 if (type != -1 && cnt != type)
1408 continue;
1409 switch (cnt) {
1410 case USRQUOTA:
1411 id = inode->i_uid;
1412 break;
1413 case GRPQUOTA:
1414 id = inode->i_gid;
1415 break;
1416 }
1417 got[cnt] = dqget(sb, id, cnt);
1418 }
1419
1420 down_write(&sb_dqopt(sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 if (IS_NOQUOTA(inode))
1422 goto out_err;
1423 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1424 if (type != -1 && cnt != type)
1425 continue;
Jan Karacc334122009-01-12 17:23:05 +01001426 /* Avoid races with quotaoff() */
1427 if (!sb_has_quota_active(sb, cnt))
1428 continue;
Jan Kara4408ea42010-10-19 00:24:21 +02001429 /* We could race with quotaon or dqget() could have failed */
1430 if (!got[cnt])
1431 continue;
Jan Karadd6f3c62009-01-26 16:01:43 +01001432 if (!inode->i_dquot[cnt]) {
Jan Karacc334122009-01-12 17:23:05 +01001433 inode->i_dquot[cnt] = got[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001434 got[cnt] = NULL;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001435 /*
1436 * Make quota reservation system happy if someone
1437 * did a write before quota was turned on
1438 */
1439 rsv = inode_get_rsv_space(inode);
1440 if (unlikely(rsv))
1441 dquot_resv_space(inode->i_dquot[cnt], rsv);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 }
1443 }
1444out_err:
Jan Karacc334122009-01-12 17:23:05 +01001445 up_write(&sb_dqopt(sb)->dqptr_sem);
1446 /* Drop unused references */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001447 dqput_all(got);
Christoph Hellwig871a2932010-03-03 09:05:07 -05001448}
1449
1450void dquot_initialize(struct inode *inode)
1451{
1452 __dquot_initialize(inode, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001453}
Mingming Cao08d03502009-01-14 16:19:32 +01001454EXPORT_SYMBOL(dquot_initialize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
1456/*
1457 * Release all quotas referenced by inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05001459static void __dquot_drop(struct inode *inode)
Jan Kara3d9ea252008-10-10 16:12:23 +02001460{
Jan Karacc334122009-01-12 17:23:05 +01001461 int cnt;
1462 struct dquot *put[MAXQUOTAS];
1463
Jan Kara3d9ea252008-10-10 16:12:23 +02001464 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001465 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1466 put[cnt] = inode->i_dquot[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001467 inode->i_dquot[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001468 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001470 dqput_all(put);
Christoph Hellwig9f754752010-03-03 09:05:05 -05001471}
1472
1473void dquot_drop(struct inode *inode)
1474{
1475 int cnt;
1476
1477 if (IS_NOQUOTA(inode))
1478 return;
1479
1480 /*
1481 * Test before calling to rule out calls from proc and such
1482 * where we are not allowed to block. Note that this is
1483 * actually reliable test even without the lock - the caller
1484 * must assure that nobody can come after the DQUOT_DROP and
1485 * add quota pointers back anyway.
1486 */
1487 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1488 if (inode->i_dquot[cnt])
1489 break;
1490 }
1491
1492 if (cnt < MAXQUOTAS)
1493 __dquot_drop(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494}
Mingming Cao08d03502009-01-14 16:19:32 +01001495EXPORT_SYMBOL(dquot_drop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
1497/*
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001498 * inode_reserved_space is managed internally by quota, and protected by
1499 * i_lock similar to i_blocks+i_bytes.
1500 */
1501static qsize_t *inode_reserved_space(struct inode * inode)
1502{
1503 /* Filesystem must explicitly define it's own method in order to use
1504 * quota reservation interface */
1505 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1506 return inode->i_sb->dq_op->get_reserved_space(inode);
1507}
1508
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001509void inode_add_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001510{
1511 spin_lock(&inode->i_lock);
1512 *inode_reserved_space(inode) += number;
1513 spin_unlock(&inode->i_lock);
1514}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001515EXPORT_SYMBOL(inode_add_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001516
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001517void inode_claim_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001518{
1519 spin_lock(&inode->i_lock);
1520 *inode_reserved_space(inode) -= number;
1521 __inode_add_bytes(inode, number);
1522 spin_unlock(&inode->i_lock);
1523}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001524EXPORT_SYMBOL(inode_claim_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001525
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001526void inode_sub_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001527{
1528 spin_lock(&inode->i_lock);
1529 *inode_reserved_space(inode) -= number;
1530 spin_unlock(&inode->i_lock);
1531}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001532EXPORT_SYMBOL(inode_sub_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001533
1534static qsize_t inode_get_rsv_space(struct inode *inode)
1535{
1536 qsize_t ret;
Jan Kara05b5d892010-01-06 18:03:36 +01001537
1538 if (!inode->i_sb->dq_op->get_reserved_space)
1539 return 0;
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001540 spin_lock(&inode->i_lock);
1541 ret = *inode_reserved_space(inode);
1542 spin_unlock(&inode->i_lock);
1543 return ret;
1544}
1545
1546static void inode_incr_space(struct inode *inode, qsize_t number,
1547 int reserve)
1548{
1549 if (reserve)
1550 inode_add_rsv_space(inode, number);
1551 else
1552 inode_add_bytes(inode, number);
1553}
1554
1555static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1556{
1557 if (reserve)
1558 inode_sub_rsv_space(inode, number);
1559 else
1560 inode_sub_bytes(inode, number);
1561}
1562
1563/*
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001564 * This functions updates i_blocks+i_bytes fields and quota information
1565 * (together with appropriate checks).
1566 *
1567 * NOTE: We absolutely rely on the fact that caller dirties the inode
1568 * (usually helpers in quotaops.h care about this) and holds a handle for
1569 * the current transaction so that dquot write and inode write go into the
1570 * same transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001571 */
1572
1573/*
1574 * This operation can block, but only after everything is updated
1575 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001576int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577{
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001578 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001579 struct dquot_warn warn[MAXQUOTAS];
1580 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001581 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001583 /*
1584 * First test before acquiring mutex - solves deadlocks when we
1585 * re-enter the quota code and are already holding the mutex
1586 */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001587 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001588 inode_incr_space(inode, number, reserve);
1589 goto out;
1590 }
1591
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001593 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001594
Jeff Liu6ea2eea2012-07-18 12:12:41 +08001595 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596 spin_lock(&dq_data_lock);
1597 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001598 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001600 ret = check_bdq(dquots[cnt], number,
1601 !(flags & DQUOT_SPACE_WARN), &warn[cnt]);
1602 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001603 spin_unlock(&dq_data_lock);
1604 goto out_flush_warn;
Mingming Caof18df222009-01-13 16:43:09 +01001605 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 }
1607 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001608 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609 continue;
Mingming Caof18df222009-01-13 16:43:09 +01001610 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001611 dquot_resv_space(dquots[cnt], number);
Mingming Caof18df222009-01-13 16:43:09 +01001612 else
Jan Karabf097aa2012-02-14 13:28:01 +01001613 dquot_incr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001615 inode_incr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001617
1618 if (reserve)
1619 goto out_flush_warn;
Jan Karabf097aa2012-02-14 13:28:01 +01001620 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001621out_flush_warn:
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001622 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001623 flush_warnings(warn);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001624out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 return ret;
1626}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001627EXPORT_SYMBOL(__dquot_alloc_space);
Mingming Caof18df222009-01-13 16:43:09 +01001628
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629/*
1630 * This operation can block, but only after everything is updated
1631 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001632int dquot_alloc_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633{
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001634 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001635 struct dquot_warn warn[MAXQUOTAS];
1636 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
Ingo Molnard3be9152006-03-23 03:00:29 -08001638 /* First test before acquiring mutex - solves deadlocks when we
1639 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001640 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001641 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001643 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001645 spin_lock(&dq_data_lock);
1646 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001647 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001649 ret = check_idq(dquots[cnt], 1, &warn[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001650 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 goto warn_put_all;
1652 }
1653
1654 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001655 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001657 dquot_incr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 }
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001659
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660warn_put_all:
1661 spin_unlock(&dq_data_lock);
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001662 if (ret == 0)
Jan Karabf097aa2012-02-14 13:28:01 +01001663 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001665 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 return ret;
1667}
Mingming Cao08d03502009-01-14 16:19:32 +01001668EXPORT_SYMBOL(dquot_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001670/*
1671 * Convert in-memory reserved quotas to real consumed quotas
1672 */
1673int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001674{
1675 int cnt;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001676
Christoph Hellwig189eef52010-06-04 10:56:29 +02001677 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001678 inode_claim_rsv_space(inode, number);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001679 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001680 }
1681
1682 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001683 spin_lock(&dq_data_lock);
1684 /* Claim reserved quotas to allocated quotas */
1685 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001686 if (inode->i_dquot[cnt])
Mingming Cao740d9dc2009-01-13 16:43:14 +01001687 dquot_claim_reserved_space(inode->i_dquot[cnt],
1688 number);
1689 }
1690 /* Update inode bytes */
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001691 inode_claim_rsv_space(inode, number);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001692 spin_unlock(&dq_data_lock);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001693 mark_all_dquot_dirty(inode->i_dquot);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001694 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001695 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001696}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001697EXPORT_SYMBOL(dquot_claim_space_nodirty);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001698
1699/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001700 * This operation can block, but only after everything is updated
1701 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001702void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703{
1704 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001705 struct dquot_warn warn[MAXQUOTAS];
1706 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001707 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001708
Ingo Molnard3be9152006-03-23 03:00:29 -08001709 /* First test before acquiring mutex - solves deadlocks when we
1710 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001711 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001712 inode_decr_space(inode, number, reserve);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001713 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 }
Jan Kara657d3bf2008-07-25 01:46:52 -07001715
Linus Torvalds1da177e2005-04-16 15:20:36 -07001716 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 spin_lock(&dq_data_lock);
1718 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001719 int wtype;
1720
1721 warn[cnt].w_type = QUOTA_NL_NOWARN;
1722 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001724 wtype = info_bdq_free(dquots[cnt], number);
1725 if (wtype != QUOTA_NL_NOWARN)
1726 prepare_warning(&warn[cnt], dquots[cnt], wtype);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001727 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001728 dquot_free_reserved_space(dquots[cnt], number);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001729 else
Jan Karabf097aa2012-02-14 13:28:01 +01001730 dquot_decr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001732 inode_decr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001733 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001734
1735 if (reserve)
1736 goto out_unlock;
Jan Karabf097aa2012-02-14 13:28:01 +01001737 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001738out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001739 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001740 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001742EXPORT_SYMBOL(__dquot_free_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001743
1744/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001745 * This operation can block, but only after everything is updated
1746 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001747void dquot_free_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748{
1749 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001750 struct dquot_warn warn[MAXQUOTAS];
1751 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
Ingo Molnard3be9152006-03-23 03:00:29 -08001753 /* First test before acquiring mutex - solves deadlocks when we
1754 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001755 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001756 return;
Jan Kara657d3bf2008-07-25 01:46:52 -07001757
Linus Torvalds1da177e2005-04-16 15:20:36 -07001758 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 spin_lock(&dq_data_lock);
1760 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001761 int wtype;
1762
1763 warn[cnt].w_type = QUOTA_NL_NOWARN;
1764 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001766 wtype = info_idq_free(dquots[cnt], 1);
1767 if (wtype != QUOTA_NL_NOWARN)
1768 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1769 dquot_decr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 }
1771 spin_unlock(&dq_data_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01001772 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001773 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001774 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775}
Mingming Cao08d03502009-01-14 16:19:32 +01001776EXPORT_SYMBOL(dquot_free_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001777
1778/*
1779 * Transfer the number of inode and blocks from one diskquota to an other.
Jan Karabc8e5f02010-05-13 19:58:50 +02001780 * On success, dquot references in transfer_to are consumed and references
1781 * to original dquots that need to be released are placed there. On failure,
1782 * references are kept untouched.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 *
1784 * This operation can block, but only after everything is updated
1785 * A transaction must be started when entering this function.
Jan Karabc8e5f02010-05-13 19:58:50 +02001786 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787 */
Jan Karabc8e5f02010-05-13 19:58:50 +02001788int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789{
Mingming Cao740d9dc2009-01-13 16:43:14 +01001790 qsize_t space, cur_space;
1791 qsize_t rsv_space = 0;
Jan Karabc8e5f02010-05-13 19:58:50 +02001792 struct dquot *transfer_from[MAXQUOTAS] = {};
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001793 int cnt, ret = 0;
Dmitry9e327842010-10-09 23:15:30 +04001794 char is_valid[MAXQUOTAS] = {};
Jan Karabf097aa2012-02-14 13:28:01 +01001795 struct dquot_warn warn_to[MAXQUOTAS];
1796 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1797 struct dquot_warn warn_from_space[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798
Ingo Molnard3be9152006-03-23 03:00:29 -08001799 /* First test before acquiring mutex - solves deadlocks when we
1800 * re-enter the quota code and are already holding the mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 if (IS_NOQUOTA(inode))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001802 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001803 /* Initialize the arrays */
Jan Karabf097aa2012-02-14 13:28:01 +01001804 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1805 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1806 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1807 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1808 }
Jan Karacc334122009-01-12 17:23:05 +01001809 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001810 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
1811 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabc8e5f02010-05-13 19:58:50 +02001812 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001813 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814 spin_lock(&dq_data_lock);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001815 cur_space = inode_get_bytes(inode);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001816 rsv_space = inode_get_rsv_space(inode);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001817 space = cur_space + rsv_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 /* Build the transfer_from list and check the limits */
1819 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001820 /*
1821 * Skip changes for same uid or gid or for turned off quota-type.
1822 */
Jan Karadd6f3c62009-01-26 16:01:43 +01001823 if (!transfer_to[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 continue;
Dmitry9e327842010-10-09 23:15:30 +04001825 /* Avoid races with quotaoff() */
1826 if (!sb_has_quota_active(inode->i_sb, cnt))
1827 continue;
1828 is_valid[cnt] = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 transfer_from[cnt] = inode->i_dquot[cnt];
Jan Karabf097aa2012-02-14 13:28:01 +01001830 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001831 if (ret)
1832 goto over_quota;
Jan Karabf097aa2012-02-14 13:28:01 +01001833 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001834 if (ret)
Jan Karacc334122009-01-12 17:23:05 +01001835 goto over_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 }
1837
1838 /*
1839 * Finally perform the needed transfer from transfer_from to transfer_to
1840 */
1841 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001842 if (!is_valid[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 /* Due to IO error we might not have transfer_from[] structure */
1845 if (transfer_from[cnt]) {
Jan Karabf097aa2012-02-14 13:28:01 +01001846 int wtype;
1847 wtype = info_idq_free(transfer_from[cnt], 1);
1848 if (wtype != QUOTA_NL_NOWARN)
1849 prepare_warning(&warn_from_inodes[cnt],
1850 transfer_from[cnt], wtype);
1851 wtype = info_bdq_free(transfer_from[cnt], space);
1852 if (wtype != QUOTA_NL_NOWARN)
1853 prepare_warning(&warn_from_space[cnt],
1854 transfer_from[cnt], wtype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855 dquot_decr_inodes(transfer_from[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001856 dquot_decr_space(transfer_from[cnt], cur_space);
1857 dquot_free_reserved_space(transfer_from[cnt],
1858 rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 }
1860
1861 dquot_incr_inodes(transfer_to[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001862 dquot_incr_space(transfer_to[cnt], cur_space);
1863 dquot_resv_space(transfer_to[cnt], rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
1865 inode->i_dquot[cnt] = transfer_to[cnt];
1866 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 spin_unlock(&dq_data_lock);
Jan Karacc334122009-01-12 17:23:05 +01001868 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1869
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001870 mark_all_dquot_dirty(transfer_from);
1871 mark_all_dquot_dirty(transfer_to);
Jan Karabf097aa2012-02-14 13:28:01 +01001872 flush_warnings(warn_to);
1873 flush_warnings(warn_from_inodes);
1874 flush_warnings(warn_from_space);
Jan Karabc8e5f02010-05-13 19:58:50 +02001875 /* Pass back references to put */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001876 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Dmitry9e327842010-10-09 23:15:30 +04001877 if (is_valid[cnt])
1878 transfer_to[cnt] = transfer_from[cnt];
Jan Kara86f3cbe2010-10-11 15:22:21 +02001879 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001880over_quota:
1881 spin_unlock(&dq_data_lock);
1882 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001883 flush_warnings(warn_to);
Jan Kara86f3cbe2010-10-11 15:22:21 +02001884 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001885}
Jan Karabc8e5f02010-05-13 19:58:50 +02001886EXPORT_SYMBOL(__dquot_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001888/* Wrapper for transferring ownership of an inode for uid/gid only
1889 * Called from FSXXX_setattr()
1890 */
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001891int dquot_transfer(struct inode *inode, struct iattr *iattr)
Jan Karab85f4b82008-07-25 01:46:50 -07001892{
Jan Karabc8e5f02010-05-13 19:58:50 +02001893 struct dquot *transfer_to[MAXQUOTAS] = {};
1894 struct super_block *sb = inode->i_sb;
1895 int ret;
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001896
Christoph Hellwig189eef52010-06-04 10:56:29 +02001897 if (!dquot_active(inode))
Jan Karabc8e5f02010-05-13 19:58:50 +02001898 return 0;
Dmitry Monakhov12755622010-04-08 22:04:20 +04001899
Jan Karabc8e5f02010-05-13 19:58:50 +02001900 if (iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid)
1901 transfer_to[USRQUOTA] = dqget(sb, iattr->ia_uid, USRQUOTA);
1902 if (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)
Jan Kara4dea4962010-05-24 12:39:49 +02001903 transfer_to[GRPQUOTA] = dqget(sb, iattr->ia_gid, GRPQUOTA);
Jan Karabc8e5f02010-05-13 19:58:50 +02001904
1905 ret = __dquot_transfer(inode, transfer_to);
1906 dqput_all(transfer_to);
1907 return ret;
Jan Karab85f4b82008-07-25 01:46:50 -07001908}
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001909EXPORT_SYMBOL(dquot_transfer);
Jan Karab85f4b82008-07-25 01:46:50 -07001910
Linus Torvalds1da177e2005-04-16 15:20:36 -07001911/*
1912 * Write info of quota file to disk
1913 */
1914int dquot_commit_info(struct super_block *sb, int type)
1915{
1916 int ret;
1917 struct quota_info *dqopt = sb_dqopt(sb);
1918
Ingo Molnard3be9152006-03-23 03:00:29 -08001919 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 ret = dqopt->ops[type]->write_file_info(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08001921 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922 return ret;
1923}
Mingming Cao08d03502009-01-14 16:19:32 +01001924EXPORT_SYMBOL(dquot_commit_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925
1926/*
1927 * Definitions of diskquota operations.
1928 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -07001929const struct dquot_operations dquot_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 .write_dquot = dquot_commit,
1931 .acquire_dquot = dquot_acquire,
1932 .release_dquot = dquot_release,
1933 .mark_dirty = dquot_mark_dquot_dirty,
Jan Kara74f783a2008-08-19 14:51:22 +02001934 .write_info = dquot_commit_info,
1935 .alloc_dquot = dquot_alloc,
1936 .destroy_dquot = dquot_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937};
Christoph Hellwig123e9ca2010-05-19 07:16:44 -04001938EXPORT_SYMBOL(dquot_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940/*
Christoph Hellwig907f4552010-03-03 09:05:06 -05001941 * Generic helper for ->open on filesystems supporting disk quotas.
1942 */
1943int dquot_file_open(struct inode *inode, struct file *file)
1944{
1945 int error;
1946
1947 error = generic_file_open(inode, file);
1948 if (!error && (file->f_mode & FMODE_WRITE))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001949 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -05001950 return error;
1951}
1952EXPORT_SYMBOL(dquot_file_open);
1953
1954/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001955 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
1956 */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04001957int dquot_disable(struct super_block *sb, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001958{
Jan Kara0ff5af82008-04-28 02:14:33 -07001959 int cnt, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 struct quota_info *dqopt = sb_dqopt(sb);
1961 struct inode *toputinode[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962
Jan Karaf55abc02008-08-20 17:50:32 +02001963 /* Cannot turn off usage accounting without turning off limits, or
1964 * suspend quotas and simultaneously turn quotas off. */
1965 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
1966 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
1967 DQUOT_USAGE_ENABLED)))
1968 return -EINVAL;
1969
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 /* We need to serialize quota_off() for device */
Ingo Molnard3be9152006-03-23 03:00:29 -08001971 mutex_lock(&dqopt->dqonoff_mutex);
Jan Kara9377abd2008-05-12 14:02:08 -07001972
1973 /*
1974 * Skip everything if there's nothing to do. We have to do this because
1975 * sometimes we are called when fill_super() failed and calling
1976 * sync_fs() in such cases does no good.
1977 */
Jan Karaf55abc02008-08-20 17:50:32 +02001978 if (!sb_any_quota_loaded(sb)) {
Jan Kara9377abd2008-05-12 14:02:08 -07001979 mutex_unlock(&dqopt->dqonoff_mutex);
1980 return 0;
1981 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1983 toputinode[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001984 if (type != -1 && cnt != type)
1985 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02001986 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07001987 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02001988
1989 if (flags & DQUOT_SUSPENDED) {
Jan Karacc334122009-01-12 17:23:05 +01001990 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02001991 dqopt->flags |=
1992 dquot_state_flag(DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01001993 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02001994 } else {
Jan Karacc334122009-01-12 17:23:05 +01001995 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02001996 dqopt->flags &= ~dquot_state_flag(flags, cnt);
1997 /* Turning off suspended quotas? */
1998 if (!sb_has_quota_loaded(sb, cnt) &&
1999 sb_has_quota_suspended(sb, cnt)) {
2000 dqopt->flags &= ~dquot_state_flag(
2001 DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002002 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002003 iput(dqopt->files[cnt]);
2004 dqopt->files[cnt] = NULL;
2005 continue;
2006 }
Jan Karacc334122009-01-12 17:23:05 +01002007 spin_unlock(&dq_state_lock);
Jan Kara0ff5af82008-04-28 02:14:33 -07002008 }
Jan Karaf55abc02008-08-20 17:50:32 +02002009
2010 /* We still have to keep quota loaded? */
2011 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002012 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013
2014 /* Note: these are blocking operations */
2015 drop_dquot_ref(sb, cnt);
2016 invalidate_dquots(sb, cnt);
2017 /*
Jan Kara268157b2009-01-27 15:47:22 +01002018 * Now all dquots should be invalidated, all writes done so we
2019 * should be only users of the info. No locks needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 */
2021 if (info_dirty(&dqopt->info[cnt]))
2022 sb->dq_op->write_info(sb, cnt);
2023 if (dqopt->ops[cnt]->free_file_info)
2024 dqopt->ops[cnt]->free_file_info(sb, cnt);
2025 put_quota_format(dqopt->info[cnt].dqi_format);
2026
2027 toputinode[cnt] = dqopt->files[cnt];
Jan Karaf55abc02008-08-20 17:50:32 +02002028 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002029 dqopt->files[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 dqopt->info[cnt].dqi_flags = 0;
2031 dqopt->info[cnt].dqi_igrace = 0;
2032 dqopt->info[cnt].dqi_bgrace = 0;
2033 dqopt->ops[cnt] = NULL;
2034 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002035 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002036
2037 /* Skip syncing and setting flags if quota files are hidden */
2038 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2039 goto put_inodes;
2040
Linus Torvalds1da177e2005-04-16 15:20:36 -07002041 /* Sync the superblock so that buffers with quota data are written to
Al Viro7b7b1ac2005-11-07 17:13:39 -05002042 * disk (and so userspace sees correct data afterwards). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043 if (sb->s_op->sync_fs)
2044 sb->s_op->sync_fs(sb, 1);
2045 sync_blockdev(sb->s_bdev);
2046 /* Now the quota files are just ordinary files and we can set the
2047 * inode flags back. Moreover we discard the pagecache so that
2048 * userspace sees the writes we did bypassing the pagecache. We
2049 * must also discard the blockdev buffers so that we see the
2050 * changes done by userspace on the next quotaon() */
2051 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2052 if (toputinode[cnt]) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002053 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002054 /* If quota was reenabled in the meantime, we have
2055 * nothing to do */
Jan Karaf55abc02008-08-20 17:50:32 +02002056 if (!sb_has_quota_loaded(sb, cnt)) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002057 mutex_lock(&toputinode[cnt]->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002058 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
2059 S_NOATIME | S_NOQUOTA);
Jan Kara268157b2009-01-27 15:47:22 +01002060 truncate_inode_pages(&toputinode[cnt]->i_data,
2061 0);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002062 mutex_unlock(&toputinode[cnt]->i_mutex);
Jan Kara43d29322010-07-21 14:22:21 +02002063 mark_inode_dirty_sync(toputinode[cnt]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002064 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002065 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002066 }
2067 if (sb->s_bdev)
2068 invalidate_bdev(sb->s_bdev);
2069put_inodes:
2070 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2071 if (toputinode[cnt]) {
Jan Kara0ff5af82008-04-28 02:14:33 -07002072 /* On remount RO, we keep the inode pointer so that we
Jan Karaf55abc02008-08-20 17:50:32 +02002073 * can reenable quota on the subsequent remount RW. We
2074 * have to check 'flags' variable and not use sb_has_
2075 * function because another quotaon / quotaoff could
2076 * change global state before we got here. We refuse
2077 * to suspend quotas when there is pending delete on
2078 * the quota file... */
2079 if (!(flags & DQUOT_SUSPENDED))
Jan Kara0ff5af82008-04-28 02:14:33 -07002080 iput(toputinode[cnt]);
2081 else if (!toputinode[cnt]->i_nlink)
2082 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002084 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002085}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002086EXPORT_SYMBOL(dquot_disable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087
Christoph Hellwig287a8092010-05-19 07:16:45 -04002088int dquot_quota_off(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +02002089{
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002090 return dquot_disable(sb, type,
2091 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Jan Karaf55abc02008-08-20 17:50:32 +02002092}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002093EXPORT_SYMBOL(dquot_quota_off);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002094
Linus Torvalds1da177e2005-04-16 15:20:36 -07002095/*
2096 * Turn quotas on on a device
2097 */
2098
Jan Karaf55abc02008-08-20 17:50:32 +02002099/*
2100 * Helper function to turn quotas on when we already have the inode of
2101 * quota file and no quota information is loaded.
2102 */
2103static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2104 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105{
2106 struct quota_format_type *fmt = find_quota_format(format_id);
2107 struct super_block *sb = inode->i_sb;
2108 struct quota_info *dqopt = sb_dqopt(sb);
2109 int error;
2110 int oldflags = -1;
2111
2112 if (!fmt)
2113 return -ESRCH;
2114 if (!S_ISREG(inode->i_mode)) {
2115 error = -EACCES;
2116 goto out_fmt;
2117 }
2118 if (IS_RDONLY(inode)) {
2119 error = -EROFS;
2120 goto out_fmt;
2121 }
2122 if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
2123 error = -EINVAL;
2124 goto out_fmt;
2125 }
Jan Karaf55abc02008-08-20 17:50:32 +02002126 /* Usage always has to be set... */
2127 if (!(flags & DQUOT_USAGE_ENABLED)) {
2128 error = -EINVAL;
2129 goto out_fmt;
2130 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131
Jan Karaca785ec2008-09-30 17:53:37 +02002132 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
Jan Karaab94c392010-02-22 21:07:17 +01002133 /* As we bypass the pagecache we must now flush all the
2134 * dirty data and invalidate caches so that kernel sees
2135 * changes from userspace. It is not enough to just flush
2136 * the quota file since if blocksize < pagesize, invalidation
2137 * of the cache could fail because of other unrelated dirty
2138 * data */
2139 sync_filesystem(sb);
Jan Karaca785ec2008-09-30 17:53:37 +02002140 invalidate_bdev(sb->s_bdev);
2141 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002142 mutex_lock(&dqopt->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002143 if (sb_has_quota_loaded(sb, type)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 error = -EBUSY;
2145 goto out_lock;
2146 }
Jan Karaca785ec2008-09-30 17:53:37 +02002147
2148 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2149 /* We don't want quota and atime on quota files (deadlocks
2150 * possible) Also nobody should write to the file - we use
2151 * special IO operations which ignore the immutable bit. */
Jan Karaa80b12c2012-04-25 21:15:53 +02002152 mutex_lock(&inode->i_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002153 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2154 S_NOQUOTA);
Jan Karaca785ec2008-09-30 17:53:37 +02002155 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
Jan Karadee86562009-07-22 18:12:17 +02002156 mutex_unlock(&inode->i_mutex);
Jan Kara26245c92010-01-06 17:20:35 +01002157 /*
2158 * When S_NOQUOTA is set, remove dquot references as no more
2159 * references can be added
2160 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05002161 __dquot_drop(inode);
Jan Karaca785ec2008-09-30 17:53:37 +02002162 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163
2164 error = -EIO;
2165 dqopt->files[type] = igrab(inode);
2166 if (!dqopt->files[type])
2167 goto out_lock;
2168 error = -EINVAL;
2169 if (!fmt->qf_ops->check_quota_file(sb, type))
2170 goto out_file_init;
2171
2172 dqopt->ops[type] = fmt->qf_ops;
2173 dqopt->info[type].dqi_format = fmt;
Jan Kara0ff5af82008-04-28 02:14:33 -07002174 dqopt->info[type].dqi_fmt_id = format_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
Ingo Molnard3be9152006-03-23 03:00:29 -08002176 mutex_lock(&dqopt->dqio_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002177 error = dqopt->ops[type]->read_file_info(sb, type);
2178 if (error < 0) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002179 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180 goto out_file_init;
2181 }
Jan Kara46fe44c2011-11-16 15:03:59 +01002182 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2183 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
Ingo Molnard3be9152006-03-23 03:00:29 -08002184 mutex_unlock(&dqopt->dqio_mutex);
Jan Karacc334122009-01-12 17:23:05 +01002185 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002186 dqopt->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002187 spin_unlock(&dq_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002188
2189 add_dquot_ref(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08002190 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002191
2192 return 0;
2193
2194out_file_init:
2195 dqopt->files[type] = NULL;
2196 iput(inode);
2197out_lock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198 if (oldflags != -1) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002199 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200 /* Set the flags back (in the case of accidental quotaon()
2201 * on a wrong file we don't want to mess up the flags) */
2202 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2203 inode->i_flags |= oldflags;
Jan Karadee86562009-07-22 18:12:17 +02002204 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002205 }
Jiaying Zhangd01730d2009-07-07 18:15:21 +02002206 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002207out_fmt:
2208 put_quota_format(fmt);
2209
2210 return error;
2211}
2212
Jan Kara0ff5af82008-04-28 02:14:33 -07002213/* Reenable quotas on remount RW */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002214int dquot_resume(struct super_block *sb, int type)
Jan Kara0ff5af82008-04-28 02:14:33 -07002215{
2216 struct quota_info *dqopt = sb_dqopt(sb);
2217 struct inode *inode;
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002218 int ret = 0, cnt;
Jan Karaf55abc02008-08-20 17:50:32 +02002219 unsigned int flags;
Jan Kara0ff5af82008-04-28 02:14:33 -07002220
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002221 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2222 if (type != -1 && cnt != type)
2223 continue;
Jan Kara0ff5af82008-04-28 02:14:33 -07002224
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002225 mutex_lock(&dqopt->dqonoff_mutex);
2226 if (!sb_has_quota_suspended(sb, cnt)) {
2227 mutex_unlock(&dqopt->dqonoff_mutex);
2228 continue;
2229 }
2230 inode = dqopt->files[cnt];
2231 dqopt->files[cnt] = NULL;
2232 spin_lock(&dq_state_lock);
2233 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2234 DQUOT_LIMITS_ENABLED,
2235 cnt);
2236 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2237 spin_unlock(&dq_state_lock);
2238 mutex_unlock(&dqopt->dqonoff_mutex);
2239
2240 flags = dquot_generic_flag(flags, cnt);
2241 ret = vfs_load_quota_inode(inode, cnt,
2242 dqopt->info[cnt].dqi_fmt_id, flags);
2243 iput(inode);
2244 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002245
2246 return ret;
2247}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002248EXPORT_SYMBOL(dquot_resume);
Jan Kara0ff5af82008-04-28 02:14:33 -07002249
Jan Karaf00c9e42010-09-15 17:38:58 +02002250int dquot_quota_on(struct super_block *sb, int type, int format_id,
2251 struct path *path)
Al Viro77e69da2008-08-01 04:29:18 -04002252{
2253 int error = security_quota_on(path->dentry);
2254 if (error)
2255 return error;
2256 /* Quota file not on the same filesystem? */
Al Virod8c95842011-12-07 18:16:57 -05002257 if (path->dentry->d_sb != sb)
Al Viro77e69da2008-08-01 04:29:18 -04002258 error = -EXDEV;
2259 else
Jan Karaf55abc02008-08-20 17:50:32 +02002260 error = vfs_load_quota_inode(path->dentry->d_inode, type,
2261 format_id, DQUOT_USAGE_ENABLED |
2262 DQUOT_LIMITS_ENABLED);
Al Viro77e69da2008-08-01 04:29:18 -04002263 return error;
2264}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002265EXPORT_SYMBOL(dquot_quota_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266
2267/*
Jan Karaf55abc02008-08-20 17:50:32 +02002268 * More powerful function for turning on quotas allowing setting
2269 * of individual quota flags
2270 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002271int dquot_enable(struct inode *inode, int type, int format_id,
2272 unsigned int flags)
Jan Karaf55abc02008-08-20 17:50:32 +02002273{
2274 int ret = 0;
2275 struct super_block *sb = inode->i_sb;
2276 struct quota_info *dqopt = sb_dqopt(sb);
2277
2278 /* Just unsuspend quotas? */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002279 BUG_ON(flags & DQUOT_SUSPENDED);
2280
Jan Karaf55abc02008-08-20 17:50:32 +02002281 if (!flags)
2282 return 0;
2283 /* Just updating flags needed? */
2284 if (sb_has_quota_loaded(sb, type)) {
2285 mutex_lock(&dqopt->dqonoff_mutex);
2286 /* Now do a reliable test... */
2287 if (!sb_has_quota_loaded(sb, type)) {
2288 mutex_unlock(&dqopt->dqonoff_mutex);
2289 goto load_quota;
2290 }
2291 if (flags & DQUOT_USAGE_ENABLED &&
2292 sb_has_quota_usage_enabled(sb, type)) {
2293 ret = -EBUSY;
2294 goto out_lock;
2295 }
2296 if (flags & DQUOT_LIMITS_ENABLED &&
2297 sb_has_quota_limits_enabled(sb, type)) {
2298 ret = -EBUSY;
2299 goto out_lock;
2300 }
Jan Karacc334122009-01-12 17:23:05 +01002301 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002302 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002303 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002304out_lock:
2305 mutex_unlock(&dqopt->dqonoff_mutex);
2306 return ret;
2307 }
2308
2309load_quota:
2310 return vfs_load_quota_inode(inode, type, format_id, flags);
2311}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002312EXPORT_SYMBOL(dquot_enable);
Jan Karaf55abc02008-08-20 17:50:32 +02002313
2314/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002315 * This function is used when filesystem needs to initialize quotas
2316 * during mount time.
2317 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002318int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Christoph Hellwig84de8562005-06-23 00:09:16 -07002319 int format_id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002320{
Christoph Hellwig84de8562005-06-23 00:09:16 -07002321 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002322 int error;
2323
Jan Karac56818d2009-11-12 15:42:08 +01002324 mutex_lock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig2fa389c2005-06-23 00:09:16 -07002325 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
Jan Karac56818d2009-11-12 15:42:08 +01002326 mutex_unlock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002327 if (IS_ERR(dentry))
2328 return PTR_ERR(dentry);
2329
Jan Kara154f4842005-11-28 13:44:14 -08002330 if (!dentry->d_inode) {
2331 error = -ENOENT;
2332 goto out;
2333 }
2334
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335 error = security_quota_on(dentry);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002336 if (!error)
Jan Karaf55abc02008-08-20 17:50:32 +02002337 error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
2338 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002339
Jan Kara154f4842005-11-28 13:44:14 -08002340out:
Christoph Hellwig84de8562005-06-23 00:09:16 -07002341 dput(dentry);
2342 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002343}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002344EXPORT_SYMBOL(dquot_quota_on_mount);
Jan Karab85f4b82008-07-25 01:46:50 -07002345
Jan Kara12095462008-08-20 14:45:12 +02002346static inline qsize_t qbtos(qsize_t blocks)
2347{
2348 return blocks << QIF_DQBLKSIZE_BITS;
2349}
2350
2351static inline qsize_t stoqb(qsize_t space)
2352{
2353 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
2354}
2355
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356/* Generic routine for getting common part of quota structure */
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002357static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358{
2359 struct mem_dqblk *dm = &dquot->dq_dqb;
2360
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002361 memset(di, 0, sizeof(*di));
2362 di->d_version = FS_DQUOT_VERSION;
2363 di->d_flags = dquot->dq_type == USRQUOTA ?
Christoph Hellwigade7ce32010-06-04 10:56:01 +02002364 FS_USER_QUOTA : FS_GROUP_QUOTA;
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002365 di->d_id = dquot->dq_id;
2366
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367 spin_lock(&dq_data_lock);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002368 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
2369 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
2370 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2371 di->d_ino_softlimit = dm->dqb_isoftlimit;
2372 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
2373 di->d_icount = dm->dqb_curinodes;
2374 di->d_btimer = dm->dqb_btime;
2375 di->d_itimer = dm->dqb_itime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002376 spin_unlock(&dq_data_lock);
2377}
2378
Christoph Hellwig287a8092010-05-19 07:16:45 -04002379int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
2380 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381{
2382 struct dquot *dquot;
2383
Jan Karacc334122009-01-12 17:23:05 +01002384 dquot = dqget(sb, id, type);
Jan Karadd6f3c62009-01-26 16:01:43 +01002385 if (!dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386 return -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002387 do_get_dqblk(dquot, di);
2388 dqput(dquot);
Jan Karacc334122009-01-12 17:23:05 +01002389
Linus Torvalds1da177e2005-04-16 15:20:36 -07002390 return 0;
2391}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002392EXPORT_SYMBOL(dquot_get_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002393
Christoph Hellwigc472b432010-05-06 17:05:17 -04002394#define VFS_FS_DQ_MASK \
2395 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
2396 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
2397 FS_DQ_BTIMER | FS_DQ_ITIMER)
2398
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399/* Generic routine for setting common part of quota structure */
Christoph Hellwigc472b432010-05-06 17:05:17 -04002400static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401{
2402 struct mem_dqblk *dm = &dquot->dq_dqb;
2403 int check_blim = 0, check_ilim = 0;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002404 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];
2405
Christoph Hellwigc472b432010-05-06 17:05:17 -04002406 if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
2407 return -EINVAL;
2408
2409 if (((di->d_fieldmask & FS_DQ_BSOFT) &&
2410 (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
2411 ((di->d_fieldmask & FS_DQ_BHARD) &&
2412 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
2413 ((di->d_fieldmask & FS_DQ_ISOFT) &&
2414 (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
2415 ((di->d_fieldmask & FS_DQ_IHARD) &&
2416 (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002417 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002418
2419 spin_lock(&dq_data_lock);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002420 if (di->d_fieldmask & FS_DQ_BCOUNT) {
2421 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002423 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002425
2426 if (di->d_fieldmask & FS_DQ_BSOFT)
2427 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
2428 if (di->d_fieldmask & FS_DQ_BHARD)
2429 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
2430 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002431 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002432 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002434
2435 if (di->d_fieldmask & FS_DQ_ICOUNT) {
2436 dm->dqb_curinodes = di->d_icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002437 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002438 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002440
2441 if (di->d_fieldmask & FS_DQ_ISOFT)
2442 dm->dqb_isoftlimit = di->d_ino_softlimit;
2443 if (di->d_fieldmask & FS_DQ_IHARD)
2444 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2445 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002447 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002448 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002449
2450 if (di->d_fieldmask & FS_DQ_BTIMER) {
2451 dm->dqb_btime = di->d_btimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002452 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002453 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002454 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002455
2456 if (di->d_fieldmask & FS_DQ_ITIMER) {
2457 dm->dqb_itime = di->d_itimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002458 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002459 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002460 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461
2462 if (check_blim) {
Jan Kara268157b2009-01-27 15:47:22 +01002463 if (!dm->dqb_bsoftlimit ||
2464 dm->dqb_curspace < dm->dqb_bsoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 dm->dqb_btime = 0;
2466 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002467 } else if (!(di->d_fieldmask & FS_DQ_BTIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002468 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002469 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002470 }
2471 if (check_ilim) {
Jan Kara268157b2009-01-27 15:47:22 +01002472 if (!dm->dqb_isoftlimit ||
2473 dm->dqb_curinodes < dm->dqb_isoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 dm->dqb_itime = 0;
2475 clear_bit(DQ_INODES_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002476 } else if (!(di->d_fieldmask & FS_DQ_ITIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002477 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002478 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002479 }
Jan Kara268157b2009-01-27 15:47:22 +01002480 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2481 dm->dqb_isoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2483 else
2484 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2485 spin_unlock(&dq_data_lock);
2486 mark_dquot_dirty(dquot);
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002487
2488 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489}
2490
Christoph Hellwig287a8092010-05-19 07:16:45 -04002491int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
Christoph Hellwigc472b432010-05-06 17:05:17 -04002492 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002493{
2494 struct dquot *dquot;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002495 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002496
Jan Karaf55abc02008-08-20 17:50:32 +02002497 dquot = dqget(sb, id, type);
2498 if (!dquot) {
2499 rc = -ESRCH;
2500 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 }
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002502 rc = do_set_dqblk(dquot, di);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 dqput(dquot);
Jan Karaf55abc02008-08-20 17:50:32 +02002504out:
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002505 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002506}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002507EXPORT_SYMBOL(dquot_set_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508
2509/* Generic routine for getting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002510int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511{
2512 struct mem_dqinfo *mi;
2513
Ingo Molnard3be9152006-03-23 03:00:29 -08002514 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002515 if (!sb_has_quota_active(sb, type)) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002516 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 return -ESRCH;
2518 }
2519 mi = sb_dqopt(sb)->info + type;
2520 spin_lock(&dq_data_lock);
2521 ii->dqi_bgrace = mi->dqi_bgrace;
2522 ii->dqi_igrace = mi->dqi_igrace;
Jan Kara46fe44c2011-11-16 15:03:59 +01002523 ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002524 ii->dqi_valid = IIF_ALL;
2525 spin_unlock(&dq_data_lock);
Ingo Molnard3be9152006-03-23 03:00:29 -08002526 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 return 0;
2528}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002529EXPORT_SYMBOL(dquot_get_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002530
2531/* Generic routine for setting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002532int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002533{
2534 struct mem_dqinfo *mi;
Jan Karaf55abc02008-08-20 17:50:32 +02002535 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536
Ingo Molnard3be9152006-03-23 03:00:29 -08002537 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002538 if (!sb_has_quota_active(sb, type)) {
2539 err = -ESRCH;
2540 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002541 }
2542 mi = sb_dqopt(sb)->info + type;
2543 spin_lock(&dq_data_lock);
2544 if (ii->dqi_valid & IIF_BGRACE)
2545 mi->dqi_bgrace = ii->dqi_bgrace;
2546 if (ii->dqi_valid & IIF_IGRACE)
2547 mi->dqi_igrace = ii->dqi_igrace;
2548 if (ii->dqi_valid & IIF_FLAGS)
Jan Kara46fe44c2011-11-16 15:03:59 +01002549 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) |
2550 (ii->dqi_flags & DQF_SETINFO_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551 spin_unlock(&dq_data_lock);
2552 mark_info_dirty(sb, type);
2553 /* Force write to disk */
2554 sb->dq_op->write_info(sb, type);
Jan Karaf55abc02008-08-20 17:50:32 +02002555out:
Ingo Molnard3be9152006-03-23 03:00:29 -08002556 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002557 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002558}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002559EXPORT_SYMBOL(dquot_set_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560
Christoph Hellwig287a8092010-05-19 07:16:45 -04002561const struct quotactl_ops dquot_quotactl_ops = {
2562 .quota_on = dquot_quota_on,
2563 .quota_off = dquot_quota_off,
2564 .quota_sync = dquot_quota_sync,
2565 .get_info = dquot_get_dqinfo,
2566 .set_info = dquot_set_dqinfo,
2567 .get_dqblk = dquot_get_dqblk,
2568 .set_dqblk = dquot_set_dqblk
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569};
Christoph Hellwig287a8092010-05-19 07:16:45 -04002570EXPORT_SYMBOL(dquot_quotactl_ops);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002571
2572static int do_proc_dqstats(struct ctl_table *table, int write,
2573 void __user *buffer, size_t *lenp, loff_t *ppos)
2574{
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002575 unsigned int type = (int *)table->data - dqstats.stat;
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002576
2577 /* Update global table */
2578 dqstats.stat[type] =
2579 percpu_counter_sum_positive(&dqstats.counter[type]);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002580 return proc_dointvec(table, write, buffer, lenp, ppos);
2581}
2582
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583static ctl_table fs_dqstats_table[] = {
2584 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585 .procname = "lookups",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002586 .data = &dqstats.stat[DQST_LOOKUPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002587 .maxlen = sizeof(int),
2588 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002589 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590 },
2591 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002592 .procname = "drops",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002593 .data = &dqstats.stat[DQST_DROPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 .maxlen = sizeof(int),
2595 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002596 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002597 },
2598 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599 .procname = "reads",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002600 .data = &dqstats.stat[DQST_READS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601 .maxlen = sizeof(int),
2602 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002603 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 },
2605 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002606 .procname = "writes",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002607 .data = &dqstats.stat[DQST_WRITES],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002608 .maxlen = sizeof(int),
2609 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002610 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 },
2612 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613 .procname = "cache_hits",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002614 .data = &dqstats.stat[DQST_CACHE_HITS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002615 .maxlen = sizeof(int),
2616 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002617 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618 },
2619 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 .procname = "allocated_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002621 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 .maxlen = sizeof(int),
2623 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002624 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002625 },
2626 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 .procname = "free_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002628 .data = &dqstats.stat[DQST_FREE_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002629 .maxlen = sizeof(int),
2630 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002631 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002632 },
2633 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002634 .procname = "syncs",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002635 .data = &dqstats.stat[DQST_SYNCS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 .maxlen = sizeof(int),
2637 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002638 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002639 },
Jan Kara8e893462007-10-16 23:29:31 -07002640#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07002641 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 .procname = "warnings",
2643 .data = &flag_print_warnings,
2644 .maxlen = sizeof(int),
2645 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08002646 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 },
Jan Kara8e893462007-10-16 23:29:31 -07002648#endif
Eric W. Biedermanab092032009-11-05 14:25:10 -08002649 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650};
2651
2652static ctl_table fs_table[] = {
2653 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 .procname = "quota",
2655 .mode = 0555,
2656 .child = fs_dqstats_table,
2657 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002658 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659};
2660
2661static ctl_table sys_table[] = {
2662 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663 .procname = "fs",
2664 .mode = 0555,
2665 .child = fs_table,
2666 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002667 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668};
2669
2670static int __init dquot_init(void)
2671{
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002672 int i, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 unsigned long nr_hash, order;
2674
2675 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2676
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08002677 register_sysctl_table(sys_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678
Paul Mundt20c2df82007-07-20 10:11:58 +09002679 dquot_cachep = kmem_cache_create("dquot",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 sizeof(struct dquot), sizeof(unsigned long) * 4,
Paul Jacksonfffb60f2006-03-24 03:16:06 -08002681 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2682 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +09002683 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684
2685 order = 0;
2686 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2687 if (!dquot_hash)
2688 panic("Cannot create dquot hash table");
2689
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002690 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2691 ret = percpu_counter_init(&dqstats.counter[i], 0);
2692 if (ret)
2693 panic("Cannot create dquot stat counters");
2694 }
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002695
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 /* Find power-of-two hlist_heads which can fit into allocation */
2697 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2698 dq_hash_bits = 0;
2699 do {
2700 dq_hash_bits++;
2701 } while (nr_hash >> dq_hash_bits);
2702 dq_hash_bits--;
2703
2704 nr_hash = 1UL << dq_hash_bits;
2705 dq_hash_mask = nr_hash - 1;
2706 for (i = 0; i < nr_hash; i++)
2707 INIT_HLIST_HEAD(dquot_hash + i);
2708
2709 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2710 nr_hash, order, (PAGE_SIZE << order));
2711
Rusty Russell8e1f9362007-07-17 04:03:17 -07002712 register_shrinker(&dqcache_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713
Linus Torvalds1da177e2005-04-16 15:20:36 -07002714 return 0;
2715}
2716module_init(dquot_init);