blob: 831d49a4111f8405716d96ff6a451fc9ebd59e91 [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
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700256hashfn(const struct super_block *sb, struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257{
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700258 unsigned int id = from_kqid(&init_user_ns, qid);
259 int type = qid.type;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700260 unsigned long tmp;
261
262 tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
263 return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
264}
265
266/*
267 * Following list functions expect dq_list_lock to be held
268 */
269static inline void insert_dquot_hash(struct dquot *dquot)
270{
Jan Kara268157b2009-01-27 15:47:22 +0100271 struct hlist_head *head;
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700272 head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 hlist_add_head(&dquot->dq_hash, head);
274}
275
276static inline void remove_dquot_hash(struct dquot *dquot)
277{
278 hlist_del_init(&dquot->dq_hash);
279}
280
Jan Kara7a2435d2009-01-27 01:47:11 +0100281static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700282 struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283{
284 struct hlist_node *node;
285 struct dquot *dquot;
286
287 hlist_for_each (node, dquot_hash+hashent) {
288 dquot = hlist_entry(node, struct dquot, dq_hash);
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700289 if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700290 return dquot;
291 }
Jan Karadd6f3c62009-01-26 16:01:43 +0100292 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293}
294
295/* Add a dquot to the tail of the free list */
296static inline void put_dquot_last(struct dquot *dquot)
297{
Akinobu Mita8e130592006-06-26 00:24:37 -0700298 list_add_tail(&dquot->dq_free, &free_dquots);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400299 dqstats_inc(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300}
301
302static inline void remove_free_dquot(struct dquot *dquot)
303{
304 if (list_empty(&dquot->dq_free))
305 return;
306 list_del_init(&dquot->dq_free);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400307 dqstats_dec(DQST_FREE_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308}
309
310static inline void put_inuse(struct dquot *dquot)
311{
312 /* We add to the back of inuse list so we don't have to restart
313 * when traversing this list and we block */
Akinobu Mita8e130592006-06-26 00:24:37 -0700314 list_add_tail(&dquot->dq_inuse, &inuse_list);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400315 dqstats_inc(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700316}
317
318static inline void remove_inuse(struct dquot *dquot)
319{
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400320 dqstats_dec(DQST_ALLOC_DQUOTS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 list_del(&dquot->dq_inuse);
322}
323/*
324 * End of list functions needing dq_list_lock
325 */
326
327static void wait_on_dquot(struct dquot *dquot)
328{
Ingo Molnard3be9152006-03-23 03:00:29 -0800329 mutex_lock(&dquot->dq_lock);
330 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331}
332
Jan Kara03f6e922008-04-28 02:14:32 -0700333static inline int dquot_dirty(struct dquot *dquot)
334{
335 return test_bit(DQ_MOD_B, &dquot->dq_flags);
336}
337
338static inline int mark_dquot_dirty(struct dquot *dquot)
339{
340 return dquot->dq_sb->dq_op->mark_dirty(dquot);
341}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700342
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300343/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344int dquot_mark_dquot_dirty(struct dquot *dquot)
345{
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300346 int ret = 1;
347
348 /* If quota is dirty already, we don't have to acquire dq_list_lock */
349 if (test_bit(DQ_MOD_B, &dquot->dq_flags))
350 return 1;
351
Linus Torvalds1da177e2005-04-16 15:20:36 -0700352 spin_lock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300353 if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700354 list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700355 info[dquot->dq_id.type].dqi_dirty_list);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300356 ret = 0;
357 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700358 spin_unlock(&dq_list_lock);
Dmitry Monakhoveabf2902010-03-27 15:15:38 +0300359 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360}
Mingming Cao08d03502009-01-14 16:19:32 +0100361EXPORT_SYMBOL(dquot_mark_dquot_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +0300363/* Dirtify all the dquots - this can block when journalling */
364static inline int mark_all_dquot_dirty(struct dquot * const *dquot)
365{
366 int ret, err, cnt;
367
368 ret = err = 0;
369 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
370 if (dquot[cnt])
371 /* Even in case of error we have to continue */
372 ret = mark_dquot_dirty(dquot[cnt]);
373 if (!err)
374 err = ret;
375 }
376 return err;
377}
378
379static inline void dqput_all(struct dquot **dquot)
380{
381 unsigned int cnt;
382
383 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
384 dqput(dquot[cnt]);
385}
386
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387/* This function needs dq_list_lock */
388static inline int clear_dquot_dirty(struct dquot *dquot)
389{
390 if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags))
391 return 0;
392 list_del_init(&dquot->dq_dirty);
393 return 1;
394}
395
396void mark_info_dirty(struct super_block *sb, int type)
397{
398 set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags);
399}
400EXPORT_SYMBOL(mark_info_dirty);
401
402/*
403 * Read dquot from disk and alloc space for it
404 */
405
406int dquot_acquire(struct dquot *dquot)
407{
408 int ret = 0, ret2 = 0;
409 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
410
Ingo Molnard3be9152006-03-23 03:00:29 -0800411 mutex_lock(&dquot->dq_lock);
412 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 if (!test_bit(DQ_READ_B, &dquot->dq_flags))
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700414 ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (ret < 0)
416 goto out_iolock;
417 set_bit(DQ_READ_B, &dquot->dq_flags);
418 /* Instantiate dquot if needed */
419 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700420 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 /* Write the info if needed */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700422 if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
423 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
424 dquot->dq_sb, dquot->dq_id.type);
Jan Kara268157b2009-01-27 15:47:22 +0100425 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 if (ret < 0)
427 goto out_iolock;
428 if (ret2 < 0) {
429 ret = ret2;
430 goto out_iolock;
431 }
432 }
433 set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
434out_iolock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800435 mutex_unlock(&dqopt->dqio_mutex);
436 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437 return ret;
438}
Mingming Cao08d03502009-01-14 16:19:32 +0100439EXPORT_SYMBOL(dquot_acquire);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440
441/*
442 * Write dquot to disk
443 */
444int dquot_commit(struct dquot *dquot)
445{
Jan Karab03f2452011-03-31 18:36:52 +0200446 int ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
448
Ingo Molnard3be9152006-03-23 03:00:29 -0800449 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 spin_lock(&dq_list_lock);
451 if (!clear_dquot_dirty(dquot)) {
452 spin_unlock(&dq_list_lock);
453 goto out_sem;
454 }
455 spin_unlock(&dq_list_lock);
456 /* Inactive dquot can be only if there was error during read/init
457 * => we have better not writing it */
Jan Karab03f2452011-03-31 18:36:52 +0200458 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700459 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
Jan Karab03f2452011-03-31 18:36:52 +0200460 else
461 ret = -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462out_sem:
Ingo Molnard3be9152006-03-23 03:00:29 -0800463 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464 return ret;
465}
Mingming Cao08d03502009-01-14 16:19:32 +0100466EXPORT_SYMBOL(dquot_commit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467
468/*
469 * Release dquot
470 */
471int dquot_release(struct dquot *dquot)
472{
473 int ret = 0, ret2 = 0;
474 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
475
Ingo Molnard3be9152006-03-23 03:00:29 -0800476 mutex_lock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 /* Check whether we are not racing with some other dqget() */
478 if (atomic_read(&dquot->dq_count) > 1)
479 goto out_dqlock;
Ingo Molnard3be9152006-03-23 03:00:29 -0800480 mutex_lock(&dqopt->dqio_mutex);
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700481 if (dqopt->ops[dquot->dq_id.type]->release_dqblk) {
482 ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483 /* Write the info */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700484 if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
485 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
486 dquot->dq_sb, dquot->dq_id.type);
Jan Kara268157b2009-01-27 15:47:22 +0100487 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700488 if (ret >= 0)
489 ret = ret2;
490 }
491 clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
Ingo Molnard3be9152006-03-23 03:00:29 -0800492 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493out_dqlock:
Ingo Molnard3be9152006-03-23 03:00:29 -0800494 mutex_unlock(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700495 return ret;
496}
Mingming Cao08d03502009-01-14 16:19:32 +0100497EXPORT_SYMBOL(dquot_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498
Jan Kara7d9056b2008-11-25 15:31:32 +0100499void dquot_destroy(struct dquot *dquot)
Jan Kara74f783a2008-08-19 14:51:22 +0200500{
501 kmem_cache_free(dquot_cachep, dquot);
502}
Jan Kara7d9056b2008-11-25 15:31:32 +0100503EXPORT_SYMBOL(dquot_destroy);
Jan Kara74f783a2008-08-19 14:51:22 +0200504
505static inline void do_destroy_dquot(struct dquot *dquot)
506{
507 dquot->dq_sb->dq_op->destroy_dquot(dquot);
508}
509
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510/* Invalidate all dquots on the list. Note that this function is called after
511 * quota is disabled and pointers from inodes removed so there cannot be new
Jan Kara6362e4d2006-03-23 03:00:17 -0800512 * quota users. There can still be some users of quotas due to inodes being
513 * just deleted or pruned by prune_icache() (those are not attached to any
Jan Karacc334122009-01-12 17:23:05 +0100514 * list) or parallel quotactl call. We have to wait for such users.
Jan Kara6362e4d2006-03-23 03:00:17 -0800515 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516static void invalidate_dquots(struct super_block *sb, int type)
517{
Domen Puncerc33ed272005-06-25 14:59:36 -0700518 struct dquot *dquot, *tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519
Jan Kara6362e4d2006-03-23 03:00:17 -0800520restart:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 spin_lock(&dq_list_lock);
Domen Puncerc33ed272005-06-25 14:59:36 -0700522 list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700523 if (dquot->dq_sb != sb)
524 continue;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700525 if (dquot->dq_id.type != type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 continue;
Jan Kara6362e4d2006-03-23 03:00:17 -0800527 /* Wait for dquot users */
528 if (atomic_read(&dquot->dq_count)) {
529 DEFINE_WAIT(wait);
530
531 atomic_inc(&dquot->dq_count);
532 prepare_to_wait(&dquot->dq_wait_unused, &wait,
533 TASK_UNINTERRUPTIBLE);
534 spin_unlock(&dq_list_lock);
535 /* Once dqput() wakes us up, we know it's time to free
536 * the dquot.
537 * IMPORTANT: we rely on the fact that there is always
538 * at most one process waiting for dquot to free.
539 * Otherwise dq_count would be > 1 and we would never
540 * wake up.
541 */
542 if (atomic_read(&dquot->dq_count) > 1)
543 schedule();
544 finish_wait(&dquot->dq_wait_unused, &wait);
545 dqput(dquot);
546 /* At this moment dquot() need not exist (it could be
547 * reclaimed by prune_dqcache(). Hence we must
548 * restart. */
549 goto restart;
550 }
551 /*
552 * Quota now has no users and it has been written on last
553 * dqput()
554 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 remove_dquot_hash(dquot);
556 remove_free_dquot(dquot);
557 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200558 do_destroy_dquot(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559 }
560 spin_unlock(&dq_list_lock);
561}
562
Jan Kara12c77522008-10-20 17:05:00 +0200563/* Call callback for every active dquot on given filesystem */
564int dquot_scan_active(struct super_block *sb,
565 int (*fn)(struct dquot *dquot, unsigned long priv),
566 unsigned long priv)
567{
568 struct dquot *dquot, *old_dquot = NULL;
569 int ret = 0;
570
571 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
572 spin_lock(&dq_list_lock);
573 list_for_each_entry(dquot, &inuse_list, dq_inuse) {
574 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
575 continue;
576 if (dquot->dq_sb != sb)
577 continue;
578 /* Now we have active dquot so we can just increase use count */
579 atomic_inc(&dquot->dq_count);
Jan Kara12c77522008-10-20 17:05:00 +0200580 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400581 dqstats_inc(DQST_LOOKUPS);
Jan Kara12c77522008-10-20 17:05:00 +0200582 dqput(old_dquot);
583 old_dquot = dquot;
584 ret = fn(dquot, priv);
585 if (ret < 0)
586 goto out;
587 spin_lock(&dq_list_lock);
588 /* We are safe to continue now because our dquot could not
589 * be moved out of the inuse list while we hold the reference */
590 }
591 spin_unlock(&dq_list_lock);
592out:
593 dqput(old_dquot);
594 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
595 return ret;
596}
Mingming Cao08d03502009-01-14 16:19:32 +0100597EXPORT_SYMBOL(dquot_scan_active);
Jan Kara12c77522008-10-20 17:05:00 +0200598
Jan Karaceed1722012-07-03 16:45:28 +0200599/* Write all dquot structures to quota files */
600int dquot_writeback_dquots(struct super_block *sb, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
602 struct list_head *dirty;
603 struct dquot *dquot;
604 struct quota_info *dqopt = sb_dqopt(sb);
605 int cnt;
Jan Karaceed1722012-07-03 16:45:28 +0200606 int err, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607
Ingo Molnard3be9152006-03-23 03:00:29 -0800608 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
610 if (type != -1 && cnt != type)
611 continue;
Jan Karaf55abc02008-08-20 17:50:32 +0200612 if (!sb_has_quota_active(sb, cnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 continue;
614 spin_lock(&dq_list_lock);
615 dirty = &dqopt->info[cnt].dqi_dirty_list;
616 while (!list_empty(dirty)) {
Jan Kara268157b2009-01-27 15:47:22 +0100617 dquot = list_first_entry(dirty, struct dquot,
618 dq_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619 /* Dirty and inactive can be only bad dquot... */
620 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
621 clear_dquot_dirty(dquot);
622 continue;
623 }
624 /* Now we have active dquot from which someone is
625 * holding reference so we can safely just increase
626 * use count */
627 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400629 dqstats_inc(DQST_LOOKUPS);
Jan Karaceed1722012-07-03 16:45:28 +0200630 err = sb->dq_op->write_dquot(dquot);
631 if (!ret && err)
632 err = ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 dqput(dquot);
634 spin_lock(&dq_list_lock);
635 }
636 spin_unlock(&dq_list_lock);
637 }
638
639 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karaf55abc02008-08-20 17:50:32 +0200640 if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
641 && info_dirty(&dqopt->info[cnt]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 sb->dq_op->write_info(sb, cnt);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400643 dqstats_inc(DQST_SYNCS);
Ingo Molnard3be9152006-03-23 03:00:29 -0800644 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Jan Karaceed1722012-07-03 16:45:28 +0200646 return ret;
647}
648EXPORT_SYMBOL(dquot_writeback_dquots);
649
650/* Write all dquot structures to disk and make them visible from userspace */
651int dquot_quota_sync(struct super_block *sb, int type)
652{
653 struct quota_info *dqopt = sb_dqopt(sb);
654 int cnt;
655 int ret;
656
657 ret = dquot_writeback_dquots(sb, type);
658 if (ret)
659 return ret;
660 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500661 return 0;
662
663 /* This is not very clever (and fast) but currently I don't know about
664 * any other simple way of getting quota data to disk and we must get
665 * them there for userspace to be visible... */
666 if (sb->s_op->sync_fs)
667 sb->s_op->sync_fs(sb, 1);
668 sync_blockdev(sb->s_bdev);
669
670 /*
671 * Now when everything is written we can discard the pagecache so
672 * that userspace sees the changes.
673 */
Jan Karaf9ef1782012-04-25 21:10:31 +0200674 mutex_lock(&dqopt->dqonoff_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500675 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
676 if (type != -1 && cnt != type)
677 continue;
678 if (!sb_has_quota_active(sb, cnt))
679 continue;
Jan Karaa80b12c2012-04-25 21:15:53 +0200680 mutex_lock(&dqopt->files[cnt]->i_mutex);
Jan Karaf9ef1782012-04-25 21:10:31 +0200681 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
682 mutex_unlock(&dqopt->files[cnt]->i_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500683 }
Jan Karaf9ef1782012-04-25 21:10:31 +0200684 mutex_unlock(&dqopt->dqonoff_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500685
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 return 0;
687}
Christoph Hellwig287a8092010-05-19 07:16:45 -0400688EXPORT_SYMBOL(dquot_quota_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689
Dave Chinner1ab6c492013-08-28 10:18:09 +1000690static unsigned long
691dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
693 struct list_head *head;
694 struct dquot *dquot;
Dave Chinner1ab6c492013-08-28 10:18:09 +1000695 unsigned long freed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700696
697 head = free_dquots.prev;
Dave Chinner1ab6c492013-08-28 10:18:09 +1000698 while (head != &free_dquots && sc->nr_to_scan) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 dquot = list_entry(head, struct dquot, dq_free);
700 remove_dquot_hash(dquot);
701 remove_free_dquot(dquot);
702 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200703 do_destroy_dquot(dquot);
Dave Chinner1ab6c492013-08-28 10:18:09 +1000704 sc->nr_to_scan--;
705 freed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 head = free_dquots.prev;
707 }
Dave Chinner1ab6c492013-08-28 10:18:09 +1000708 return freed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709}
710
Dave Chinner1ab6c492013-08-28 10:18:09 +1000711static unsigned long
712dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713{
Glauber Costa55f841c2013-08-28 10:17:53 +1000714 return vfs_pressure_ratio(
715 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700716}
717
Rusty Russell8e1f9362007-07-17 04:03:17 -0700718static struct shrinker dqcache_shrinker = {
Dave Chinner1ab6c492013-08-28 10:18:09 +1000719 .count_objects = dqcache_shrink_count,
720 .scan_objects = dqcache_shrink_scan,
Rusty Russell8e1f9362007-07-17 04:03:17 -0700721 .seeks = DEFAULT_SEEKS,
722};
723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724/*
725 * Put reference to dquot
726 * NOTE: If you change this function please check whether dqput_blocks() works right...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200728void dqput(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729{
Jan Karab48d3802008-07-25 01:46:49 -0700730 int ret;
731
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (!dquot)
733 return;
Jan Kara62af9b52010-04-19 16:47:20 +0200734#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 if (!atomic_read(&dquot->dq_count)) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200736 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700737 quotatypes[dquot->dq_id.type],
738 from_kqid(&init_user_ns, dquot->dq_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 BUG();
740 }
741#endif
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400742 dqstats_inc(DQST_DROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743we_slept:
744 spin_lock(&dq_list_lock);
745 if (atomic_read(&dquot->dq_count) > 1) {
746 /* We have more than one user... nothing to do */
747 atomic_dec(&dquot->dq_count);
Jan Kara6362e4d2006-03-23 03:00:17 -0800748 /* Releasing dquot during quotaoff phase? */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700749 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) &&
Jan Kara6362e4d2006-03-23 03:00:17 -0800750 atomic_read(&dquot->dq_count) == 1)
751 wake_up(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 spin_unlock(&dq_list_lock);
753 return;
754 }
755 /* Need to release dquot? */
756 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
757 spin_unlock(&dq_list_lock);
758 /* Commit dquot before releasing */
Jan Karab48d3802008-07-25 01:46:49 -0700759 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
760 if (ret < 0) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200761 quota_error(dquot->dq_sb, "Can't write quota structure"
762 " (error %d). Quota may get out of sync!",
763 ret);
Jan Karab48d3802008-07-25 01:46:49 -0700764 /*
765 * We clear dirty bit anyway, so that we avoid
766 * infinite loop here
767 */
768 spin_lock(&dq_list_lock);
769 clear_dquot_dirty(dquot);
770 spin_unlock(&dq_list_lock);
771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772 goto we_slept;
773 }
774 /* Clear flag in case dquot was inactive (something bad happened) */
775 clear_dquot_dirty(dquot);
776 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
777 spin_unlock(&dq_list_lock);
778 dquot->dq_sb->dq_op->release_dquot(dquot);
779 goto we_slept;
780 }
781 atomic_dec(&dquot->dq_count);
Jan Kara62af9b52010-04-19 16:47:20 +0200782#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 /* sanity check */
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200784 BUG_ON(!list_empty(&dquot->dq_free));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785#endif
786 put_dquot_last(dquot);
787 spin_unlock(&dq_list_lock);
788}
Mingming Cao08d03502009-01-14 16:19:32 +0100789EXPORT_SYMBOL(dqput);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Jan Kara7d9056b2008-11-25 15:31:32 +0100791struct dquot *dquot_alloc(struct super_block *sb, int type)
Jan Kara74f783a2008-08-19 14:51:22 +0200792{
793 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
794}
Jan Kara7d9056b2008-11-25 15:31:32 +0100795EXPORT_SYMBOL(dquot_alloc);
Jan Kara74f783a2008-08-19 14:51:22 +0200796
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797static struct dquot *get_empty_dquot(struct super_block *sb, int type)
798{
799 struct dquot *dquot;
800
Jan Kara74f783a2008-08-19 14:51:22 +0200801 dquot = sb->dq_op->alloc_dquot(sb, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 if(!dquot)
Jan Karadd6f3c62009-01-26 16:01:43 +0100803 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Ingo Molnard3be9152006-03-23 03:00:29 -0800805 mutex_init(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806 INIT_LIST_HEAD(&dquot->dq_free);
807 INIT_LIST_HEAD(&dquot->dq_inuse);
808 INIT_HLIST_NODE(&dquot->dq_hash);
809 INIT_LIST_HEAD(&dquot->dq_dirty);
Jan Kara6362e4d2006-03-23 03:00:17 -0800810 init_waitqueue_head(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 dquot->dq_sb = sb;
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700812 dquot->dq_id = make_kqid_invalid(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813 atomic_set(&dquot->dq_count, 1);
814
815 return dquot;
816}
817
818/*
819 * Get reference to dquot
Jan Karacc334122009-01-12 17:23:05 +0100820 *
821 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
822 * destroying our dquot by:
823 * a) checking for quota flags under dq_list_lock and
824 * b) getting a reference to dquot before we release dq_list_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 */
Eric W. Biedermanaca645a2012-09-16 03:11:50 -0700826struct dquot *dqget(struct super_block *sb, struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700827{
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700828 unsigned int hashent = hashfn(sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +0100829 struct dquot *dquot = NULL, *empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700831 if (!sb_has_quota_active(sb, qid.type))
Jan Karadd6f3c62009-01-26 16:01:43 +0100832 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700833we_slept:
834 spin_lock(&dq_list_lock);
Jan Karacc334122009-01-12 17:23:05 +0100835 spin_lock(&dq_state_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700836 if (!sb_has_quota_active(sb, qid.type)) {
Jan Karacc334122009-01-12 17:23:05 +0100837 spin_unlock(&dq_state_lock);
838 spin_unlock(&dq_list_lock);
839 goto out;
840 }
841 spin_unlock(&dq_state_lock);
842
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700843 dquot = find_dquot(hashent, sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +0100844 if (!dquot) {
845 if (!empty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 spin_unlock(&dq_list_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700847 empty = get_empty_dquot(sb, qid.type);
Jan Karadd6f3c62009-01-26 16:01:43 +0100848 if (!empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 schedule(); /* Try to wait for a moment... */
850 goto we_slept;
851 }
852 dquot = empty;
Jan Karadd6f3c62009-01-26 16:01:43 +0100853 empty = NULL;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700854 dquot->dq_id = qid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 /* all dquots go on the inuse_list */
856 put_inuse(dquot);
857 /* hash it first so it can be found */
858 insert_dquot_hash(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400860 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861 } else {
862 if (!atomic_read(&dquot->dq_count))
863 remove_free_dquot(dquot);
864 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400866 dqstats_inc(DQST_CACHE_HITS);
867 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 }
Jan Kara268157b2009-01-27 15:47:22 +0100869 /* Wait for dq_lock - after this we know that either dquot_release() is
870 * already finished or it will be canceled due to dq_count > 1 test */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 wait_on_dquot(dquot);
Jan Kara268157b2009-01-27 15:47:22 +0100872 /* Read the dquot / allocate space in quota file */
873 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
874 sb->dq_op->acquire_dquot(dquot) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 dqput(dquot);
Jan Karadd6f3c62009-01-26 16:01:43 +0100876 dquot = NULL;
Jan Karacc334122009-01-12 17:23:05 +0100877 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 }
Jan Kara62af9b52010-04-19 16:47:20 +0200879#ifdef CONFIG_QUOTA_DEBUG
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200880 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881#endif
Jan Karacc334122009-01-12 17:23:05 +0100882out:
883 if (empty)
884 do_destroy_dquot(empty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885
886 return dquot;
887}
Mingming Cao08d03502009-01-14 16:19:32 +0100888EXPORT_SYMBOL(dqget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700889
890static int dqinit_needed(struct inode *inode, int type)
891{
892 int cnt;
893
894 if (IS_NOQUOTA(inode))
895 return 0;
896 if (type != -1)
Jan Karadd6f3c62009-01-26 16:01:43 +0100897 return !inode->i_dquot[type];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karadd6f3c62009-01-26 16:01:43 +0100899 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 return 1;
901 return 0;
902}
903
Ingo Molnard3be9152006-03-23 03:00:29 -0800904/* This routine is guarded by dqonoff_mutex mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700905static void add_dquot_ref(struct super_block *sb, int type)
906{
Jan Kara941d2382008-02-06 01:37:36 -0800907 struct inode *inode, *old_inode = NULL;
Jan Kara62af9b52010-04-19 16:47:20 +0200908#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100909 int reserved = 0;
Jan Kara4c5e6c02010-04-06 18:52:47 +0200910#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
Dave Chinner55fa6092011-03-22 22:23:40 +1100912 spin_lock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800913 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Dave Chinner250df6e2011-03-22 22:23:36 +1100914 spin_lock(&inode->i_lock);
915 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
916 !atomic_read(&inode->i_writecount) ||
917 !dqinit_needed(inode, type)) {
918 spin_unlock(&inode->i_lock);
Nick Pigginaabb8fd2009-03-11 13:17:36 -0700919 continue;
Dave Chinner250df6e2011-03-22 22:23:36 +1100920 }
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800921 __iget(inode);
Dave Chinner250df6e2011-03-22 22:23:36 +1100922 spin_unlock(&inode->i_lock);
Dave Chinner55fa6092011-03-22 22:23:40 +1100923 spin_unlock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800924
Jan Karad7e97112012-04-24 17:08:41 +0200925#ifdef CONFIG_QUOTA_DEBUG
926 if (unlikely(inode_get_rsv_space(inode) > 0))
927 reserved = 1;
928#endif
Jan Kara941d2382008-02-06 01:37:36 -0800929 iput(old_inode);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500930 __dquot_initialize(inode, type);
Dave Chinner55fa6092011-03-22 22:23:40 +1100931
932 /*
933 * We hold a reference to 'inode' so it couldn't have been
934 * removed from s_inodes list while we dropped the
935 * inode_sb_list_lock We cannot iput the inode now as we can be
936 * holding the last reference and we cannot iput it under
937 * inode_sb_list_lock. So we keep the reference and iput it
938 * later.
939 */
Jan Kara941d2382008-02-06 01:37:36 -0800940 old_inode = inode;
Dave Chinner55fa6092011-03-22 22:23:40 +1100941 spin_lock(&inode_sb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700942 }
Dave Chinner55fa6092011-03-22 22:23:40 +1100943 spin_unlock(&inode_sb_list_lock);
Jan Kara941d2382008-02-06 01:37:36 -0800944 iput(old_inode);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100945
Jan Kara62af9b52010-04-19 16:47:20 +0200946#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100947 if (reserved) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200948 quota_error(sb, "Writes happened before quota was turned on "
949 "thus quota information is probably inconsistent. "
950 "Please run quotacheck(8)");
Jan Kara0a5a9c72010-02-09 18:20:39 +0100951 }
Jan Kara4c5e6c02010-04-06 18:52:47 +0200952#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700953}
954
Jan Kara268157b2009-01-27 15:47:22 +0100955/*
956 * Return 0 if dqput() won't block.
957 * (note that 1 doesn't necessarily mean blocking)
958 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959static inline int dqput_blocks(struct dquot *dquot)
960{
961 if (atomic_read(&dquot->dq_count) <= 1)
962 return 1;
963 return 0;
964}
965
Jan Kara268157b2009-01-27 15:47:22 +0100966/*
967 * Remove references to dquots from inode and add dquot to list for freeing
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300968 * if we have the last reference to dquot
Jan Kara268157b2009-01-27 15:47:22 +0100969 * We can't race with anybody because we hold dqptr_sem for writing...
970 */
Adrian Bunke5f00f42007-05-08 00:27:22 -0700971static int remove_inode_dquot_ref(struct inode *inode, int type,
972 struct list_head *tofree_head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700973{
974 struct dquot *dquot = inode->i_dquot[type];
975
Jan Karadd6f3c62009-01-26 16:01:43 +0100976 inode->i_dquot[type] = NULL;
977 if (dquot) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700978 if (dqput_blocks(dquot)) {
Jan Kara62af9b52010-04-19 16:47:20 +0200979#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 if (atomic_read(&dquot->dq_count) != 1)
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200981 quota_error(inode->i_sb, "Adding dquot with "
982 "dq_count %d to dispose list",
983 atomic_read(&dquot->dq_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984#endif
985 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100986 /* As dquot must have currently users it can't be on
987 * the free list... */
988 list_add(&dquot->dq_free, tofree_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 spin_unlock(&dq_list_lock);
990 return 1;
991 }
992 else
993 dqput(dquot); /* We have guaranteed we won't block */
994 }
995 return 0;
996}
997
Jan Kara268157b2009-01-27 15:47:22 +0100998/*
999 * Free list of dquots
1000 * Dquots are removed from inodes and no new references can be got so we are
1001 * the only ones holding reference
1002 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003static void put_dquot_list(struct list_head *tofree_head)
1004{
1005 struct list_head *act_head;
1006 struct dquot *dquot;
1007
1008 act_head = tofree_head->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009 while (act_head != tofree_head) {
1010 dquot = list_entry(act_head, struct dquot, dq_free);
1011 act_head = act_head->next;
Jan Kara268157b2009-01-27 15:47:22 +01001012 /* Remove dquot from the list so we won't have problems... */
1013 list_del_init(&dquot->dq_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 dqput(dquot);
1015 }
1016}
1017
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001018static void remove_dquot_ref(struct super_block *sb, int type,
1019 struct list_head *tofree_head)
1020{
1021 struct inode *inode;
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001022 int reserved = 0;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001023
Dave Chinner55fa6092011-03-22 22:23:40 +11001024 spin_lock(&inode_sb_list_lock);
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001025 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Nick Pigginaabb8fd2009-03-11 13:17:36 -07001026 /*
1027 * We have to scan also I_NEW inodes because they can already
1028 * have quota pointer initialized. Luckily, we need to touch
1029 * only quota pointers and these have separate locking
1030 * (dqptr_sem).
1031 */
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001032 if (!IS_NOQUOTA(inode)) {
1033 if (unlikely(inode_get_rsv_space(inode) > 0))
1034 reserved = 1;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001035 remove_inode_dquot_ref(inode, type, tofree_head);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001036 }
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001037 }
Dave Chinner55fa6092011-03-22 22:23:40 +11001038 spin_unlock(&inode_sb_list_lock);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001039#ifdef CONFIG_QUOTA_DEBUG
1040 if (reserved) {
1041 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1042 " was disabled thus quota information is probably "
1043 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1044 }
1045#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001046}
1047
Linus Torvalds1da177e2005-04-16 15:20:36 -07001048/* Gather all references from inodes and drop them */
1049static void drop_dquot_ref(struct super_block *sb, int type)
1050{
1051 LIST_HEAD(tofree_head);
1052
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001053 if (sb->dq_op) {
1054 down_write(&sb_dqopt(sb)->dqptr_sem);
1055 remove_dquot_ref(sb, type, &tofree_head);
1056 up_write(&sb_dqopt(sb)->dqptr_sem);
1057 put_dquot_list(&tofree_head);
1058 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059}
1060
Jan Kara12095462008-08-20 14:45:12 +02001061static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001062{
1063 dquot->dq_dqb.dqb_curinodes += number;
1064}
1065
1066static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
1067{
1068 dquot->dq_dqb.dqb_curspace += number;
1069}
1070
Mingming Caof18df222009-01-13 16:43:09 +01001071static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
1072{
1073 dquot->dq_dqb.dqb_rsvspace += number;
1074}
1075
Mingming Cao740d9dc2009-01-13 16:43:14 +01001076/*
1077 * Claim reserved quota space
1078 */
Jan Kara0a5a9c72010-02-09 18:20:39 +01001079static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001080{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001081 if (dquot->dq_dqb.dqb_rsvspace < number) {
1082 WARN_ON_ONCE(1);
1083 number = dquot->dq_dqb.dqb_rsvspace;
1084 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001085 dquot->dq_dqb.dqb_curspace += number;
1086 dquot->dq_dqb.dqb_rsvspace -= number;
1087}
1088
Jan Kara1c8924e2013-08-17 09:32:32 -04001089static void dquot_reclaim_reserved_space(struct dquot *dquot, qsize_t number)
1090{
1091 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
1092 number = dquot->dq_dqb.dqb_curspace;
1093 dquot->dq_dqb.dqb_rsvspace += number;
1094 dquot->dq_dqb.dqb_curspace -= number;
1095}
1096
Mingming Cao740d9dc2009-01-13 16:43:14 +01001097static inline
1098void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1099{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001100 if (dquot->dq_dqb.dqb_rsvspace >= number)
1101 dquot->dq_dqb.dqb_rsvspace -= number;
1102 else {
1103 WARN_ON_ONCE(1);
1104 dquot->dq_dqb.dqb_rsvspace = 0;
1105 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001106}
1107
Jan Kara7a2435d2009-01-27 01:47:11 +01001108static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109{
Jan Karadb49d2d2008-10-01 18:21:39 +02001110 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1111 dquot->dq_dqb.dqb_curinodes >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 dquot->dq_dqb.dqb_curinodes -= number;
1113 else
1114 dquot->dq_dqb.dqb_curinodes = 0;
1115 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1116 dquot->dq_dqb.dqb_itime = (time_t) 0;
1117 clear_bit(DQ_INODES_B, &dquot->dq_flags);
1118}
1119
Jan Kara7a2435d2009-01-27 01:47:11 +01001120static void dquot_decr_space(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121{
Jan Karadb49d2d2008-10-01 18:21:39 +02001122 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1123 dquot->dq_dqb.dqb_curspace >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124 dquot->dq_dqb.dqb_curspace -= number;
1125 else
1126 dquot->dq_dqb.dqb_curspace = 0;
Jan Kara12095462008-08-20 14:45:12 +02001127 if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001128 dquot->dq_dqb.dqb_btime = (time_t) 0;
1129 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1130}
1131
Jan Karabf097aa2012-02-14 13:28:01 +01001132struct dquot_warn {
1133 struct super_block *w_sb;
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001134 struct kqid w_dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001135 short w_type;
1136};
1137
Jan Karac5254602007-12-22 14:03:25 -08001138static int warning_issued(struct dquot *dquot, const int warntype)
1139{
1140 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1141 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1142 ((warntype == QUOTA_NL_IHARDWARN ||
1143 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1144
1145 if (!flag)
1146 return 0;
1147 return test_and_set_bit(flag, &dquot->dq_flags);
1148}
1149
Jan Kara8e893462007-10-16 23:29:31 -07001150#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151static int flag_print_warnings = 1;
1152
Jan Karabf097aa2012-02-14 13:28:01 +01001153static int need_print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154{
1155 if (!flag_print_warnings)
1156 return 0;
1157
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001158 switch (warn->w_dq_id.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001159 case USRQUOTA:
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001160 return uid_eq(current_fsuid(), warn->w_dq_id.uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161 case GRPQUOTA:
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001162 return in_group_p(warn->w_dq_id.gid);
Jan Kara6c29c502012-10-09 23:30:17 +02001163 case PRJQUOTA: /* Never taken... Just make gcc happy */
1164 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001165 }
1166 return 0;
1167}
1168
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169/* Print warning to user which exceeded quota */
Jan Karabf097aa2012-02-14 13:28:01 +01001170static void print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171{
1172 char *msg = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001173 struct tty_struct *tty;
Jan Karabf097aa2012-02-14 13:28:01 +01001174 int warntype = warn->w_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175
Jan Kara657d3bf2008-07-25 01:46:52 -07001176 if (warntype == QUOTA_NL_IHARDBELOW ||
1177 warntype == QUOTA_NL_ISOFTBELOW ||
1178 warntype == QUOTA_NL_BHARDBELOW ||
Jan Karabf097aa2012-02-14 13:28:01 +01001179 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 return;
1181
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001182 tty = get_current_tty();
1183 if (!tty)
Alan Cox452a00d2008-10-13 10:39:13 +01001184 return;
Jan Karabf097aa2012-02-14 13:28:01 +01001185 tty_write_message(tty, warn->w_sb->s_id);
Jan Kara8e893462007-10-16 23:29:31 -07001186 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001187 tty_write_message(tty, ": warning, ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 else
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001189 tty_write_message(tty, ": write failed, ");
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001190 tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001191 switch (warntype) {
Jan Kara8e893462007-10-16 23:29:31 -07001192 case QUOTA_NL_IHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 msg = " file limit reached.\r\n";
1194 break;
Jan Kara8e893462007-10-16 23:29:31 -07001195 case QUOTA_NL_ISOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 msg = " file quota exceeded too long.\r\n";
1197 break;
Jan Kara8e893462007-10-16 23:29:31 -07001198 case QUOTA_NL_ISOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 msg = " file quota exceeded.\r\n";
1200 break;
Jan Kara8e893462007-10-16 23:29:31 -07001201 case QUOTA_NL_BHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 msg = " block limit reached.\r\n";
1203 break;
Jan Kara8e893462007-10-16 23:29:31 -07001204 case QUOTA_NL_BSOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 msg = " block quota exceeded too long.\r\n";
1206 break;
Jan Kara8e893462007-10-16 23:29:31 -07001207 case QUOTA_NL_BSOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001208 msg = " block quota exceeded.\r\n";
1209 break;
1210 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001211 tty_write_message(tty, msg);
Alan Cox452a00d2008-10-13 10:39:13 +01001212 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213}
Jan Kara8e893462007-10-16 23:29:31 -07001214#endif
1215
Jan Karabf097aa2012-02-14 13:28:01 +01001216static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1217 int warntype)
1218{
1219 if (warning_issued(dquot, warntype))
1220 return;
1221 warn->w_type = warntype;
1222 warn->w_sb = dquot->dq_sb;
1223 warn->w_dq_id = dquot->dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001224}
1225
Mingming Caof18df222009-01-13 16:43:09 +01001226/*
1227 * Write warnings to the console and send warning messages over netlink.
1228 *
Jan Karabf097aa2012-02-14 13:28:01 +01001229 * Note that this function can call into tty and networking code.
Mingming Caof18df222009-01-13 16:43:09 +01001230 */
Jan Karabf097aa2012-02-14 13:28:01 +01001231static void flush_warnings(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001232{
1233 int i;
1234
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001235 for (i = 0; i < MAXQUOTAS; i++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001236 if (warn[i].w_type == QUOTA_NL_NOWARN)
1237 continue;
Jan Kara8e893462007-10-16 23:29:31 -07001238#ifdef CONFIG_PRINT_QUOTA_WARNING
Jan Karabf097aa2012-02-14 13:28:01 +01001239 print_warning(&warn[i]);
Jan Kara8e893462007-10-16 23:29:31 -07001240#endif
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001241 quota_send_warning(warn[i].w_dq_id,
Jan Karabf097aa2012-02-14 13:28:01 +01001242 warn[i].w_sb->s_dev, warn[i].w_type);
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001243 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244}
1245
Jan Kara7a2435d2009-01-27 01:47:11 +01001246static int ignore_hardlimit(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247{
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001248 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001249
1250 return capable(CAP_SYS_RESOURCE) &&
Jan Kara268157b2009-01-27 15:47:22 +01001251 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1252 !(info->dqi_flags & V1_DQF_RSQUASH));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253}
1254
1255/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001256static int check_idq(struct dquot *dquot, qsize_t inodes,
1257 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258{
Jan Kara268157b2009-01-27 15:47:22 +01001259 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1260
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001261 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001262 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001263 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264
1265 if (dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001266 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001268 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001269 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001270 }
1271
1272 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001273 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1274 dquot->dq_dqb.dqb_itime &&
1275 get_seconds() >= dquot->dq_dqb.dqb_itime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001277 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001278 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279 }
1280
1281 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001282 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001283 dquot->dq_dqb.dqb_itime == 0) {
Jan Karabf097aa2012-02-14 13:28:01 +01001284 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001285 dquot->dq_dqb.dqb_itime = get_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001286 sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 }
1288
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001289 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290}
1291
1292/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001293static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc,
1294 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295{
Mingming Caof18df222009-01-13 16:43:09 +01001296 qsize_t tspace;
Jan Kara268157b2009-01-27 15:47:22 +01001297 struct super_block *sb = dquot->dq_sb;
Mingming Caof18df222009-01-13 16:43:09 +01001298
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001299 if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001300 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001301 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302
Mingming Caof18df222009-01-13 16:43:09 +01001303 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1304 + space;
1305
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 if (dquot->dq_dqb.dqb_bhardlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001307 tspace > dquot->dq_dqb.dqb_bhardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001308 !ignore_hardlimit(dquot)) {
1309 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001310 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001311 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312 }
1313
1314 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001315 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001316 dquot->dq_dqb.dqb_btime &&
1317 get_seconds() >= dquot->dq_dqb.dqb_btime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 !ignore_hardlimit(dquot)) {
1319 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001320 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001321 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 }
1323
1324 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001325 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001326 dquot->dq_dqb.dqb_btime == 0) {
1327 if (!prealloc) {
Jan Karabf097aa2012-02-14 13:28:01 +01001328 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001329 dquot->dq_dqb.dqb_btime = get_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001330 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001331 }
1332 else
1333 /*
1334 * We don't allow preallocation to exceed softlimit so exceeding will
1335 * be always printed
1336 */
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001337 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338 }
1339
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001340 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341}
1342
Jan Kara12095462008-08-20 14:45:12 +02001343static int info_idq_free(struct dquot *dquot, qsize_t inodes)
Jan Kara657d3bf2008-07-25 01:46:52 -07001344{
Jan Kara268157b2009-01-27 15:47:22 +01001345 qsize_t newinodes;
1346
Jan Kara657d3bf2008-07-25 01:46:52 -07001347 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001348 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001349 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type))
Jan Kara657d3bf2008-07-25 01:46:52 -07001350 return QUOTA_NL_NOWARN;
1351
Jan Kara268157b2009-01-27 15:47:22 +01001352 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1353 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001354 return QUOTA_NL_ISOFTBELOW;
1355 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001356 newinodes < dquot->dq_dqb.dqb_ihardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001357 return QUOTA_NL_IHARDBELOW;
1358 return QUOTA_NL_NOWARN;
1359}
1360
1361static int info_bdq_free(struct dquot *dquot, qsize_t space)
1362{
1363 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Kara12095462008-08-20 14:45:12 +02001364 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001365 return QUOTA_NL_NOWARN;
1366
Jan Kara12095462008-08-20 14:45:12 +02001367 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001368 return QUOTA_NL_BSOFTBELOW;
Jan Kara12095462008-08-20 14:45:12 +02001369 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
1370 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001371 return QUOTA_NL_BHARDBELOW;
1372 return QUOTA_NL_NOWARN;
1373}
Jan Kara0a5a9c72010-02-09 18:20:39 +01001374
Christoph Hellwig189eef52010-06-04 10:56:29 +02001375static int dquot_active(const struct inode *inode)
1376{
1377 struct super_block *sb = inode->i_sb;
1378
1379 if (IS_NOQUOTA(inode))
1380 return 0;
1381 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1382}
1383
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384/*
Christoph Hellwig871a2932010-03-03 09:05:07 -05001385 * Initialize quota pointers in inode
1386 *
1387 * We do things in a bit complicated way but by that we avoid calling
1388 * dqget() and thus filesystem callbacks under dqptr_sem.
1389 *
1390 * It is better to call this function outside of any transaction as it
1391 * might need a lot of space in journal for dquot structure allocation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 */
Christoph Hellwig871a2932010-03-03 09:05:07 -05001393static void __dquot_initialize(struct inode *inode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394{
Christoph Hellwig871a2932010-03-03 09:05:07 -05001395 int cnt;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001396 struct dquot *got[MAXQUOTAS];
Jan Karacc334122009-01-12 17:23:05 +01001397 struct super_block *sb = inode->i_sb;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001398 qsize_t rsv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
Ingo Molnard3be9152006-03-23 03:00:29 -08001400 /* First test before acquiring mutex - solves deadlocks when we
1401 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001402 if (!dquot_active(inode))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001403 return;
Jan Karacc334122009-01-12 17:23:05 +01001404
1405 /* First get references to structures we might need. */
1406 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001407 struct kqid qid;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001408 got[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001409 if (type != -1 && cnt != type)
1410 continue;
1411 switch (cnt) {
1412 case USRQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001413 qid = make_kqid_uid(inode->i_uid);
Jan Karacc334122009-01-12 17:23:05 +01001414 break;
1415 case GRPQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001416 qid = make_kqid_gid(inode->i_gid);
Jan Karacc334122009-01-12 17:23:05 +01001417 break;
1418 }
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001419 got[cnt] = dqget(sb, qid);
Jan Karacc334122009-01-12 17:23:05 +01001420 }
1421
1422 down_write(&sb_dqopt(sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 if (IS_NOQUOTA(inode))
1424 goto out_err;
1425 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1426 if (type != -1 && cnt != type)
1427 continue;
Jan Karacc334122009-01-12 17:23:05 +01001428 /* Avoid races with quotaoff() */
1429 if (!sb_has_quota_active(sb, cnt))
1430 continue;
Jan Kara4408ea42010-10-19 00:24:21 +02001431 /* We could race with quotaon or dqget() could have failed */
1432 if (!got[cnt])
1433 continue;
Jan Karadd6f3c62009-01-26 16:01:43 +01001434 if (!inode->i_dquot[cnt]) {
Jan Karacc334122009-01-12 17:23:05 +01001435 inode->i_dquot[cnt] = got[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001436 got[cnt] = NULL;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001437 /*
1438 * Make quota reservation system happy if someone
1439 * did a write before quota was turned on
1440 */
1441 rsv = inode_get_rsv_space(inode);
Jeff Mahoney68ac8bf2013-02-27 14:43:09 -05001442 if (unlikely(rsv)) {
1443 spin_lock(&dq_data_lock);
Jan Kara0a5a9c72010-02-09 18:20:39 +01001444 dquot_resv_space(inode->i_dquot[cnt], rsv);
Jeff Mahoney68ac8bf2013-02-27 14:43:09 -05001445 spin_unlock(&dq_data_lock);
1446 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447 }
1448 }
1449out_err:
Jan Karacc334122009-01-12 17:23:05 +01001450 up_write(&sb_dqopt(sb)->dqptr_sem);
1451 /* Drop unused references */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001452 dqput_all(got);
Christoph Hellwig871a2932010-03-03 09:05:07 -05001453}
1454
1455void dquot_initialize(struct inode *inode)
1456{
1457 __dquot_initialize(inode, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458}
Mingming Cao08d03502009-01-14 16:19:32 +01001459EXPORT_SYMBOL(dquot_initialize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
1461/*
1462 * Release all quotas referenced by inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05001464static void __dquot_drop(struct inode *inode)
Jan Kara3d9ea252008-10-10 16:12:23 +02001465{
Jan Karacc334122009-01-12 17:23:05 +01001466 int cnt;
1467 struct dquot *put[MAXQUOTAS];
1468
Jan Kara3d9ea252008-10-10 16:12:23 +02001469 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001470 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1471 put[cnt] = inode->i_dquot[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001472 inode->i_dquot[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001473 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001475 dqput_all(put);
Christoph Hellwig9f754752010-03-03 09:05:05 -05001476}
1477
1478void dquot_drop(struct inode *inode)
1479{
1480 int cnt;
1481
1482 if (IS_NOQUOTA(inode))
1483 return;
1484
1485 /*
1486 * Test before calling to rule out calls from proc and such
1487 * where we are not allowed to block. Note that this is
1488 * actually reliable test even without the lock - the caller
1489 * must assure that nobody can come after the DQUOT_DROP and
1490 * add quota pointers back anyway.
1491 */
1492 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1493 if (inode->i_dquot[cnt])
1494 break;
1495 }
1496
1497 if (cnt < MAXQUOTAS)
1498 __dquot_drop(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499}
Mingming Cao08d03502009-01-14 16:19:32 +01001500EXPORT_SYMBOL(dquot_drop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501
1502/*
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001503 * inode_reserved_space is managed internally by quota, and protected by
1504 * i_lock similar to i_blocks+i_bytes.
1505 */
1506static qsize_t *inode_reserved_space(struct inode * inode)
1507{
1508 /* Filesystem must explicitly define it's own method in order to use
1509 * quota reservation interface */
1510 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1511 return inode->i_sb->dq_op->get_reserved_space(inode);
1512}
1513
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001514void inode_add_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001515{
1516 spin_lock(&inode->i_lock);
1517 *inode_reserved_space(inode) += number;
1518 spin_unlock(&inode->i_lock);
1519}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001520EXPORT_SYMBOL(inode_add_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001521
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001522void inode_claim_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001523{
1524 spin_lock(&inode->i_lock);
1525 *inode_reserved_space(inode) -= number;
1526 __inode_add_bytes(inode, number);
1527 spin_unlock(&inode->i_lock);
1528}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001529EXPORT_SYMBOL(inode_claim_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001530
Jan Kara1c8924e2013-08-17 09:32:32 -04001531void inode_reclaim_rsv_space(struct inode *inode, qsize_t number)
1532{
1533 spin_lock(&inode->i_lock);
1534 *inode_reserved_space(inode) += number;
1535 __inode_sub_bytes(inode, number);
1536 spin_unlock(&inode->i_lock);
1537}
1538EXPORT_SYMBOL(inode_reclaim_rsv_space);
1539
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001540void inode_sub_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001541{
1542 spin_lock(&inode->i_lock);
1543 *inode_reserved_space(inode) -= number;
1544 spin_unlock(&inode->i_lock);
1545}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001546EXPORT_SYMBOL(inode_sub_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001547
1548static qsize_t inode_get_rsv_space(struct inode *inode)
1549{
1550 qsize_t ret;
Jan Kara05b5d892010-01-06 18:03:36 +01001551
1552 if (!inode->i_sb->dq_op->get_reserved_space)
1553 return 0;
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001554 spin_lock(&inode->i_lock);
1555 ret = *inode_reserved_space(inode);
1556 spin_unlock(&inode->i_lock);
1557 return ret;
1558}
1559
1560static void inode_incr_space(struct inode *inode, qsize_t number,
1561 int reserve)
1562{
1563 if (reserve)
1564 inode_add_rsv_space(inode, number);
1565 else
1566 inode_add_bytes(inode, number);
1567}
1568
1569static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1570{
1571 if (reserve)
1572 inode_sub_rsv_space(inode, number);
1573 else
1574 inode_sub_bytes(inode, number);
1575}
1576
1577/*
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001578 * This functions updates i_blocks+i_bytes fields and quota information
1579 * (together with appropriate checks).
1580 *
1581 * NOTE: We absolutely rely on the fact that caller dirties the inode
1582 * (usually helpers in quotaops.h care about this) and holds a handle for
1583 * the current transaction so that dquot write and inode write go into the
1584 * same transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001585 */
1586
1587/*
1588 * This operation can block, but only after everything is updated
1589 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001590int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591{
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001592 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001593 struct dquot_warn warn[MAXQUOTAS];
1594 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001595 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001597 /*
1598 * First test before acquiring mutex - solves deadlocks when we
1599 * re-enter the quota code and are already holding the mutex
1600 */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001601 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001602 inode_incr_space(inode, number, reserve);
1603 goto out;
1604 }
1605
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001607 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
Jeff Liu6ea2eea2012-07-18 12:12:41 +08001609 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 spin_lock(&dq_data_lock);
1611 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001612 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001613 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001614 ret = check_bdq(dquots[cnt], number,
1615 !(flags & DQUOT_SPACE_WARN), &warn[cnt]);
1616 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001617 spin_unlock(&dq_data_lock);
1618 goto out_flush_warn;
Mingming Caof18df222009-01-13 16:43:09 +01001619 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 }
1621 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001622 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 continue;
Mingming Caof18df222009-01-13 16:43:09 +01001624 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001625 dquot_resv_space(dquots[cnt], number);
Mingming Caof18df222009-01-13 16:43:09 +01001626 else
Jan Karabf097aa2012-02-14 13:28:01 +01001627 dquot_incr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001629 inode_incr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001631
1632 if (reserve)
1633 goto out_flush_warn;
Jan Karabf097aa2012-02-14 13:28:01 +01001634 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001635out_flush_warn:
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001636 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001637 flush_warnings(warn);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001638out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 return ret;
1640}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001641EXPORT_SYMBOL(__dquot_alloc_space);
Mingming Caof18df222009-01-13 16:43:09 +01001642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643/*
1644 * This operation can block, but only after everything is updated
1645 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001646int dquot_alloc_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647{
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001648 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001649 struct dquot_warn warn[MAXQUOTAS];
1650 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651
Ingo Molnard3be9152006-03-23 03:00:29 -08001652 /* First test before acquiring mutex - solves deadlocks when we
1653 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001654 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001655 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001657 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 spin_lock(&dq_data_lock);
1660 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001661 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001663 ret = check_idq(dquots[cnt], 1, &warn[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001664 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001665 goto warn_put_all;
1666 }
1667
1668 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001669 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001671 dquot_incr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 }
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001673
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674warn_put_all:
1675 spin_unlock(&dq_data_lock);
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001676 if (ret == 0)
Jan Karabf097aa2012-02-14 13:28:01 +01001677 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001678 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001679 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 return ret;
1681}
Mingming Cao08d03502009-01-14 16:19:32 +01001682EXPORT_SYMBOL(dquot_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001684/*
1685 * Convert in-memory reserved quotas to real consumed quotas
1686 */
1687int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001688{
1689 int cnt;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001690
Christoph Hellwig189eef52010-06-04 10:56:29 +02001691 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001692 inode_claim_rsv_space(inode, number);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001693 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001694 }
1695
1696 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001697 spin_lock(&dq_data_lock);
1698 /* Claim reserved quotas to allocated quotas */
1699 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001700 if (inode->i_dquot[cnt])
Mingming Cao740d9dc2009-01-13 16:43:14 +01001701 dquot_claim_reserved_space(inode->i_dquot[cnt],
1702 number);
1703 }
1704 /* Update inode bytes */
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001705 inode_claim_rsv_space(inode, number);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001706 spin_unlock(&dq_data_lock);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001707 mark_all_dquot_dirty(inode->i_dquot);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001708 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001709 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001710}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001711EXPORT_SYMBOL(dquot_claim_space_nodirty);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001712
1713/*
Jan Kara1c8924e2013-08-17 09:32:32 -04001714 * Convert allocated space back to in-memory reserved quotas
1715 */
1716void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
1717{
1718 int cnt;
1719
1720 if (!dquot_active(inode)) {
1721 inode_reclaim_rsv_space(inode, number);
1722 return;
1723 }
1724
1725 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1726 spin_lock(&dq_data_lock);
1727 /* Claim reserved quotas to allocated quotas */
1728 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1729 if (inode->i_dquot[cnt])
1730 dquot_reclaim_reserved_space(inode->i_dquot[cnt],
1731 number);
1732 }
1733 /* Update inode bytes */
1734 inode_reclaim_rsv_space(inode, number);
1735 spin_unlock(&dq_data_lock);
1736 mark_all_dquot_dirty(inode->i_dquot);
1737 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1738 return;
1739}
1740EXPORT_SYMBOL(dquot_reclaim_space_nodirty);
1741
1742/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743 * This operation can block, but only after everything is updated
1744 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001745void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746{
1747 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001748 struct dquot_warn warn[MAXQUOTAS];
1749 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001750 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001751
Ingo Molnard3be9152006-03-23 03:00:29 -08001752 /* First test before acquiring mutex - solves deadlocks when we
1753 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001754 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001755 inode_decr_space(inode, number, reserve);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001756 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001757 }
Jan Kara657d3bf2008-07-25 01:46:52 -07001758
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001760 spin_lock(&dq_data_lock);
1761 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001762 int wtype;
1763
1764 warn[cnt].w_type = QUOTA_NL_NOWARN;
1765 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001767 wtype = info_bdq_free(dquots[cnt], number);
1768 if (wtype != QUOTA_NL_NOWARN)
1769 prepare_warning(&warn[cnt], dquots[cnt], wtype);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001770 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001771 dquot_free_reserved_space(dquots[cnt], number);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001772 else
Jan Karabf097aa2012-02-14 13:28:01 +01001773 dquot_decr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001775 inode_decr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001777
1778 if (reserve)
1779 goto out_unlock;
Jan Karabf097aa2012-02-14 13:28:01 +01001780 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001781out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001783 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001785EXPORT_SYMBOL(__dquot_free_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001786
1787/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001788 * This operation can block, but only after everything is updated
1789 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001790void dquot_free_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791{
1792 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001793 struct dquot_warn warn[MAXQUOTAS];
1794 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001795
Ingo Molnard3be9152006-03-23 03:00:29 -08001796 /* First test before acquiring mutex - solves deadlocks when we
1797 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001798 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001799 return;
Jan Kara657d3bf2008-07-25 01:46:52 -07001800
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 spin_lock(&dq_data_lock);
1803 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001804 int wtype;
1805
1806 warn[cnt].w_type = QUOTA_NL_NOWARN;
1807 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001809 wtype = info_idq_free(dquots[cnt], 1);
1810 if (wtype != QUOTA_NL_NOWARN)
1811 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1812 dquot_decr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 }
1814 spin_unlock(&dq_data_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01001815 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001817 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818}
Mingming Cao08d03502009-01-14 16:19:32 +01001819EXPORT_SYMBOL(dquot_free_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820
1821/*
1822 * Transfer the number of inode and blocks from one diskquota to an other.
Jan Karabc8e5f02010-05-13 19:58:50 +02001823 * On success, dquot references in transfer_to are consumed and references
1824 * to original dquots that need to be released are placed there. On failure,
1825 * references are kept untouched.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 *
1827 * This operation can block, but only after everything is updated
1828 * A transaction must be started when entering this function.
Jan Karabc8e5f02010-05-13 19:58:50 +02001829 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 */
Jan Karabc8e5f02010-05-13 19:58:50 +02001831int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832{
Mingming Cao740d9dc2009-01-13 16:43:14 +01001833 qsize_t space, cur_space;
1834 qsize_t rsv_space = 0;
Jan Karabc8e5f02010-05-13 19:58:50 +02001835 struct dquot *transfer_from[MAXQUOTAS] = {};
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001836 int cnt, ret = 0;
Dmitry9e327842010-10-09 23:15:30 +04001837 char is_valid[MAXQUOTAS] = {};
Jan Karabf097aa2012-02-14 13:28:01 +01001838 struct dquot_warn warn_to[MAXQUOTAS];
1839 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1840 struct dquot_warn warn_from_space[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841
Ingo Molnard3be9152006-03-23 03:00:29 -08001842 /* First test before acquiring mutex - solves deadlocks when we
1843 * re-enter the quota code and are already holding the mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 if (IS_NOQUOTA(inode))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001845 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001846 /* Initialize the arrays */
Jan Karabf097aa2012-02-14 13:28:01 +01001847 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1848 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1849 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1850 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1851 }
Jan Karacc334122009-01-12 17:23:05 +01001852 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001853 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
1854 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabc8e5f02010-05-13 19:58:50 +02001855 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001856 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857 spin_lock(&dq_data_lock);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001858 cur_space = inode_get_bytes(inode);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001859 rsv_space = inode_get_rsv_space(inode);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001860 space = cur_space + rsv_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861 /* Build the transfer_from list and check the limits */
1862 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001863 /*
1864 * Skip changes for same uid or gid or for turned off quota-type.
1865 */
Jan Karadd6f3c62009-01-26 16:01:43 +01001866 if (!transfer_to[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 continue;
Dmitry9e327842010-10-09 23:15:30 +04001868 /* Avoid races with quotaoff() */
1869 if (!sb_has_quota_active(inode->i_sb, cnt))
1870 continue;
1871 is_valid[cnt] = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 transfer_from[cnt] = inode->i_dquot[cnt];
Jan Karabf097aa2012-02-14 13:28:01 +01001873 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001874 if (ret)
1875 goto over_quota;
Jan Karabf097aa2012-02-14 13:28:01 +01001876 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001877 if (ret)
Jan Karacc334122009-01-12 17:23:05 +01001878 goto over_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 }
1880
1881 /*
1882 * Finally perform the needed transfer from transfer_from to transfer_to
1883 */
1884 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001885 if (!is_valid[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001886 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887 /* Due to IO error we might not have transfer_from[] structure */
1888 if (transfer_from[cnt]) {
Jan Karabf097aa2012-02-14 13:28:01 +01001889 int wtype;
1890 wtype = info_idq_free(transfer_from[cnt], 1);
1891 if (wtype != QUOTA_NL_NOWARN)
1892 prepare_warning(&warn_from_inodes[cnt],
1893 transfer_from[cnt], wtype);
1894 wtype = info_bdq_free(transfer_from[cnt], space);
1895 if (wtype != QUOTA_NL_NOWARN)
1896 prepare_warning(&warn_from_space[cnt],
1897 transfer_from[cnt], wtype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 dquot_decr_inodes(transfer_from[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001899 dquot_decr_space(transfer_from[cnt], cur_space);
1900 dquot_free_reserved_space(transfer_from[cnt],
1901 rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 }
1903
1904 dquot_incr_inodes(transfer_to[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001905 dquot_incr_space(transfer_to[cnt], cur_space);
1906 dquot_resv_space(transfer_to[cnt], rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907
1908 inode->i_dquot[cnt] = transfer_to[cnt];
1909 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 spin_unlock(&dq_data_lock);
Jan Karacc334122009-01-12 17:23:05 +01001911 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1912
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001913 mark_all_dquot_dirty(transfer_from);
1914 mark_all_dquot_dirty(transfer_to);
Jan Karabf097aa2012-02-14 13:28:01 +01001915 flush_warnings(warn_to);
1916 flush_warnings(warn_from_inodes);
1917 flush_warnings(warn_from_space);
Jan Karabc8e5f02010-05-13 19:58:50 +02001918 /* Pass back references to put */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001919 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Dmitry9e327842010-10-09 23:15:30 +04001920 if (is_valid[cnt])
1921 transfer_to[cnt] = transfer_from[cnt];
Jan Kara86f3cbe2010-10-11 15:22:21 +02001922 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001923over_quota:
1924 spin_unlock(&dq_data_lock);
1925 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001926 flush_warnings(warn_to);
Jan Kara86f3cbe2010-10-11 15:22:21 +02001927 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928}
Jan Karabc8e5f02010-05-13 19:58:50 +02001929EXPORT_SYMBOL(__dquot_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001931/* Wrapper for transferring ownership of an inode for uid/gid only
1932 * Called from FSXXX_setattr()
1933 */
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001934int dquot_transfer(struct inode *inode, struct iattr *iattr)
Jan Karab85f4b82008-07-25 01:46:50 -07001935{
Jan Karabc8e5f02010-05-13 19:58:50 +02001936 struct dquot *transfer_to[MAXQUOTAS] = {};
1937 struct super_block *sb = inode->i_sb;
1938 int ret;
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001939
Christoph Hellwig189eef52010-06-04 10:56:29 +02001940 if (!dquot_active(inode))
Jan Karabc8e5f02010-05-13 19:58:50 +02001941 return 0;
Dmitry Monakhov12755622010-04-08 22:04:20 +04001942
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001943 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid))
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001944 transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(iattr->ia_uid));
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001945 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001946 transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(iattr->ia_gid));
Jan Karabc8e5f02010-05-13 19:58:50 +02001947
1948 ret = __dquot_transfer(inode, transfer_to);
1949 dqput_all(transfer_to);
1950 return ret;
Jan Karab85f4b82008-07-25 01:46:50 -07001951}
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001952EXPORT_SYMBOL(dquot_transfer);
Jan Karab85f4b82008-07-25 01:46:50 -07001953
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954/*
1955 * Write info of quota file to disk
1956 */
1957int dquot_commit_info(struct super_block *sb, int type)
1958{
1959 int ret;
1960 struct quota_info *dqopt = sb_dqopt(sb);
1961
Ingo Molnard3be9152006-03-23 03:00:29 -08001962 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 ret = dqopt->ops[type]->write_file_info(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08001964 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 return ret;
1966}
Mingming Cao08d03502009-01-14 16:19:32 +01001967EXPORT_SYMBOL(dquot_commit_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001968
1969/*
1970 * Definitions of diskquota operations.
1971 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -07001972const struct dquot_operations dquot_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 .write_dquot = dquot_commit,
1974 .acquire_dquot = dquot_acquire,
1975 .release_dquot = dquot_release,
1976 .mark_dirty = dquot_mark_dquot_dirty,
Jan Kara74f783a2008-08-19 14:51:22 +02001977 .write_info = dquot_commit_info,
1978 .alloc_dquot = dquot_alloc,
1979 .destroy_dquot = dquot_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980};
Christoph Hellwig123e9ca2010-05-19 07:16:44 -04001981EXPORT_SYMBOL(dquot_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983/*
Christoph Hellwig907f4552010-03-03 09:05:06 -05001984 * Generic helper for ->open on filesystems supporting disk quotas.
1985 */
1986int dquot_file_open(struct inode *inode, struct file *file)
1987{
1988 int error;
1989
1990 error = generic_file_open(inode, file);
1991 if (!error && (file->f_mode & FMODE_WRITE))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001992 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -05001993 return error;
1994}
1995EXPORT_SYMBOL(dquot_file_open);
1996
1997/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
1999 */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002000int dquot_disable(struct super_block *sb, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001{
Jan Kara0ff5af82008-04-28 02:14:33 -07002002 int cnt, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 struct quota_info *dqopt = sb_dqopt(sb);
2004 struct inode *toputinode[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005
Jan Karaf55abc02008-08-20 17:50:32 +02002006 /* Cannot turn off usage accounting without turning off limits, or
2007 * suspend quotas and simultaneously turn quotas off. */
2008 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
2009 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
2010 DQUOT_USAGE_ENABLED)))
2011 return -EINVAL;
2012
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 /* We need to serialize quota_off() for device */
Ingo Molnard3be9152006-03-23 03:00:29 -08002014 mutex_lock(&dqopt->dqonoff_mutex);
Jan Kara9377abd2008-05-12 14:02:08 -07002015
2016 /*
2017 * Skip everything if there's nothing to do. We have to do this because
2018 * sometimes we are called when fill_super() failed and calling
2019 * sync_fs() in such cases does no good.
2020 */
Jan Karaf55abc02008-08-20 17:50:32 +02002021 if (!sb_any_quota_loaded(sb)) {
Jan Kara9377abd2008-05-12 14:02:08 -07002022 mutex_unlock(&dqopt->dqonoff_mutex);
2023 return 0;
2024 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002025 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2026 toputinode[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 if (type != -1 && cnt != type)
2028 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002029 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002030 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002031
2032 if (flags & DQUOT_SUSPENDED) {
Jan Karacc334122009-01-12 17:23:05 +01002033 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002034 dqopt->flags |=
2035 dquot_state_flag(DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002036 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002037 } else {
Jan Karacc334122009-01-12 17:23:05 +01002038 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002039 dqopt->flags &= ~dquot_state_flag(flags, cnt);
2040 /* Turning off suspended quotas? */
2041 if (!sb_has_quota_loaded(sb, cnt) &&
2042 sb_has_quota_suspended(sb, cnt)) {
2043 dqopt->flags &= ~dquot_state_flag(
2044 DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002045 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002046 iput(dqopt->files[cnt]);
2047 dqopt->files[cnt] = NULL;
2048 continue;
2049 }
Jan Karacc334122009-01-12 17:23:05 +01002050 spin_unlock(&dq_state_lock);
Jan Kara0ff5af82008-04-28 02:14:33 -07002051 }
Jan Karaf55abc02008-08-20 17:50:32 +02002052
2053 /* We still have to keep quota loaded? */
2054 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002055 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056
2057 /* Note: these are blocking operations */
2058 drop_dquot_ref(sb, cnt);
2059 invalidate_dquots(sb, cnt);
2060 /*
Jan Kara268157b2009-01-27 15:47:22 +01002061 * Now all dquots should be invalidated, all writes done so we
2062 * should be only users of the info. No locks needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002063 */
2064 if (info_dirty(&dqopt->info[cnt]))
2065 sb->dq_op->write_info(sb, cnt);
2066 if (dqopt->ops[cnt]->free_file_info)
2067 dqopt->ops[cnt]->free_file_info(sb, cnt);
2068 put_quota_format(dqopt->info[cnt].dqi_format);
2069
2070 toputinode[cnt] = dqopt->files[cnt];
Jan Karaf55abc02008-08-20 17:50:32 +02002071 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002072 dqopt->files[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 dqopt->info[cnt].dqi_flags = 0;
2074 dqopt->info[cnt].dqi_igrace = 0;
2075 dqopt->info[cnt].dqi_bgrace = 0;
2076 dqopt->ops[cnt] = NULL;
2077 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002078 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002079
2080 /* Skip syncing and setting flags if quota files are hidden */
2081 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2082 goto put_inodes;
2083
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 /* Sync the superblock so that buffers with quota data are written to
Al Viro7b7b1ac2005-11-07 17:13:39 -05002085 * disk (and so userspace sees correct data afterwards). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 if (sb->s_op->sync_fs)
2087 sb->s_op->sync_fs(sb, 1);
2088 sync_blockdev(sb->s_bdev);
2089 /* Now the quota files are just ordinary files and we can set the
2090 * inode flags back. Moreover we discard the pagecache so that
2091 * userspace sees the writes we did bypassing the pagecache. We
2092 * must also discard the blockdev buffers so that we see the
2093 * changes done by userspace on the next quotaon() */
2094 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2095 if (toputinode[cnt]) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002096 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 /* If quota was reenabled in the meantime, we have
2098 * nothing to do */
Jan Karaf55abc02008-08-20 17:50:32 +02002099 if (!sb_has_quota_loaded(sb, cnt)) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002100 mutex_lock(&toputinode[cnt]->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
2102 S_NOATIME | S_NOQUOTA);
Jan Kara268157b2009-01-27 15:47:22 +01002103 truncate_inode_pages(&toputinode[cnt]->i_data,
2104 0);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002105 mutex_unlock(&toputinode[cnt]->i_mutex);
Jan Kara43d29322010-07-21 14:22:21 +02002106 mark_inode_dirty_sync(toputinode[cnt]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002108 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002109 }
2110 if (sb->s_bdev)
2111 invalidate_bdev(sb->s_bdev);
2112put_inodes:
2113 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2114 if (toputinode[cnt]) {
Jan Kara0ff5af82008-04-28 02:14:33 -07002115 /* On remount RO, we keep the inode pointer so that we
Jan Karaf55abc02008-08-20 17:50:32 +02002116 * can reenable quota on the subsequent remount RW. We
2117 * have to check 'flags' variable and not use sb_has_
2118 * function because another quotaon / quotaoff could
2119 * change global state before we got here. We refuse
2120 * to suspend quotas when there is pending delete on
2121 * the quota file... */
2122 if (!(flags & DQUOT_SUSPENDED))
Jan Kara0ff5af82008-04-28 02:14:33 -07002123 iput(toputinode[cnt]);
2124 else if (!toputinode[cnt]->i_nlink)
2125 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002127 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002129EXPORT_SYMBOL(dquot_disable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130
Christoph Hellwig287a8092010-05-19 07:16:45 -04002131int dquot_quota_off(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +02002132{
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002133 return dquot_disable(sb, type,
2134 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Jan Karaf55abc02008-08-20 17:50:32 +02002135}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002136EXPORT_SYMBOL(dquot_quota_off);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002137
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138/*
2139 * Turn quotas on on a device
2140 */
2141
Jan Karaf55abc02008-08-20 17:50:32 +02002142/*
2143 * Helper function to turn quotas on when we already have the inode of
2144 * quota file and no quota information is loaded.
2145 */
2146static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2147 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148{
2149 struct quota_format_type *fmt = find_quota_format(format_id);
2150 struct super_block *sb = inode->i_sb;
2151 struct quota_info *dqopt = sb_dqopt(sb);
2152 int error;
2153 int oldflags = -1;
2154
2155 if (!fmt)
2156 return -ESRCH;
2157 if (!S_ISREG(inode->i_mode)) {
2158 error = -EACCES;
2159 goto out_fmt;
2160 }
2161 if (IS_RDONLY(inode)) {
2162 error = -EROFS;
2163 goto out_fmt;
2164 }
2165 if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
2166 error = -EINVAL;
2167 goto out_fmt;
2168 }
Jan Karaf55abc02008-08-20 17:50:32 +02002169 /* Usage always has to be set... */
2170 if (!(flags & DQUOT_USAGE_ENABLED)) {
2171 error = -EINVAL;
2172 goto out_fmt;
2173 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174
Jan Karaca785ec2008-09-30 17:53:37 +02002175 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
Jan Karaab94c392010-02-22 21:07:17 +01002176 /* As we bypass the pagecache we must now flush all the
2177 * dirty data and invalidate caches so that kernel sees
2178 * changes from userspace. It is not enough to just flush
2179 * the quota file since if blocksize < pagesize, invalidation
2180 * of the cache could fail because of other unrelated dirty
2181 * data */
2182 sync_filesystem(sb);
Jan Karaca785ec2008-09-30 17:53:37 +02002183 invalidate_bdev(sb->s_bdev);
2184 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002185 mutex_lock(&dqopt->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002186 if (sb_has_quota_loaded(sb, type)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 error = -EBUSY;
2188 goto out_lock;
2189 }
Jan Karaca785ec2008-09-30 17:53:37 +02002190
2191 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2192 /* We don't want quota and atime on quota files (deadlocks
2193 * possible) Also nobody should write to the file - we use
2194 * special IO operations which ignore the immutable bit. */
Jan Karaa80b12c2012-04-25 21:15:53 +02002195 mutex_lock(&inode->i_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002196 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2197 S_NOQUOTA);
Jan Karaca785ec2008-09-30 17:53:37 +02002198 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
Jan Karadee86562009-07-22 18:12:17 +02002199 mutex_unlock(&inode->i_mutex);
Jan Kara26245c92010-01-06 17:20:35 +01002200 /*
2201 * When S_NOQUOTA is set, remove dquot references as no more
2202 * references can be added
2203 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05002204 __dquot_drop(inode);
Jan Karaca785ec2008-09-30 17:53:37 +02002205 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002206
2207 error = -EIO;
2208 dqopt->files[type] = igrab(inode);
2209 if (!dqopt->files[type])
2210 goto out_lock;
2211 error = -EINVAL;
2212 if (!fmt->qf_ops->check_quota_file(sb, type))
2213 goto out_file_init;
2214
2215 dqopt->ops[type] = fmt->qf_ops;
2216 dqopt->info[type].dqi_format = fmt;
Jan Kara0ff5af82008-04-28 02:14:33 -07002217 dqopt->info[type].dqi_fmt_id = format_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
Ingo Molnard3be9152006-03-23 03:00:29 -08002219 mutex_lock(&dqopt->dqio_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002220 error = dqopt->ops[type]->read_file_info(sb, type);
2221 if (error < 0) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002222 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223 goto out_file_init;
2224 }
Jan Kara46fe44c2011-11-16 15:03:59 +01002225 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2226 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
Ingo Molnard3be9152006-03-23 03:00:29 -08002227 mutex_unlock(&dqopt->dqio_mutex);
Jan Karacc334122009-01-12 17:23:05 +01002228 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002229 dqopt->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002230 spin_unlock(&dq_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002231
2232 add_dquot_ref(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08002233 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234
2235 return 0;
2236
2237out_file_init:
2238 dqopt->files[type] = NULL;
2239 iput(inode);
2240out_lock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 if (oldflags != -1) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002242 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 /* Set the flags back (in the case of accidental quotaon()
2244 * on a wrong file we don't want to mess up the flags) */
2245 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2246 inode->i_flags |= oldflags;
Jan Karadee86562009-07-22 18:12:17 +02002247 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002248 }
Jiaying Zhangd01730d2009-07-07 18:15:21 +02002249 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002250out_fmt:
2251 put_quota_format(fmt);
2252
2253 return error;
2254}
2255
Jan Kara0ff5af82008-04-28 02:14:33 -07002256/* Reenable quotas on remount RW */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002257int dquot_resume(struct super_block *sb, int type)
Jan Kara0ff5af82008-04-28 02:14:33 -07002258{
2259 struct quota_info *dqopt = sb_dqopt(sb);
2260 struct inode *inode;
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002261 int ret = 0, cnt;
Jan Karaf55abc02008-08-20 17:50:32 +02002262 unsigned int flags;
Jan Kara0ff5af82008-04-28 02:14:33 -07002263
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002264 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2265 if (type != -1 && cnt != type)
2266 continue;
Jan Kara0ff5af82008-04-28 02:14:33 -07002267
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002268 mutex_lock(&dqopt->dqonoff_mutex);
2269 if (!sb_has_quota_suspended(sb, cnt)) {
2270 mutex_unlock(&dqopt->dqonoff_mutex);
2271 continue;
2272 }
2273 inode = dqopt->files[cnt];
2274 dqopt->files[cnt] = NULL;
2275 spin_lock(&dq_state_lock);
2276 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2277 DQUOT_LIMITS_ENABLED,
2278 cnt);
2279 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2280 spin_unlock(&dq_state_lock);
2281 mutex_unlock(&dqopt->dqonoff_mutex);
2282
2283 flags = dquot_generic_flag(flags, cnt);
2284 ret = vfs_load_quota_inode(inode, cnt,
2285 dqopt->info[cnt].dqi_fmt_id, flags);
2286 iput(inode);
2287 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002288
2289 return ret;
2290}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002291EXPORT_SYMBOL(dquot_resume);
Jan Kara0ff5af82008-04-28 02:14:33 -07002292
Jan Karaf00c9e42010-09-15 17:38:58 +02002293int dquot_quota_on(struct super_block *sb, int type, int format_id,
2294 struct path *path)
Al Viro77e69da2008-08-01 04:29:18 -04002295{
2296 int error = security_quota_on(path->dentry);
2297 if (error)
2298 return error;
2299 /* Quota file not on the same filesystem? */
Al Virod8c95842011-12-07 18:16:57 -05002300 if (path->dentry->d_sb != sb)
Al Viro77e69da2008-08-01 04:29:18 -04002301 error = -EXDEV;
2302 else
Jan Karaf55abc02008-08-20 17:50:32 +02002303 error = vfs_load_quota_inode(path->dentry->d_inode, type,
2304 format_id, DQUOT_USAGE_ENABLED |
2305 DQUOT_LIMITS_ENABLED);
Al Viro77e69da2008-08-01 04:29:18 -04002306 return error;
2307}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002308EXPORT_SYMBOL(dquot_quota_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002309
2310/*
Jan Karaf55abc02008-08-20 17:50:32 +02002311 * More powerful function for turning on quotas allowing setting
2312 * of individual quota flags
2313 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002314int dquot_enable(struct inode *inode, int type, int format_id,
2315 unsigned int flags)
Jan Karaf55abc02008-08-20 17:50:32 +02002316{
2317 int ret = 0;
2318 struct super_block *sb = inode->i_sb;
2319 struct quota_info *dqopt = sb_dqopt(sb);
2320
2321 /* Just unsuspend quotas? */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002322 BUG_ON(flags & DQUOT_SUSPENDED);
2323
Jan Karaf55abc02008-08-20 17:50:32 +02002324 if (!flags)
2325 return 0;
2326 /* Just updating flags needed? */
2327 if (sb_has_quota_loaded(sb, type)) {
2328 mutex_lock(&dqopt->dqonoff_mutex);
2329 /* Now do a reliable test... */
2330 if (!sb_has_quota_loaded(sb, type)) {
2331 mutex_unlock(&dqopt->dqonoff_mutex);
2332 goto load_quota;
2333 }
2334 if (flags & DQUOT_USAGE_ENABLED &&
2335 sb_has_quota_usage_enabled(sb, type)) {
2336 ret = -EBUSY;
2337 goto out_lock;
2338 }
2339 if (flags & DQUOT_LIMITS_ENABLED &&
2340 sb_has_quota_limits_enabled(sb, type)) {
2341 ret = -EBUSY;
2342 goto out_lock;
2343 }
Jan Karacc334122009-01-12 17:23:05 +01002344 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002345 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002346 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002347out_lock:
2348 mutex_unlock(&dqopt->dqonoff_mutex);
2349 return ret;
2350 }
2351
2352load_quota:
2353 return vfs_load_quota_inode(inode, type, format_id, flags);
2354}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002355EXPORT_SYMBOL(dquot_enable);
Jan Karaf55abc02008-08-20 17:50:32 +02002356
2357/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 * This function is used when filesystem needs to initialize quotas
2359 * during mount time.
2360 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002361int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Christoph Hellwig84de8562005-06-23 00:09:16 -07002362 int format_id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002363{
Christoph Hellwig84de8562005-06-23 00:09:16 -07002364 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002365 int error;
2366
Jan Karac56818d2009-11-12 15:42:08 +01002367 mutex_lock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig2fa389c2005-06-23 00:09:16 -07002368 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
Jan Karac56818d2009-11-12 15:42:08 +01002369 mutex_unlock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002370 if (IS_ERR(dentry))
2371 return PTR_ERR(dentry);
2372
Jan Kara154f4842005-11-28 13:44:14 -08002373 if (!dentry->d_inode) {
2374 error = -ENOENT;
2375 goto out;
2376 }
2377
Linus Torvalds1da177e2005-04-16 15:20:36 -07002378 error = security_quota_on(dentry);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002379 if (!error)
Jan Karaf55abc02008-08-20 17:50:32 +02002380 error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
2381 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002382
Jan Kara154f4842005-11-28 13:44:14 -08002383out:
Christoph Hellwig84de8562005-06-23 00:09:16 -07002384 dput(dentry);
2385 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002387EXPORT_SYMBOL(dquot_quota_on_mount);
Jan Karab85f4b82008-07-25 01:46:50 -07002388
Jan Kara12095462008-08-20 14:45:12 +02002389static inline qsize_t qbtos(qsize_t blocks)
2390{
2391 return blocks << QIF_DQBLKSIZE_BITS;
2392}
2393
2394static inline qsize_t stoqb(qsize_t space)
2395{
2396 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
2397}
2398
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399/* Generic routine for getting common part of quota structure */
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002400static void do_get_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
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002404 memset(di, 0, sizeof(*di));
2405 di->d_version = FS_DQUOT_VERSION;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002406 di->d_flags = dquot->dq_id.type == USRQUOTA ?
Christoph Hellwigade7ce32010-06-04 10:56:01 +02002407 FS_USER_QUOTA : FS_GROUP_QUOTA;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002408 di->d_id = from_kqid_munged(current_user_ns(), dquot->dq_id);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002409
Linus Torvalds1da177e2005-04-16 15:20:36 -07002410 spin_lock(&dq_data_lock);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002411 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
2412 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
2413 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2414 di->d_ino_softlimit = dm->dqb_isoftlimit;
2415 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
2416 di->d_icount = dm->dqb_curinodes;
2417 di->d_btimer = dm->dqb_btime;
2418 di->d_itimer = dm->dqb_itime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002419 spin_unlock(&dq_data_lock);
2420}
2421
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002422int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
Christoph Hellwig287a8092010-05-19 07:16:45 -04002423 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424{
2425 struct dquot *dquot;
2426
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002427 dquot = dqget(sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +01002428 if (!dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 return -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002430 do_get_dqblk(dquot, di);
2431 dqput(dquot);
Jan Karacc334122009-01-12 17:23:05 +01002432
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 return 0;
2434}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002435EXPORT_SYMBOL(dquot_get_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002436
Christoph Hellwigc472b432010-05-06 17:05:17 -04002437#define VFS_FS_DQ_MASK \
2438 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
2439 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
2440 FS_DQ_BTIMER | FS_DQ_ITIMER)
2441
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442/* Generic routine for setting common part of quota structure */
Christoph Hellwigc472b432010-05-06 17:05:17 -04002443static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002444{
2445 struct mem_dqblk *dm = &dquot->dq_dqb;
2446 int check_blim = 0, check_ilim = 0;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002447 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002448
Christoph Hellwigc472b432010-05-06 17:05:17 -04002449 if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
2450 return -EINVAL;
2451
2452 if (((di->d_fieldmask & FS_DQ_BSOFT) &&
2453 (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
2454 ((di->d_fieldmask & FS_DQ_BHARD) &&
2455 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
2456 ((di->d_fieldmask & FS_DQ_ISOFT) &&
2457 (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
2458 ((di->d_fieldmask & FS_DQ_IHARD) &&
2459 (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002460 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002461
2462 spin_lock(&dq_data_lock);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002463 if (di->d_fieldmask & FS_DQ_BCOUNT) {
2464 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002466 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002468
2469 if (di->d_fieldmask & FS_DQ_BSOFT)
2470 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
2471 if (di->d_fieldmask & FS_DQ_BHARD)
2472 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
2473 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002475 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002476 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002477
2478 if (di->d_fieldmask & FS_DQ_ICOUNT) {
2479 dm->dqb_curinodes = di->d_icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002480 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002481 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002482 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002483
2484 if (di->d_fieldmask & FS_DQ_ISOFT)
2485 dm->dqb_isoftlimit = di->d_ino_softlimit;
2486 if (di->d_fieldmask & FS_DQ_IHARD)
2487 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2488 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002490 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002491 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002492
2493 if (di->d_fieldmask & FS_DQ_BTIMER) {
2494 dm->dqb_btime = di->d_btimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002495 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002496 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002497 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002498
2499 if (di->d_fieldmask & FS_DQ_ITIMER) {
2500 dm->dqb_itime = di->d_itimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002501 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002502 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002503 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504
2505 if (check_blim) {
Jan Kara268157b2009-01-27 15:47:22 +01002506 if (!dm->dqb_bsoftlimit ||
2507 dm->dqb_curspace < dm->dqb_bsoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002508 dm->dqb_btime = 0;
2509 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002510 } else if (!(di->d_fieldmask & FS_DQ_BTIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002511 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002512 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 }
2514 if (check_ilim) {
Jan Kara268157b2009-01-27 15:47:22 +01002515 if (!dm->dqb_isoftlimit ||
2516 dm->dqb_curinodes < dm->dqb_isoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002517 dm->dqb_itime = 0;
2518 clear_bit(DQ_INODES_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002519 } else if (!(di->d_fieldmask & FS_DQ_ITIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002520 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002521 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002522 }
Jan Kara268157b2009-01-27 15:47:22 +01002523 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2524 dm->dqb_isoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002525 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2526 else
2527 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2528 spin_unlock(&dq_data_lock);
2529 mark_dquot_dirty(dquot);
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002530
2531 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532}
2533
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002534int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
Christoph Hellwigc472b432010-05-06 17:05:17 -04002535 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536{
2537 struct dquot *dquot;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002538 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002540 dquot = dqget(sb, qid);
Jan Karaf55abc02008-08-20 17:50:32 +02002541 if (!dquot) {
2542 rc = -ESRCH;
2543 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 }
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002545 rc = do_set_dqblk(dquot, di);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546 dqput(dquot);
Jan Karaf55abc02008-08-20 17:50:32 +02002547out:
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002548 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002550EXPORT_SYMBOL(dquot_set_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002551
2552/* Generic routine for getting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002553int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554{
2555 struct mem_dqinfo *mi;
2556
Ingo Molnard3be9152006-03-23 03:00:29 -08002557 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002558 if (!sb_has_quota_active(sb, type)) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002559 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002560 return -ESRCH;
2561 }
2562 mi = sb_dqopt(sb)->info + type;
2563 spin_lock(&dq_data_lock);
2564 ii->dqi_bgrace = mi->dqi_bgrace;
2565 ii->dqi_igrace = mi->dqi_igrace;
Jan Kara46fe44c2011-11-16 15:03:59 +01002566 ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567 ii->dqi_valid = IIF_ALL;
2568 spin_unlock(&dq_data_lock);
Ingo Molnard3be9152006-03-23 03:00:29 -08002569 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 return 0;
2571}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002572EXPORT_SYMBOL(dquot_get_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002573
2574/* Generic routine for setting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002575int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002576{
2577 struct mem_dqinfo *mi;
Jan Karaf55abc02008-08-20 17:50:32 +02002578 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002579
Ingo Molnard3be9152006-03-23 03:00:29 -08002580 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002581 if (!sb_has_quota_active(sb, type)) {
2582 err = -ESRCH;
2583 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002584 }
2585 mi = sb_dqopt(sb)->info + type;
2586 spin_lock(&dq_data_lock);
2587 if (ii->dqi_valid & IIF_BGRACE)
2588 mi->dqi_bgrace = ii->dqi_bgrace;
2589 if (ii->dqi_valid & IIF_IGRACE)
2590 mi->dqi_igrace = ii->dqi_igrace;
2591 if (ii->dqi_valid & IIF_FLAGS)
Jan Kara46fe44c2011-11-16 15:03:59 +01002592 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) |
2593 (ii->dqi_flags & DQF_SETINFO_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 spin_unlock(&dq_data_lock);
2595 mark_info_dirty(sb, type);
2596 /* Force write to disk */
2597 sb->dq_op->write_info(sb, type);
Jan Karaf55abc02008-08-20 17:50:32 +02002598out:
Ingo Molnard3be9152006-03-23 03:00:29 -08002599 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002600 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002601}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002602EXPORT_SYMBOL(dquot_set_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603
Christoph Hellwig287a8092010-05-19 07:16:45 -04002604const struct quotactl_ops dquot_quotactl_ops = {
2605 .quota_on = dquot_quota_on,
2606 .quota_off = dquot_quota_off,
2607 .quota_sync = dquot_quota_sync,
2608 .get_info = dquot_get_dqinfo,
2609 .set_info = dquot_set_dqinfo,
2610 .get_dqblk = dquot_get_dqblk,
2611 .set_dqblk = dquot_set_dqblk
Linus Torvalds1da177e2005-04-16 15:20:36 -07002612};
Christoph Hellwig287a8092010-05-19 07:16:45 -04002613EXPORT_SYMBOL(dquot_quotactl_ops);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002614
2615static int do_proc_dqstats(struct ctl_table *table, int write,
2616 void __user *buffer, size_t *lenp, loff_t *ppos)
2617{
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002618 unsigned int type = (int *)table->data - dqstats.stat;
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002619
2620 /* Update global table */
2621 dqstats.stat[type] =
2622 percpu_counter_sum_positive(&dqstats.counter[type]);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002623 return proc_dointvec(table, write, buffer, lenp, ppos);
2624}
2625
Joe Perchese6287532013-06-13 19:37:49 -07002626static struct ctl_table fs_dqstats_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002628 .procname = "lookups",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002629 .data = &dqstats.stat[DQST_LOOKUPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002630 .maxlen = sizeof(int),
2631 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002632 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002633 },
2634 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635 .procname = "drops",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002636 .data = &dqstats.stat[DQST_DROPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 .maxlen = sizeof(int),
2638 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002639 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 },
2641 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 .procname = "reads",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002643 .data = &dqstats.stat[DQST_READS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002644 .maxlen = sizeof(int),
2645 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002646 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 },
2648 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002649 .procname = "writes",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002650 .data = &dqstats.stat[DQST_WRITES],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651 .maxlen = sizeof(int),
2652 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002653 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 },
2655 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 .procname = "cache_hits",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002657 .data = &dqstats.stat[DQST_CACHE_HITS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 .maxlen = sizeof(int),
2659 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002660 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 },
2662 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663 .procname = "allocated_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002664 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 .maxlen = sizeof(int),
2666 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002667 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 },
2669 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 .procname = "free_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002671 .data = &dqstats.stat[DQST_FREE_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672 .maxlen = sizeof(int),
2673 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002674 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 },
2676 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677 .procname = "syncs",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002678 .data = &dqstats.stat[DQST_SYNCS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 .maxlen = sizeof(int),
2680 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002681 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 },
Jan Kara8e893462007-10-16 23:29:31 -07002683#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685 .procname = "warnings",
2686 .data = &flag_print_warnings,
2687 .maxlen = sizeof(int),
2688 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08002689 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002690 },
Jan Kara8e893462007-10-16 23:29:31 -07002691#endif
Eric W. Biedermanab092032009-11-05 14:25:10 -08002692 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693};
2694
Joe Perchese6287532013-06-13 19:37:49 -07002695static struct ctl_table fs_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002696 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002697 .procname = "quota",
2698 .mode = 0555,
2699 .child = fs_dqstats_table,
2700 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002701 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702};
2703
Joe Perchese6287532013-06-13 19:37:49 -07002704static struct ctl_table sys_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 .procname = "fs",
2707 .mode = 0555,
2708 .child = fs_table,
2709 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002710 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002711};
2712
2713static int __init dquot_init(void)
2714{
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002715 int i, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 unsigned long nr_hash, order;
2717
2718 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2719
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08002720 register_sysctl_table(sys_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721
Paul Mundt20c2df82007-07-20 10:11:58 +09002722 dquot_cachep = kmem_cache_create("dquot",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723 sizeof(struct dquot), sizeof(unsigned long) * 4,
Paul Jacksonfffb60f2006-03-24 03:16:06 -08002724 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2725 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +09002726 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002727
2728 order = 0;
2729 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2730 if (!dquot_hash)
2731 panic("Cannot create dquot hash table");
2732
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002733 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2734 ret = percpu_counter_init(&dqstats.counter[i], 0);
2735 if (ret)
2736 panic("Cannot create dquot stat counters");
2737 }
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002738
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 /* Find power-of-two hlist_heads which can fit into allocation */
2740 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2741 dq_hash_bits = 0;
2742 do {
2743 dq_hash_bits++;
2744 } while (nr_hash >> dq_hash_bits);
2745 dq_hash_bits--;
2746
2747 nr_hash = 1UL << dq_hash_bits;
2748 dq_hash_mask = nr_hash - 1;
2749 for (i = 0; i < nr_hash; i++)
2750 INIT_HLIST_HEAD(dquot_hash + i);
2751
2752 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2753 nr_hash, order, (PAGE_SIZE << order));
2754
Rusty Russell8e1f9362007-07-17 04:03:17 -07002755 register_shrinker(&dqcache_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002756
Linus Torvalds1da177e2005-04-16 15:20:36 -07002757 return 0;
2758}
2759module_init(dquot_init);