blob: fb2d2e2a89e73544e05dbee329773f3f523fe379 [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
Jan Kara9f985cb2014-04-03 14:46:55 -0700531 dqgrab(dquot);
Jan Kara6362e4d2006-03-23 03:00:17 -0800532 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;
Jan Kara1362f4e2014-02-20 17:02:27 +0100584 /*
585 * ->release_dquot() can be racing with us. Our reference
586 * protects us from new calls to it so just wait for any
587 * outstanding call and recheck the DQ_ACTIVE_B after that.
588 */
589 wait_on_dquot(dquot);
590 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
591 ret = fn(dquot, priv);
592 if (ret < 0)
593 goto out;
594 }
Jan Kara12c77522008-10-20 17:05:00 +0200595 spin_lock(&dq_list_lock);
596 /* We are safe to continue now because our dquot could not
597 * be moved out of the inuse list while we hold the reference */
598 }
599 spin_unlock(&dq_list_lock);
600out:
601 dqput(old_dquot);
602 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
603 return ret;
604}
Mingming Cao08d03502009-01-14 16:19:32 +0100605EXPORT_SYMBOL(dquot_scan_active);
Jan Kara12c77522008-10-20 17:05:00 +0200606
Jan Karaceed1722012-07-03 16:45:28 +0200607/* Write all dquot structures to quota files */
608int dquot_writeback_dquots(struct super_block *sb, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609{
610 struct list_head *dirty;
611 struct dquot *dquot;
612 struct quota_info *dqopt = sb_dqopt(sb);
613 int cnt;
Jan Karaceed1722012-07-03 16:45:28 +0200614 int err, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
Ingo Molnard3be9152006-03-23 03:00:29 -0800616 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
618 if (type != -1 && cnt != type)
619 continue;
Jan Karaf55abc02008-08-20 17:50:32 +0200620 if (!sb_has_quota_active(sb, cnt))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 continue;
622 spin_lock(&dq_list_lock);
623 dirty = &dqopt->info[cnt].dqi_dirty_list;
624 while (!list_empty(dirty)) {
Jan Kara268157b2009-01-27 15:47:22 +0100625 dquot = list_first_entry(dirty, struct dquot,
626 dq_dirty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700627 /* Dirty and inactive can be only bad dquot... */
628 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
629 clear_dquot_dirty(dquot);
630 continue;
631 }
632 /* Now we have active dquot from which someone is
633 * holding reference so we can safely just increase
634 * use count */
Jan Kara9f985cb2014-04-03 14:46:55 -0700635 dqgrab(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400637 dqstats_inc(DQST_LOOKUPS);
Jan Karaceed1722012-07-03 16:45:28 +0200638 err = sb->dq_op->write_dquot(dquot);
639 if (!ret && err)
640 err = ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 dqput(dquot);
642 spin_lock(&dq_list_lock);
643 }
644 spin_unlock(&dq_list_lock);
645 }
646
647 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karaf55abc02008-08-20 17:50:32 +0200648 if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
649 && info_dirty(&dqopt->info[cnt]))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 sb->dq_op->write_info(sb, cnt);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400651 dqstats_inc(DQST_SYNCS);
Ingo Molnard3be9152006-03-23 03:00:29 -0800652 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
Jan Karaceed1722012-07-03 16:45:28 +0200654 return ret;
655}
656EXPORT_SYMBOL(dquot_writeback_dquots);
657
658/* Write all dquot structures to disk and make them visible from userspace */
659int dquot_quota_sync(struct super_block *sb, int type)
660{
661 struct quota_info *dqopt = sb_dqopt(sb);
662 int cnt;
663 int ret;
664
665 ret = dquot_writeback_dquots(sb, type);
666 if (ret)
667 return ret;
668 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500669 return 0;
670
671 /* This is not very clever (and fast) but currently I don't know about
672 * any other simple way of getting quota data to disk and we must get
673 * them there for userspace to be visible... */
674 if (sb->s_op->sync_fs)
675 sb->s_op->sync_fs(sb, 1);
676 sync_blockdev(sb->s_bdev);
677
678 /*
679 * Now when everything is written we can discard the pagecache so
680 * that userspace sees the changes.
681 */
Jan Karaf9ef1782012-04-25 21:10:31 +0200682 mutex_lock(&dqopt->dqonoff_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500683 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
684 if (type != -1 && cnt != type)
685 continue;
686 if (!sb_has_quota_active(sb, cnt))
687 continue;
Jan Karaa80b12c2012-04-25 21:15:53 +0200688 mutex_lock(&dqopt->files[cnt]->i_mutex);
Jan Karaf9ef1782012-04-25 21:10:31 +0200689 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
690 mutex_unlock(&dqopt->files[cnt]->i_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500691 }
Jan Karaf9ef1782012-04-25 21:10:31 +0200692 mutex_unlock(&dqopt->dqonoff_mutex);
Christoph Hellwig5fb324a2010-02-16 03:44:52 -0500693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 return 0;
695}
Christoph Hellwig287a8092010-05-19 07:16:45 -0400696EXPORT_SYMBOL(dquot_quota_sync);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Dave Chinner1ab6c492013-08-28 10:18:09 +1000698static unsigned long
699dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700{
701 struct list_head *head;
702 struct dquot *dquot;
Dave Chinner1ab6c492013-08-28 10:18:09 +1000703 unsigned long freed = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704
Niu Yaweid68aab6b2014-06-04 12:22:13 +0800705 spin_lock(&dq_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 head = free_dquots.prev;
Dave Chinner1ab6c492013-08-28 10:18:09 +1000707 while (head != &free_dquots && sc->nr_to_scan) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 dquot = list_entry(head, struct dquot, dq_free);
709 remove_dquot_hash(dquot);
710 remove_free_dquot(dquot);
711 remove_inuse(dquot);
Jan Kara74f783a2008-08-19 14:51:22 +0200712 do_destroy_dquot(dquot);
Dave Chinner1ab6c492013-08-28 10:18:09 +1000713 sc->nr_to_scan--;
714 freed++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 head = free_dquots.prev;
716 }
Niu Yaweid68aab6b2014-06-04 12:22:13 +0800717 spin_unlock(&dq_list_lock);
Dave Chinner1ab6c492013-08-28 10:18:09 +1000718 return freed;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719}
720
Dave Chinner1ab6c492013-08-28 10:18:09 +1000721static unsigned long
722dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723{
Glauber Costa55f841c2013-08-28 10:17:53 +1000724 return vfs_pressure_ratio(
725 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726}
727
Rusty Russell8e1f9362007-07-17 04:03:17 -0700728static struct shrinker dqcache_shrinker = {
Dave Chinner1ab6c492013-08-28 10:18:09 +1000729 .count_objects = dqcache_shrink_count,
730 .scan_objects = dqcache_shrink_scan,
Rusty Russell8e1f9362007-07-17 04:03:17 -0700731 .seeks = DEFAULT_SEEKS,
732};
733
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734/*
735 * Put reference to dquot
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200737void dqput(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700738{
Jan Karab48d3802008-07-25 01:46:49 -0700739 int ret;
740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (!dquot)
742 return;
Jan Kara62af9b52010-04-19 16:47:20 +0200743#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 if (!atomic_read(&dquot->dq_count)) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200745 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700746 quotatypes[dquot->dq_id.type],
747 from_kqid(&init_user_ns, dquot->dq_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 BUG();
749 }
750#endif
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400751 dqstats_inc(DQST_DROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752we_slept:
753 spin_lock(&dq_list_lock);
754 if (atomic_read(&dquot->dq_count) > 1) {
755 /* We have more than one user... nothing to do */
756 atomic_dec(&dquot->dq_count);
Jan Kara6362e4d2006-03-23 03:00:17 -0800757 /* Releasing dquot during quotaoff phase? */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700758 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) &&
Jan Kara6362e4d2006-03-23 03:00:17 -0800759 atomic_read(&dquot->dq_count) == 1)
760 wake_up(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 spin_unlock(&dq_list_lock);
762 return;
763 }
764 /* Need to release dquot? */
765 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
766 spin_unlock(&dq_list_lock);
767 /* Commit dquot before releasing */
Jan Karab48d3802008-07-25 01:46:49 -0700768 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
769 if (ret < 0) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200770 quota_error(dquot->dq_sb, "Can't write quota structure"
771 " (error %d). Quota may get out of sync!",
772 ret);
Jan Karab48d3802008-07-25 01:46:49 -0700773 /*
774 * We clear dirty bit anyway, so that we avoid
775 * infinite loop here
776 */
777 spin_lock(&dq_list_lock);
778 clear_dquot_dirty(dquot);
779 spin_unlock(&dq_list_lock);
780 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 goto we_slept;
782 }
783 /* Clear flag in case dquot was inactive (something bad happened) */
784 clear_dquot_dirty(dquot);
785 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
786 spin_unlock(&dq_list_lock);
787 dquot->dq_sb->dq_op->release_dquot(dquot);
788 goto we_slept;
789 }
790 atomic_dec(&dquot->dq_count);
Jan Kara62af9b52010-04-19 16:47:20 +0200791#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700792 /* sanity check */
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200793 BUG_ON(!list_empty(&dquot->dq_free));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794#endif
795 put_dquot_last(dquot);
796 spin_unlock(&dq_list_lock);
797}
Mingming Cao08d03502009-01-14 16:19:32 +0100798EXPORT_SYMBOL(dqput);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799
Jan Kara7d9056b2008-11-25 15:31:32 +0100800struct dquot *dquot_alloc(struct super_block *sb, int type)
Jan Kara74f783a2008-08-19 14:51:22 +0200801{
802 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
803}
Jan Kara7d9056b2008-11-25 15:31:32 +0100804EXPORT_SYMBOL(dquot_alloc);
Jan Kara74f783a2008-08-19 14:51:22 +0200805
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806static struct dquot *get_empty_dquot(struct super_block *sb, int type)
807{
808 struct dquot *dquot;
809
Jan Kara74f783a2008-08-19 14:51:22 +0200810 dquot = sb->dq_op->alloc_dquot(sb, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700811 if(!dquot)
Jan Karadd6f3c62009-01-26 16:01:43 +0100812 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Ingo Molnard3be9152006-03-23 03:00:29 -0800814 mutex_init(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 INIT_LIST_HEAD(&dquot->dq_free);
816 INIT_LIST_HEAD(&dquot->dq_inuse);
817 INIT_HLIST_NODE(&dquot->dq_hash);
818 INIT_LIST_HEAD(&dquot->dq_dirty);
Jan Kara6362e4d2006-03-23 03:00:17 -0800819 init_waitqueue_head(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 dquot->dq_sb = sb;
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700821 dquot->dq_id = make_kqid_invalid(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 atomic_set(&dquot->dq_count, 1);
823
824 return dquot;
825}
826
827/*
828 * Get reference to dquot
Jan Karacc334122009-01-12 17:23:05 +0100829 *
830 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
831 * destroying our dquot by:
832 * a) checking for quota flags under dq_list_lock and
833 * b) getting a reference to dquot before we release dq_list_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700834 */
Eric W. Biedermanaca645a2012-09-16 03:11:50 -0700835struct dquot *dqget(struct super_block *sb, struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836{
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700837 unsigned int hashent = hashfn(sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +0100838 struct dquot *dquot = NULL, *empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700840 if (!sb_has_quota_active(sb, qid.type))
Jan Karadd6f3c62009-01-26 16:01:43 +0100841 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842we_slept:
843 spin_lock(&dq_list_lock);
Jan Karacc334122009-01-12 17:23:05 +0100844 spin_lock(&dq_state_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700845 if (!sb_has_quota_active(sb, qid.type)) {
Jan Karacc334122009-01-12 17:23:05 +0100846 spin_unlock(&dq_state_lock);
847 spin_unlock(&dq_list_lock);
848 goto out;
849 }
850 spin_unlock(&dq_state_lock);
851
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700852 dquot = find_dquot(hashent, sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +0100853 if (!dquot) {
854 if (!empty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700855 spin_unlock(&dq_list_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700856 empty = get_empty_dquot(sb, qid.type);
Jan Karadd6f3c62009-01-26 16:01:43 +0100857 if (!empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700858 schedule(); /* Try to wait for a moment... */
859 goto we_slept;
860 }
861 dquot = empty;
Jan Karadd6f3c62009-01-26 16:01:43 +0100862 empty = NULL;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700863 dquot->dq_id = qid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864 /* all dquots go on the inuse_list */
865 put_inuse(dquot);
866 /* hash it first so it can be found */
867 insert_dquot_hash(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700868 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400869 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870 } else {
871 if (!atomic_read(&dquot->dq_count))
872 remove_free_dquot(dquot);
873 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400875 dqstats_inc(DQST_CACHE_HITS);
876 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700877 }
Jan Kara268157b2009-01-27 15:47:22 +0100878 /* Wait for dq_lock - after this we know that either dquot_release() is
879 * already finished or it will be canceled due to dq_count > 1 test */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 wait_on_dquot(dquot);
Jan Kara268157b2009-01-27 15:47:22 +0100881 /* Read the dquot / allocate space in quota file */
882 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
883 sb->dq_op->acquire_dquot(dquot) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 dqput(dquot);
Jan Karadd6f3c62009-01-26 16:01:43 +0100885 dquot = NULL;
Jan Karacc334122009-01-12 17:23:05 +0100886 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700887 }
Jan Kara62af9b52010-04-19 16:47:20 +0200888#ifdef CONFIG_QUOTA_DEBUG
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200889 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890#endif
Jan Karacc334122009-01-12 17:23:05 +0100891out:
892 if (empty)
893 do_destroy_dquot(empty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700894
895 return dquot;
896}
Mingming Cao08d03502009-01-14 16:19:32 +0100897EXPORT_SYMBOL(dqget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898
899static int dqinit_needed(struct inode *inode, int type)
900{
901 int cnt;
902
903 if (IS_NOQUOTA(inode))
904 return 0;
905 if (type != -1)
Jan Karadd6f3c62009-01-26 16:01:43 +0100906 return !inode->i_dquot[type];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karadd6f3c62009-01-26 16:01:43 +0100908 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700909 return 1;
910 return 0;
911}
912
Ingo Molnard3be9152006-03-23 03:00:29 -0800913/* This routine is guarded by dqonoff_mutex mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700914static void add_dquot_ref(struct super_block *sb, int type)
915{
Jan Kara941d2382008-02-06 01:37:36 -0800916 struct inode *inode, *old_inode = NULL;
Jan Kara62af9b52010-04-19 16:47:20 +0200917#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100918 int reserved = 0;
Jan Kara4c5e6c02010-04-06 18:52:47 +0200919#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700920
Dave Chinner55fa6092011-03-22 22:23:40 +1100921 spin_lock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800922 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Dave Chinner250df6e2011-03-22 22:23:36 +1100923 spin_lock(&inode->i_lock);
924 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
925 !atomic_read(&inode->i_writecount) ||
926 !dqinit_needed(inode, type)) {
927 spin_unlock(&inode->i_lock);
Nick Pigginaabb8fd2009-03-11 13:17:36 -0700928 continue;
Dave Chinner250df6e2011-03-22 22:23:36 +1100929 }
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800930 __iget(inode);
Dave Chinner250df6e2011-03-22 22:23:36 +1100931 spin_unlock(&inode->i_lock);
Dave Chinner55fa6092011-03-22 22:23:40 +1100932 spin_unlock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800933
Jan Karad7e97112012-04-24 17:08:41 +0200934#ifdef CONFIG_QUOTA_DEBUG
935 if (unlikely(inode_get_rsv_space(inode) > 0))
936 reserved = 1;
937#endif
Jan Kara941d2382008-02-06 01:37:36 -0800938 iput(old_inode);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500939 __dquot_initialize(inode, type);
Dave Chinner55fa6092011-03-22 22:23:40 +1100940
941 /*
942 * We hold a reference to 'inode' so it couldn't have been
943 * removed from s_inodes list while we dropped the
944 * inode_sb_list_lock We cannot iput the inode now as we can be
945 * holding the last reference and we cannot iput it under
946 * inode_sb_list_lock. So we keep the reference and iput it
947 * later.
948 */
Jan Kara941d2382008-02-06 01:37:36 -0800949 old_inode = inode;
Dave Chinner55fa6092011-03-22 22:23:40 +1100950 spin_lock(&inode_sb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951 }
Dave Chinner55fa6092011-03-22 22:23:40 +1100952 spin_unlock(&inode_sb_list_lock);
Jan Kara941d2382008-02-06 01:37:36 -0800953 iput(old_inode);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100954
Jan Kara62af9b52010-04-19 16:47:20 +0200955#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100956 if (reserved) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200957 quota_error(sb, "Writes happened before quota was turned on "
958 "thus quota information is probably inconsistent. "
959 "Please run quotacheck(8)");
Jan Kara0a5a9c72010-02-09 18:20:39 +0100960 }
Jan Kara4c5e6c02010-04-06 18:52:47 +0200961#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962}
963
Jan Kara268157b2009-01-27 15:47:22 +0100964/*
Jan Kara268157b2009-01-27 15:47:22 +0100965 * Remove references to dquots from inode and add dquot to list for freeing
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300966 * if we have the last reference to dquot
Jan Kara268157b2009-01-27 15:47:22 +0100967 * We can't race with anybody because we hold dqptr_sem for writing...
968 */
Niu Yawei9eb64632014-06-04 12:21:30 +0800969static void remove_inode_dquot_ref(struct inode *inode, int type,
970 struct list_head *tofree_head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971{
972 struct dquot *dquot = inode->i_dquot[type];
973
Jan Karadd6f3c62009-01-26 16:01:43 +0100974 inode->i_dquot[type] = NULL;
Niu Yawei9eb64632014-06-04 12:21:30 +0800975 if (!dquot)
976 return;
977
978 if (list_empty(&dquot->dq_free)) {
979 /*
980 * The inode still has reference to dquot so it can't be in the
981 * free list
982 */
983 spin_lock(&dq_list_lock);
984 list_add(&dquot->dq_free, tofree_head);
985 spin_unlock(&dq_list_lock);
986 } else {
987 /*
988 * Dquot is already in a list to put so we won't drop the last
989 * reference here.
990 */
991 dqput(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993}
994
Jan Kara268157b2009-01-27 15:47:22 +0100995/*
996 * Free list of dquots
997 * Dquots are removed from inodes and no new references can be got so we are
998 * the only ones holding reference
999 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000static void put_dquot_list(struct list_head *tofree_head)
1001{
1002 struct list_head *act_head;
1003 struct dquot *dquot;
1004
1005 act_head = tofree_head->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006 while (act_head != tofree_head) {
1007 dquot = list_entry(act_head, struct dquot, dq_free);
1008 act_head = act_head->next;
Jan Kara268157b2009-01-27 15:47:22 +01001009 /* Remove dquot from the list so we won't have problems... */
1010 list_del_init(&dquot->dq_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001011 dqput(dquot);
1012 }
1013}
1014
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001015static void remove_dquot_ref(struct super_block *sb, int type,
1016 struct list_head *tofree_head)
1017{
1018 struct inode *inode;
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001019 int reserved = 0;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001020
Dave Chinner55fa6092011-03-22 22:23:40 +11001021 spin_lock(&inode_sb_list_lock);
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001022 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Nick Pigginaabb8fd2009-03-11 13:17:36 -07001023 /*
1024 * We have to scan also I_NEW inodes because they can already
1025 * have quota pointer initialized. Luckily, we need to touch
1026 * only quota pointers and these have separate locking
1027 * (dqptr_sem).
1028 */
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001029 if (!IS_NOQUOTA(inode)) {
1030 if (unlikely(inode_get_rsv_space(inode) > 0))
1031 reserved = 1;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001032 remove_inode_dquot_ref(inode, type, tofree_head);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001033 }
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001034 }
Dave Chinner55fa6092011-03-22 22:23:40 +11001035 spin_unlock(&inode_sb_list_lock);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001036#ifdef CONFIG_QUOTA_DEBUG
1037 if (reserved) {
1038 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1039 " was disabled thus quota information is probably "
1040 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1041 }
1042#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001043}
1044
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045/* Gather all references from inodes and drop them */
1046static void drop_dquot_ref(struct super_block *sb, int type)
1047{
1048 LIST_HEAD(tofree_head);
1049
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001050 if (sb->dq_op) {
1051 down_write(&sb_dqopt(sb)->dqptr_sem);
1052 remove_dquot_ref(sb, type, &tofree_head);
1053 up_write(&sb_dqopt(sb)->dqptr_sem);
1054 put_dquot_list(&tofree_head);
1055 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001056}
1057
Jan Kara12095462008-08-20 14:45:12 +02001058static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059{
1060 dquot->dq_dqb.dqb_curinodes += number;
1061}
1062
1063static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
1064{
1065 dquot->dq_dqb.dqb_curspace += number;
1066}
1067
Mingming Caof18df222009-01-13 16:43:09 +01001068static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
1069{
1070 dquot->dq_dqb.dqb_rsvspace += number;
1071}
1072
Mingming Cao740d9dc2009-01-13 16:43:14 +01001073/*
1074 * Claim reserved quota space
1075 */
Jan Kara0a5a9c72010-02-09 18:20:39 +01001076static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001077{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001078 if (dquot->dq_dqb.dqb_rsvspace < number) {
1079 WARN_ON_ONCE(1);
1080 number = dquot->dq_dqb.dqb_rsvspace;
1081 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001082 dquot->dq_dqb.dqb_curspace += number;
1083 dquot->dq_dqb.dqb_rsvspace -= number;
1084}
1085
Jan Kara1c8924e2013-08-17 09:32:32 -04001086static void dquot_reclaim_reserved_space(struct dquot *dquot, qsize_t number)
1087{
1088 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
1089 number = dquot->dq_dqb.dqb_curspace;
1090 dquot->dq_dqb.dqb_rsvspace += number;
1091 dquot->dq_dqb.dqb_curspace -= number;
1092}
1093
Mingming Cao740d9dc2009-01-13 16:43:14 +01001094static inline
1095void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1096{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001097 if (dquot->dq_dqb.dqb_rsvspace >= number)
1098 dquot->dq_dqb.dqb_rsvspace -= number;
1099 else {
1100 WARN_ON_ONCE(1);
1101 dquot->dq_dqb.dqb_rsvspace = 0;
1102 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001103}
1104
Jan Kara7a2435d2009-01-27 01:47:11 +01001105static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001106{
Jan Karadb49d2d2008-10-01 18:21:39 +02001107 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1108 dquot->dq_dqb.dqb_curinodes >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001109 dquot->dq_dqb.dqb_curinodes -= number;
1110 else
1111 dquot->dq_dqb.dqb_curinodes = 0;
1112 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1113 dquot->dq_dqb.dqb_itime = (time_t) 0;
1114 clear_bit(DQ_INODES_B, &dquot->dq_flags);
1115}
1116
Jan Kara7a2435d2009-01-27 01:47:11 +01001117static void dquot_decr_space(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118{
Jan Karadb49d2d2008-10-01 18:21:39 +02001119 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1120 dquot->dq_dqb.dqb_curspace >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001121 dquot->dq_dqb.dqb_curspace -= number;
1122 else
1123 dquot->dq_dqb.dqb_curspace = 0;
Jan Kara12095462008-08-20 14:45:12 +02001124 if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 dquot->dq_dqb.dqb_btime = (time_t) 0;
1126 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1127}
1128
Jan Karabf097aa2012-02-14 13:28:01 +01001129struct dquot_warn {
1130 struct super_block *w_sb;
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001131 struct kqid w_dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001132 short w_type;
1133};
1134
Jan Karac5254602007-12-22 14:03:25 -08001135static int warning_issued(struct dquot *dquot, const int warntype)
1136{
1137 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1138 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1139 ((warntype == QUOTA_NL_IHARDWARN ||
1140 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1141
1142 if (!flag)
1143 return 0;
1144 return test_and_set_bit(flag, &dquot->dq_flags);
1145}
1146
Jan Kara8e893462007-10-16 23:29:31 -07001147#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001148static int flag_print_warnings = 1;
1149
Jan Karabf097aa2012-02-14 13:28:01 +01001150static int need_print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001151{
1152 if (!flag_print_warnings)
1153 return 0;
1154
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001155 switch (warn->w_dq_id.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001156 case USRQUOTA:
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001157 return uid_eq(current_fsuid(), warn->w_dq_id.uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001158 case GRPQUOTA:
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001159 return in_group_p(warn->w_dq_id.gid);
Jan Kara6c29c502012-10-09 23:30:17 +02001160 case PRJQUOTA: /* Never taken... Just make gcc happy */
1161 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 }
1163 return 0;
1164}
1165
Linus Torvalds1da177e2005-04-16 15:20:36 -07001166/* Print warning to user which exceeded quota */
Jan Karabf097aa2012-02-14 13:28:01 +01001167static void print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001168{
1169 char *msg = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001170 struct tty_struct *tty;
Jan Karabf097aa2012-02-14 13:28:01 +01001171 int warntype = warn->w_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001172
Jan Kara657d3bf2008-07-25 01:46:52 -07001173 if (warntype == QUOTA_NL_IHARDBELOW ||
1174 warntype == QUOTA_NL_ISOFTBELOW ||
1175 warntype == QUOTA_NL_BHARDBELOW ||
Jan Karabf097aa2012-02-14 13:28:01 +01001176 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001177 return;
1178
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001179 tty = get_current_tty();
1180 if (!tty)
Alan Cox452a00d2008-10-13 10:39:13 +01001181 return;
Jan Karabf097aa2012-02-14 13:28:01 +01001182 tty_write_message(tty, warn->w_sb->s_id);
Jan Kara8e893462007-10-16 23:29:31 -07001183 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001184 tty_write_message(tty, ": warning, ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185 else
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001186 tty_write_message(tty, ": write failed, ");
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001187 tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001188 switch (warntype) {
Jan Kara8e893462007-10-16 23:29:31 -07001189 case QUOTA_NL_IHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 msg = " file limit reached.\r\n";
1191 break;
Jan Kara8e893462007-10-16 23:29:31 -07001192 case QUOTA_NL_ISOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001193 msg = " file quota exceeded too long.\r\n";
1194 break;
Jan Kara8e893462007-10-16 23:29:31 -07001195 case QUOTA_NL_ISOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 msg = " file quota exceeded.\r\n";
1197 break;
Jan Kara8e893462007-10-16 23:29:31 -07001198 case QUOTA_NL_BHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199 msg = " block limit reached.\r\n";
1200 break;
Jan Kara8e893462007-10-16 23:29:31 -07001201 case QUOTA_NL_BSOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001202 msg = " block quota exceeded too long.\r\n";
1203 break;
Jan Kara8e893462007-10-16 23:29:31 -07001204 case QUOTA_NL_BSOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001205 msg = " block quota exceeded.\r\n";
1206 break;
1207 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001208 tty_write_message(tty, msg);
Alan Cox452a00d2008-10-13 10:39:13 +01001209 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210}
Jan Kara8e893462007-10-16 23:29:31 -07001211#endif
1212
Jan Karabf097aa2012-02-14 13:28:01 +01001213static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1214 int warntype)
1215{
1216 if (warning_issued(dquot, warntype))
1217 return;
1218 warn->w_type = warntype;
1219 warn->w_sb = dquot->dq_sb;
1220 warn->w_dq_id = dquot->dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001221}
1222
Mingming Caof18df222009-01-13 16:43:09 +01001223/*
1224 * Write warnings to the console and send warning messages over netlink.
1225 *
Jan Karabf097aa2012-02-14 13:28:01 +01001226 * Note that this function can call into tty and networking code.
Mingming Caof18df222009-01-13 16:43:09 +01001227 */
Jan Karabf097aa2012-02-14 13:28:01 +01001228static void flush_warnings(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001229{
1230 int i;
1231
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001232 for (i = 0; i < MAXQUOTAS; i++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001233 if (warn[i].w_type == QUOTA_NL_NOWARN)
1234 continue;
Jan Kara8e893462007-10-16 23:29:31 -07001235#ifdef CONFIG_PRINT_QUOTA_WARNING
Jan Karabf097aa2012-02-14 13:28:01 +01001236 print_warning(&warn[i]);
Jan Kara8e893462007-10-16 23:29:31 -07001237#endif
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001238 quota_send_warning(warn[i].w_dq_id,
Jan Karabf097aa2012-02-14 13:28:01 +01001239 warn[i].w_sb->s_dev, warn[i].w_type);
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001240 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241}
1242
Jan Kara7a2435d2009-01-27 01:47:11 +01001243static int ignore_hardlimit(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244{
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001245 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246
1247 return capable(CAP_SYS_RESOURCE) &&
Jan Kara268157b2009-01-27 15:47:22 +01001248 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1249 !(info->dqi_flags & V1_DQF_RSQUASH));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250}
1251
1252/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001253static int check_idq(struct dquot *dquot, qsize_t inodes,
1254 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001255{
Jan Kara268157b2009-01-27 15:47:22 +01001256 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1257
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001258 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001259 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001260 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001261
1262 if (dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001263 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001264 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001265 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001266 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001267 }
1268
1269 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001270 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1271 dquot->dq_dqb.dqb_itime &&
1272 get_seconds() >= dquot->dq_dqb.dqb_itime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001274 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001275 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001276 }
1277
1278 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001279 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 dquot->dq_dqb.dqb_itime == 0) {
Jan Karabf097aa2012-02-14 13:28:01 +01001281 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001282 dquot->dq_dqb.dqb_itime = get_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001283 sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 }
1285
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001286 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287}
1288
1289/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001290static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc,
1291 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001292{
Mingming Caof18df222009-01-13 16:43:09 +01001293 qsize_t tspace;
Jan Kara268157b2009-01-27 15:47:22 +01001294 struct super_block *sb = dquot->dq_sb;
Mingming Caof18df222009-01-13 16:43:09 +01001295
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001296 if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001297 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001298 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Mingming Caof18df222009-01-13 16:43:09 +01001300 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1301 + space;
1302
Linus Torvalds1da177e2005-04-16 15:20:36 -07001303 if (dquot->dq_dqb.dqb_bhardlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001304 tspace > dquot->dq_dqb.dqb_bhardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 !ignore_hardlimit(dquot)) {
1306 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001307 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001308 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001309 }
1310
1311 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001312 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001313 dquot->dq_dqb.dqb_btime &&
1314 get_seconds() >= dquot->dq_dqb.dqb_btime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 !ignore_hardlimit(dquot)) {
1316 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001317 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001318 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 }
1320
1321 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001322 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 dquot->dq_dqb.dqb_btime == 0) {
1324 if (!prealloc) {
Jan Karabf097aa2012-02-14 13:28:01 +01001325 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001326 dquot->dq_dqb.dqb_btime = get_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001327 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 }
1329 else
1330 /*
1331 * We don't allow preallocation to exceed softlimit so exceeding will
1332 * be always printed
1333 */
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001334 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001335 }
1336
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001337 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001338}
1339
Jan Kara12095462008-08-20 14:45:12 +02001340static int info_idq_free(struct dquot *dquot, qsize_t inodes)
Jan Kara657d3bf2008-07-25 01:46:52 -07001341{
Jan Kara268157b2009-01-27 15:47:22 +01001342 qsize_t newinodes;
1343
Jan Kara657d3bf2008-07-25 01:46:52 -07001344 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001345 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001346 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type))
Jan Kara657d3bf2008-07-25 01:46:52 -07001347 return QUOTA_NL_NOWARN;
1348
Jan Kara268157b2009-01-27 15:47:22 +01001349 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1350 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001351 return QUOTA_NL_ISOFTBELOW;
1352 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001353 newinodes < dquot->dq_dqb.dqb_ihardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001354 return QUOTA_NL_IHARDBELOW;
1355 return QUOTA_NL_NOWARN;
1356}
1357
1358static int info_bdq_free(struct dquot *dquot, qsize_t space)
1359{
1360 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Kara12095462008-08-20 14:45:12 +02001361 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001362 return QUOTA_NL_NOWARN;
1363
Jan Kara12095462008-08-20 14:45:12 +02001364 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001365 return QUOTA_NL_BSOFTBELOW;
Jan Kara12095462008-08-20 14:45:12 +02001366 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
1367 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001368 return QUOTA_NL_BHARDBELOW;
1369 return QUOTA_NL_NOWARN;
1370}
Jan Kara0a5a9c72010-02-09 18:20:39 +01001371
Christoph Hellwig189eef52010-06-04 10:56:29 +02001372static int dquot_active(const struct inode *inode)
1373{
1374 struct super_block *sb = inode->i_sb;
1375
1376 if (IS_NOQUOTA(inode))
1377 return 0;
1378 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1379}
1380
Linus Torvalds1da177e2005-04-16 15:20:36 -07001381/*
Christoph Hellwig871a2932010-03-03 09:05:07 -05001382 * Initialize quota pointers in inode
1383 *
1384 * We do things in a bit complicated way but by that we avoid calling
1385 * dqget() and thus filesystem callbacks under dqptr_sem.
1386 *
1387 * It is better to call this function outside of any transaction as it
1388 * might need a lot of space in journal for dquot structure allocation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001389 */
Christoph Hellwig871a2932010-03-03 09:05:07 -05001390static void __dquot_initialize(struct inode *inode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391{
Niu Yawei1ea06be2014-06-04 12:20:30 +08001392 int cnt, init_needed = 0;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001393 struct dquot *got[MAXQUOTAS];
Jan Karacc334122009-01-12 17:23:05 +01001394 struct super_block *sb = inode->i_sb;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001395 qsize_t rsv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001396
Ingo Molnard3be9152006-03-23 03:00:29 -08001397 /* First test before acquiring mutex - solves deadlocks when we
1398 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001399 if (!dquot_active(inode))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001400 return;
Jan Karacc334122009-01-12 17:23:05 +01001401
1402 /* First get references to structures we might need. */
1403 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001404 struct kqid qid;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001405 got[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001406 if (type != -1 && cnt != type)
1407 continue;
Niu Yawei1ea06be2014-06-04 12:20:30 +08001408 /*
1409 * The i_dquot should have been initialized in most cases,
1410 * we check it without locking here to avoid unnecessary
1411 * dqget()/dqput() calls.
1412 */
1413 if (inode->i_dquot[cnt])
1414 continue;
1415 init_needed = 1;
1416
Jan Karacc334122009-01-12 17:23:05 +01001417 switch (cnt) {
1418 case USRQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001419 qid = make_kqid_uid(inode->i_uid);
Jan Karacc334122009-01-12 17:23:05 +01001420 break;
1421 case GRPQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001422 qid = make_kqid_gid(inode->i_gid);
Jan Karacc334122009-01-12 17:23:05 +01001423 break;
1424 }
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001425 got[cnt] = dqget(sb, qid);
Jan Karacc334122009-01-12 17:23:05 +01001426 }
1427
Niu Yawei1ea06be2014-06-04 12:20:30 +08001428 /* All required i_dquot has been initialized */
1429 if (!init_needed)
1430 return;
1431
Jan Karacc334122009-01-12 17:23:05 +01001432 down_write(&sb_dqopt(sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 if (IS_NOQUOTA(inode))
1434 goto out_err;
1435 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1436 if (type != -1 && cnt != type)
1437 continue;
Jan Karacc334122009-01-12 17:23:05 +01001438 /* Avoid races with quotaoff() */
1439 if (!sb_has_quota_active(sb, cnt))
1440 continue;
Jan Kara4408ea42010-10-19 00:24:21 +02001441 /* We could race with quotaon or dqget() could have failed */
1442 if (!got[cnt])
1443 continue;
Jan Karadd6f3c62009-01-26 16:01:43 +01001444 if (!inode->i_dquot[cnt]) {
Jan Karacc334122009-01-12 17:23:05 +01001445 inode->i_dquot[cnt] = got[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001446 got[cnt] = NULL;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001447 /*
1448 * Make quota reservation system happy if someone
1449 * did a write before quota was turned on
1450 */
1451 rsv = inode_get_rsv_space(inode);
Jeff Mahoney68ac8bf2013-02-27 14:43:09 -05001452 if (unlikely(rsv)) {
1453 spin_lock(&dq_data_lock);
Jan Kara0a5a9c72010-02-09 18:20:39 +01001454 dquot_resv_space(inode->i_dquot[cnt], rsv);
Jeff Mahoney68ac8bf2013-02-27 14:43:09 -05001455 spin_unlock(&dq_data_lock);
1456 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457 }
1458 }
1459out_err:
Jan Karacc334122009-01-12 17:23:05 +01001460 up_write(&sb_dqopt(sb)->dqptr_sem);
1461 /* Drop unused references */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001462 dqput_all(got);
Christoph Hellwig871a2932010-03-03 09:05:07 -05001463}
1464
1465void dquot_initialize(struct inode *inode)
1466{
1467 __dquot_initialize(inode, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001468}
Mingming Cao08d03502009-01-14 16:19:32 +01001469EXPORT_SYMBOL(dquot_initialize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470
1471/*
1472 * Release all quotas referenced by inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05001474static void __dquot_drop(struct inode *inode)
Jan Kara3d9ea252008-10-10 16:12:23 +02001475{
Jan Karacc334122009-01-12 17:23:05 +01001476 int cnt;
1477 struct dquot *put[MAXQUOTAS];
1478
Jan Kara3d9ea252008-10-10 16:12:23 +02001479 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001480 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1481 put[cnt] = inode->i_dquot[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001482 inode->i_dquot[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001483 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001485 dqput_all(put);
Christoph Hellwig9f754752010-03-03 09:05:05 -05001486}
1487
1488void dquot_drop(struct inode *inode)
1489{
1490 int cnt;
1491
1492 if (IS_NOQUOTA(inode))
1493 return;
1494
1495 /*
1496 * Test before calling to rule out calls from proc and such
1497 * where we are not allowed to block. Note that this is
1498 * actually reliable test even without the lock - the caller
1499 * must assure that nobody can come after the DQUOT_DROP and
1500 * add quota pointers back anyway.
1501 */
1502 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1503 if (inode->i_dquot[cnt])
1504 break;
1505 }
1506
1507 if (cnt < MAXQUOTAS)
1508 __dquot_drop(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001509}
Mingming Cao08d03502009-01-14 16:19:32 +01001510EXPORT_SYMBOL(dquot_drop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511
1512/*
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001513 * inode_reserved_space is managed internally by quota, and protected by
1514 * i_lock similar to i_blocks+i_bytes.
1515 */
1516static qsize_t *inode_reserved_space(struct inode * inode)
1517{
1518 /* Filesystem must explicitly define it's own method in order to use
1519 * quota reservation interface */
1520 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1521 return inode->i_sb->dq_op->get_reserved_space(inode);
1522}
1523
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001524void inode_add_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001525{
1526 spin_lock(&inode->i_lock);
1527 *inode_reserved_space(inode) += number;
1528 spin_unlock(&inode->i_lock);
1529}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001530EXPORT_SYMBOL(inode_add_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001531
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001532void inode_claim_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001533{
1534 spin_lock(&inode->i_lock);
1535 *inode_reserved_space(inode) -= number;
1536 __inode_add_bytes(inode, number);
1537 spin_unlock(&inode->i_lock);
1538}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001539EXPORT_SYMBOL(inode_claim_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001540
Jan Kara1c8924e2013-08-17 09:32:32 -04001541void inode_reclaim_rsv_space(struct inode *inode, qsize_t number)
1542{
1543 spin_lock(&inode->i_lock);
1544 *inode_reserved_space(inode) += number;
1545 __inode_sub_bytes(inode, number);
1546 spin_unlock(&inode->i_lock);
1547}
1548EXPORT_SYMBOL(inode_reclaim_rsv_space);
1549
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001550void inode_sub_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001551{
1552 spin_lock(&inode->i_lock);
1553 *inode_reserved_space(inode) -= number;
1554 spin_unlock(&inode->i_lock);
1555}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001556EXPORT_SYMBOL(inode_sub_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001557
1558static qsize_t inode_get_rsv_space(struct inode *inode)
1559{
1560 qsize_t ret;
Jan Kara05b5d892010-01-06 18:03:36 +01001561
1562 if (!inode->i_sb->dq_op->get_reserved_space)
1563 return 0;
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001564 spin_lock(&inode->i_lock);
1565 ret = *inode_reserved_space(inode);
1566 spin_unlock(&inode->i_lock);
1567 return ret;
1568}
1569
1570static void inode_incr_space(struct inode *inode, qsize_t number,
1571 int reserve)
1572{
1573 if (reserve)
1574 inode_add_rsv_space(inode, number);
1575 else
1576 inode_add_bytes(inode, number);
1577}
1578
1579static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1580{
1581 if (reserve)
1582 inode_sub_rsv_space(inode, number);
1583 else
1584 inode_sub_bytes(inode, number);
1585}
1586
1587/*
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001588 * This functions updates i_blocks+i_bytes fields and quota information
1589 * (together with appropriate checks).
1590 *
1591 * NOTE: We absolutely rely on the fact that caller dirties the inode
1592 * (usually helpers in quotaops.h care about this) and holds a handle for
1593 * the current transaction so that dquot write and inode write go into the
1594 * same transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 */
1596
1597/*
1598 * This operation can block, but only after everything is updated
1599 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001600int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001601{
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001602 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001603 struct dquot_warn warn[MAXQUOTAS];
1604 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001605 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001606
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001607 /*
1608 * First test before acquiring mutex - solves deadlocks when we
1609 * re-enter the quota code and are already holding the mutex
1610 */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001611 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001612 inode_incr_space(inode, number, reserve);
1613 goto out;
1614 }
1615
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001617 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618
Jeff Liu6ea2eea2012-07-18 12:12:41 +08001619 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001620 spin_lock(&dq_data_lock);
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;
Jan Karabf097aa2012-02-14 13:28:01 +01001624 ret = check_bdq(dquots[cnt], number,
1625 !(flags & DQUOT_SPACE_WARN), &warn[cnt]);
1626 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001627 spin_unlock(&dq_data_lock);
1628 goto out_flush_warn;
Mingming Caof18df222009-01-13 16:43:09 +01001629 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001630 }
1631 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001632 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 continue;
Mingming Caof18df222009-01-13 16:43:09 +01001634 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001635 dquot_resv_space(dquots[cnt], number);
Mingming Caof18df222009-01-13 16:43:09 +01001636 else
Jan Karabf097aa2012-02-14 13:28:01 +01001637 dquot_incr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001638 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001639 inode_incr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001640 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001641
1642 if (reserve)
1643 goto out_flush_warn;
Jan Karabf097aa2012-02-14 13:28:01 +01001644 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001645out_flush_warn:
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001646 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001647 flush_warnings(warn);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001648out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 return ret;
1650}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001651EXPORT_SYMBOL(__dquot_alloc_space);
Mingming Caof18df222009-01-13 16:43:09 +01001652
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653/*
1654 * This operation can block, but only after everything is updated
1655 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001656int dquot_alloc_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001657{
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001658 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001659 struct dquot_warn warn[MAXQUOTAS];
1660 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
Ingo Molnard3be9152006-03-23 03:00:29 -08001662 /* First test before acquiring mutex - solves deadlocks when we
1663 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001664 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001665 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001667 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 spin_lock(&dq_data_lock);
1670 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001671 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001673 ret = check_idq(dquots[cnt], 1, &warn[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001674 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 goto warn_put_all;
1676 }
1677
1678 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001679 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001681 dquot_incr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 }
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001683
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684warn_put_all:
1685 spin_unlock(&dq_data_lock);
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001686 if (ret == 0)
Jan Karabf097aa2012-02-14 13:28:01 +01001687 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001689 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 return ret;
1691}
Mingming Cao08d03502009-01-14 16:19:32 +01001692EXPORT_SYMBOL(dquot_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001694/*
1695 * Convert in-memory reserved quotas to real consumed quotas
1696 */
1697int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001698{
1699 int cnt;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001700
Christoph Hellwig189eef52010-06-04 10:56:29 +02001701 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001702 inode_claim_rsv_space(inode, number);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001703 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001704 }
1705
1706 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001707 spin_lock(&dq_data_lock);
1708 /* Claim reserved quotas to allocated quotas */
1709 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001710 if (inode->i_dquot[cnt])
Mingming Cao740d9dc2009-01-13 16:43:14 +01001711 dquot_claim_reserved_space(inode->i_dquot[cnt],
1712 number);
1713 }
1714 /* Update inode bytes */
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001715 inode_claim_rsv_space(inode, number);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001716 spin_unlock(&dq_data_lock);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001717 mark_all_dquot_dirty(inode->i_dquot);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001718 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001719 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001720}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001721EXPORT_SYMBOL(dquot_claim_space_nodirty);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001722
1723/*
Jan Kara1c8924e2013-08-17 09:32:32 -04001724 * Convert allocated space back to in-memory reserved quotas
1725 */
1726void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
1727{
1728 int cnt;
1729
1730 if (!dquot_active(inode)) {
1731 inode_reclaim_rsv_space(inode, number);
1732 return;
1733 }
1734
1735 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1736 spin_lock(&dq_data_lock);
1737 /* Claim reserved quotas to allocated quotas */
1738 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1739 if (inode->i_dquot[cnt])
1740 dquot_reclaim_reserved_space(inode->i_dquot[cnt],
1741 number);
1742 }
1743 /* Update inode bytes */
1744 inode_reclaim_rsv_space(inode, number);
1745 spin_unlock(&dq_data_lock);
1746 mark_all_dquot_dirty(inode->i_dquot);
1747 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1748 return;
1749}
1750EXPORT_SYMBOL(dquot_reclaim_space_nodirty);
1751
1752/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 * This operation can block, but only after everything is updated
1754 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001755void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756{
1757 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001758 struct dquot_warn warn[MAXQUOTAS];
1759 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001760 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001761
Ingo Molnard3be9152006-03-23 03:00:29 -08001762 /* First test before acquiring mutex - solves deadlocks when we
1763 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001764 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001765 inode_decr_space(inode, number, reserve);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001766 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001767 }
Jan Kara657d3bf2008-07-25 01:46:52 -07001768
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 spin_lock(&dq_data_lock);
1771 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001772 int wtype;
1773
1774 warn[cnt].w_type = QUOTA_NL_NOWARN;
1775 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001777 wtype = info_bdq_free(dquots[cnt], number);
1778 if (wtype != QUOTA_NL_NOWARN)
1779 prepare_warning(&warn[cnt], dquots[cnt], wtype);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001780 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001781 dquot_free_reserved_space(dquots[cnt], number);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001782 else
Jan Karabf097aa2012-02-14 13:28:01 +01001783 dquot_decr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001784 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001785 inode_decr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001787
1788 if (reserve)
1789 goto out_unlock;
Jan Karabf097aa2012-02-14 13:28:01 +01001790 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001791out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001793 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001795EXPORT_SYMBOL(__dquot_free_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001796
1797/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 * This operation can block, but only after everything is updated
1799 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001800void dquot_free_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801{
1802 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001803 struct dquot_warn warn[MAXQUOTAS];
1804 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
Ingo Molnard3be9152006-03-23 03:00:29 -08001806 /* First test before acquiring mutex - solves deadlocks when we
1807 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001808 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001809 return;
Jan Kara657d3bf2008-07-25 01:46:52 -07001810
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001812 spin_lock(&dq_data_lock);
1813 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001814 int wtype;
1815
1816 warn[cnt].w_type = QUOTA_NL_NOWARN;
1817 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001819 wtype = info_idq_free(dquots[cnt], 1);
1820 if (wtype != QUOTA_NL_NOWARN)
1821 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1822 dquot_decr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 }
1824 spin_unlock(&dq_data_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01001825 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001827 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001828}
Mingming Cao08d03502009-01-14 16:19:32 +01001829EXPORT_SYMBOL(dquot_free_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830
1831/*
1832 * Transfer the number of inode and blocks from one diskquota to an other.
Jan Karabc8e5f02010-05-13 19:58:50 +02001833 * On success, dquot references in transfer_to are consumed and references
1834 * to original dquots that need to be released are placed there. On failure,
1835 * references are kept untouched.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 *
1837 * This operation can block, but only after everything is updated
1838 * A transaction must be started when entering this function.
Jan Karabc8e5f02010-05-13 19:58:50 +02001839 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 */
Jan Karabc8e5f02010-05-13 19:58:50 +02001841int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842{
Mingming Cao740d9dc2009-01-13 16:43:14 +01001843 qsize_t space, cur_space;
1844 qsize_t rsv_space = 0;
Jan Karabc8e5f02010-05-13 19:58:50 +02001845 struct dquot *transfer_from[MAXQUOTAS] = {};
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001846 int cnt, ret = 0;
Dmitry9e327842010-10-09 23:15:30 +04001847 char is_valid[MAXQUOTAS] = {};
Jan Karabf097aa2012-02-14 13:28:01 +01001848 struct dquot_warn warn_to[MAXQUOTAS];
1849 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1850 struct dquot_warn warn_from_space[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001851
Ingo Molnard3be9152006-03-23 03:00:29 -08001852 /* First test before acquiring mutex - solves deadlocks when we
1853 * re-enter the quota code and are already holding the mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 if (IS_NOQUOTA(inode))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001855 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001856 /* Initialize the arrays */
Jan Karabf097aa2012-02-14 13:28:01 +01001857 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1858 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1859 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1860 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1861 }
Jan Karacc334122009-01-12 17:23:05 +01001862 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001863 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
1864 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabc8e5f02010-05-13 19:58:50 +02001865 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001866 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 spin_lock(&dq_data_lock);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001868 cur_space = inode_get_bytes(inode);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001869 rsv_space = inode_get_rsv_space(inode);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001870 space = cur_space + rsv_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 /* Build the transfer_from list and check the limits */
1872 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001873 /*
1874 * Skip changes for same uid or gid or for turned off quota-type.
1875 */
Jan Karadd6f3c62009-01-26 16:01:43 +01001876 if (!transfer_to[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 continue;
Dmitry9e327842010-10-09 23:15:30 +04001878 /* Avoid races with quotaoff() */
1879 if (!sb_has_quota_active(inode->i_sb, cnt))
1880 continue;
1881 is_valid[cnt] = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 transfer_from[cnt] = inode->i_dquot[cnt];
Jan Karabf097aa2012-02-14 13:28:01 +01001883 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001884 if (ret)
1885 goto over_quota;
Jan Karabf097aa2012-02-14 13:28:01 +01001886 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001887 if (ret)
Jan Karacc334122009-01-12 17:23:05 +01001888 goto over_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889 }
1890
1891 /*
1892 * Finally perform the needed transfer from transfer_from to transfer_to
1893 */
1894 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001895 if (!is_valid[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001896 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 /* Due to IO error we might not have transfer_from[] structure */
1898 if (transfer_from[cnt]) {
Jan Karabf097aa2012-02-14 13:28:01 +01001899 int wtype;
1900 wtype = info_idq_free(transfer_from[cnt], 1);
1901 if (wtype != QUOTA_NL_NOWARN)
1902 prepare_warning(&warn_from_inodes[cnt],
1903 transfer_from[cnt], wtype);
1904 wtype = info_bdq_free(transfer_from[cnt], space);
1905 if (wtype != QUOTA_NL_NOWARN)
1906 prepare_warning(&warn_from_space[cnt],
1907 transfer_from[cnt], wtype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908 dquot_decr_inodes(transfer_from[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001909 dquot_decr_space(transfer_from[cnt], cur_space);
1910 dquot_free_reserved_space(transfer_from[cnt],
1911 rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001912 }
1913
1914 dquot_incr_inodes(transfer_to[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001915 dquot_incr_space(transfer_to[cnt], cur_space);
1916 dquot_resv_space(transfer_to[cnt], rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
1918 inode->i_dquot[cnt] = transfer_to[cnt];
1919 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 spin_unlock(&dq_data_lock);
Jan Karacc334122009-01-12 17:23:05 +01001921 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1922
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001923 mark_all_dquot_dirty(transfer_from);
1924 mark_all_dquot_dirty(transfer_to);
Jan Karabf097aa2012-02-14 13:28:01 +01001925 flush_warnings(warn_to);
1926 flush_warnings(warn_from_inodes);
1927 flush_warnings(warn_from_space);
Jan Karabc8e5f02010-05-13 19:58:50 +02001928 /* Pass back references to put */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001929 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Dmitry9e327842010-10-09 23:15:30 +04001930 if (is_valid[cnt])
1931 transfer_to[cnt] = transfer_from[cnt];
Jan Kara86f3cbe2010-10-11 15:22:21 +02001932 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001933over_quota:
1934 spin_unlock(&dq_data_lock);
1935 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001936 flush_warnings(warn_to);
Jan Kara86f3cbe2010-10-11 15:22:21 +02001937 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938}
Jan Karabc8e5f02010-05-13 19:58:50 +02001939EXPORT_SYMBOL(__dquot_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001941/* Wrapper for transferring ownership of an inode for uid/gid only
1942 * Called from FSXXX_setattr()
1943 */
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001944int dquot_transfer(struct inode *inode, struct iattr *iattr)
Jan Karab85f4b82008-07-25 01:46:50 -07001945{
Jan Karabc8e5f02010-05-13 19:58:50 +02001946 struct dquot *transfer_to[MAXQUOTAS] = {};
1947 struct super_block *sb = inode->i_sb;
1948 int ret;
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001949
Christoph Hellwig189eef52010-06-04 10:56:29 +02001950 if (!dquot_active(inode))
Jan Karabc8e5f02010-05-13 19:58:50 +02001951 return 0;
Dmitry Monakhov12755622010-04-08 22:04:20 +04001952
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001953 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid))
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001954 transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(iattr->ia_uid));
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001955 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001956 transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(iattr->ia_gid));
Jan Karabc8e5f02010-05-13 19:58:50 +02001957
1958 ret = __dquot_transfer(inode, transfer_to);
1959 dqput_all(transfer_to);
1960 return ret;
Jan Karab85f4b82008-07-25 01:46:50 -07001961}
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001962EXPORT_SYMBOL(dquot_transfer);
Jan Karab85f4b82008-07-25 01:46:50 -07001963
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964/*
1965 * Write info of quota file to disk
1966 */
1967int dquot_commit_info(struct super_block *sb, int type)
1968{
1969 int ret;
1970 struct quota_info *dqopt = sb_dqopt(sb);
1971
Ingo Molnard3be9152006-03-23 03:00:29 -08001972 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 ret = dqopt->ops[type]->write_file_info(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08001974 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 return ret;
1976}
Mingming Cao08d03502009-01-14 16:19:32 +01001977EXPORT_SYMBOL(dquot_commit_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978
1979/*
1980 * Definitions of diskquota operations.
1981 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -07001982const struct dquot_operations dquot_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983 .write_dquot = dquot_commit,
1984 .acquire_dquot = dquot_acquire,
1985 .release_dquot = dquot_release,
1986 .mark_dirty = dquot_mark_dquot_dirty,
Jan Kara74f783a2008-08-19 14:51:22 +02001987 .write_info = dquot_commit_info,
1988 .alloc_dquot = dquot_alloc,
1989 .destroy_dquot = dquot_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990};
Christoph Hellwig123e9ca2010-05-19 07:16:44 -04001991EXPORT_SYMBOL(dquot_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992
Linus Torvalds1da177e2005-04-16 15:20:36 -07001993/*
Christoph Hellwig907f4552010-03-03 09:05:06 -05001994 * Generic helper for ->open on filesystems supporting disk quotas.
1995 */
1996int dquot_file_open(struct inode *inode, struct file *file)
1997{
1998 int error;
1999
2000 error = generic_file_open(inode, file);
2001 if (!error && (file->f_mode & FMODE_WRITE))
Christoph Hellwig871a2932010-03-03 09:05:07 -05002002 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -05002003 return error;
2004}
2005EXPORT_SYMBOL(dquot_file_open);
2006
2007/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002008 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
2009 */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002010int dquot_disable(struct super_block *sb, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011{
Jan Kara0ff5af82008-04-28 02:14:33 -07002012 int cnt, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 struct quota_info *dqopt = sb_dqopt(sb);
2014 struct inode *toputinode[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015
Jan Karaf55abc02008-08-20 17:50:32 +02002016 /* Cannot turn off usage accounting without turning off limits, or
2017 * suspend quotas and simultaneously turn quotas off. */
2018 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
2019 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
2020 DQUOT_USAGE_ENABLED)))
2021 return -EINVAL;
2022
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 /* We need to serialize quota_off() for device */
Ingo Molnard3be9152006-03-23 03:00:29 -08002024 mutex_lock(&dqopt->dqonoff_mutex);
Jan Kara9377abd2008-05-12 14:02:08 -07002025
2026 /*
2027 * Skip everything if there's nothing to do. We have to do this because
2028 * sometimes we are called when fill_super() failed and calling
2029 * sync_fs() in such cases does no good.
2030 */
Jan Karaf55abc02008-08-20 17:50:32 +02002031 if (!sb_any_quota_loaded(sb)) {
Jan Kara9377abd2008-05-12 14:02:08 -07002032 mutex_unlock(&dqopt->dqonoff_mutex);
2033 return 0;
2034 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002035 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2036 toputinode[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 if (type != -1 && cnt != type)
2038 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002039 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002040 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002041
2042 if (flags & DQUOT_SUSPENDED) {
Jan Karacc334122009-01-12 17:23:05 +01002043 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002044 dqopt->flags |=
2045 dquot_state_flag(DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002046 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002047 } else {
Jan Karacc334122009-01-12 17:23:05 +01002048 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002049 dqopt->flags &= ~dquot_state_flag(flags, cnt);
2050 /* Turning off suspended quotas? */
2051 if (!sb_has_quota_loaded(sb, cnt) &&
2052 sb_has_quota_suspended(sb, cnt)) {
2053 dqopt->flags &= ~dquot_state_flag(
2054 DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002055 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002056 iput(dqopt->files[cnt]);
2057 dqopt->files[cnt] = NULL;
2058 continue;
2059 }
Jan Karacc334122009-01-12 17:23:05 +01002060 spin_unlock(&dq_state_lock);
Jan Kara0ff5af82008-04-28 02:14:33 -07002061 }
Jan Karaf55abc02008-08-20 17:50:32 +02002062
2063 /* We still have to keep quota loaded? */
2064 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002066
2067 /* Note: these are blocking operations */
2068 drop_dquot_ref(sb, cnt);
2069 invalidate_dquots(sb, cnt);
2070 /*
Jan Kara268157b2009-01-27 15:47:22 +01002071 * Now all dquots should be invalidated, all writes done so we
2072 * should be only users of the info. No locks needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 */
2074 if (info_dirty(&dqopt->info[cnt]))
2075 sb->dq_op->write_info(sb, cnt);
2076 if (dqopt->ops[cnt]->free_file_info)
2077 dqopt->ops[cnt]->free_file_info(sb, cnt);
2078 put_quota_format(dqopt->info[cnt].dqi_format);
2079
2080 toputinode[cnt] = dqopt->files[cnt];
Jan Karaf55abc02008-08-20 17:50:32 +02002081 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002082 dqopt->files[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002083 dqopt->info[cnt].dqi_flags = 0;
2084 dqopt->info[cnt].dqi_igrace = 0;
2085 dqopt->info[cnt].dqi_bgrace = 0;
2086 dqopt->ops[cnt] = NULL;
2087 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002088 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002089
2090 /* Skip syncing and setting flags if quota files are hidden */
2091 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2092 goto put_inodes;
2093
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 /* Sync the superblock so that buffers with quota data are written to
Al Viro7b7b1ac2005-11-07 17:13:39 -05002095 * disk (and so userspace sees correct data afterwards). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 if (sb->s_op->sync_fs)
2097 sb->s_op->sync_fs(sb, 1);
2098 sync_blockdev(sb->s_bdev);
2099 /* Now the quota files are just ordinary files and we can set the
2100 * inode flags back. Moreover we discard the pagecache so that
2101 * userspace sees the writes we did bypassing the pagecache. We
2102 * must also discard the blockdev buffers so that we see the
2103 * changes done by userspace on the next quotaon() */
2104 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2105 if (toputinode[cnt]) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002106 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 /* If quota was reenabled in the meantime, we have
2108 * nothing to do */
Jan Karaf55abc02008-08-20 17:50:32 +02002109 if (!sb_has_quota_loaded(sb, cnt)) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002110 mutex_lock(&toputinode[cnt]->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002111 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
2112 S_NOATIME | S_NOQUOTA);
Jan Kara268157b2009-01-27 15:47:22 +01002113 truncate_inode_pages(&toputinode[cnt]->i_data,
2114 0);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002115 mutex_unlock(&toputinode[cnt]->i_mutex);
Jan Kara43d29322010-07-21 14:22:21 +02002116 mark_inode_dirty_sync(toputinode[cnt]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002118 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002119 }
2120 if (sb->s_bdev)
2121 invalidate_bdev(sb->s_bdev);
2122put_inodes:
2123 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2124 if (toputinode[cnt]) {
Jan Kara0ff5af82008-04-28 02:14:33 -07002125 /* On remount RO, we keep the inode pointer so that we
Jan Karaf55abc02008-08-20 17:50:32 +02002126 * can reenable quota on the subsequent remount RW. We
2127 * have to check 'flags' variable and not use sb_has_
2128 * function because another quotaon / quotaoff could
2129 * change global state before we got here. We refuse
2130 * to suspend quotas when there is pending delete on
2131 * the quota file... */
2132 if (!(flags & DQUOT_SUSPENDED))
Jan Kara0ff5af82008-04-28 02:14:33 -07002133 iput(toputinode[cnt]);
2134 else if (!toputinode[cnt]->i_nlink)
2135 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002136 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002137 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002138}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002139EXPORT_SYMBOL(dquot_disable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140
Christoph Hellwig287a8092010-05-19 07:16:45 -04002141int dquot_quota_off(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +02002142{
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002143 return dquot_disable(sb, type,
2144 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Jan Karaf55abc02008-08-20 17:50:32 +02002145}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002146EXPORT_SYMBOL(dquot_quota_off);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002147
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148/*
2149 * Turn quotas on on a device
2150 */
2151
Jan Karaf55abc02008-08-20 17:50:32 +02002152/*
2153 * Helper function to turn quotas on when we already have the inode of
2154 * quota file and no quota information is loaded.
2155 */
2156static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2157 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158{
2159 struct quota_format_type *fmt = find_quota_format(format_id);
2160 struct super_block *sb = inode->i_sb;
2161 struct quota_info *dqopt = sb_dqopt(sb);
2162 int error;
2163 int oldflags = -1;
2164
2165 if (!fmt)
2166 return -ESRCH;
2167 if (!S_ISREG(inode->i_mode)) {
2168 error = -EACCES;
2169 goto out_fmt;
2170 }
2171 if (IS_RDONLY(inode)) {
2172 error = -EROFS;
2173 goto out_fmt;
2174 }
2175 if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
2176 error = -EINVAL;
2177 goto out_fmt;
2178 }
Jan Karaf55abc02008-08-20 17:50:32 +02002179 /* Usage always has to be set... */
2180 if (!(flags & DQUOT_USAGE_ENABLED)) {
2181 error = -EINVAL;
2182 goto out_fmt;
2183 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184
Jan Karaca785ec2008-09-30 17:53:37 +02002185 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
Jan Karaab94c392010-02-22 21:07:17 +01002186 /* As we bypass the pagecache we must now flush all the
2187 * dirty data and invalidate caches so that kernel sees
2188 * changes from userspace. It is not enough to just flush
2189 * the quota file since if blocksize < pagesize, invalidation
2190 * of the cache could fail because of other unrelated dirty
2191 * data */
2192 sync_filesystem(sb);
Jan Karaca785ec2008-09-30 17:53:37 +02002193 invalidate_bdev(sb->s_bdev);
2194 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002195 mutex_lock(&dqopt->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002196 if (sb_has_quota_loaded(sb, type)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197 error = -EBUSY;
2198 goto out_lock;
2199 }
Jan Karaca785ec2008-09-30 17:53:37 +02002200
2201 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2202 /* We don't want quota and atime on quota files (deadlocks
2203 * possible) Also nobody should write to the file - we use
2204 * special IO operations which ignore the immutable bit. */
Jan Karaa80b12c2012-04-25 21:15:53 +02002205 mutex_lock(&inode->i_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002206 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2207 S_NOQUOTA);
Jan Karaca785ec2008-09-30 17:53:37 +02002208 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
Jan Karadee86562009-07-22 18:12:17 +02002209 mutex_unlock(&inode->i_mutex);
Jan Kara26245c92010-01-06 17:20:35 +01002210 /*
2211 * When S_NOQUOTA is set, remove dquot references as no more
2212 * references can be added
2213 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05002214 __dquot_drop(inode);
Jan Karaca785ec2008-09-30 17:53:37 +02002215 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
2217 error = -EIO;
2218 dqopt->files[type] = igrab(inode);
2219 if (!dqopt->files[type])
2220 goto out_lock;
2221 error = -EINVAL;
2222 if (!fmt->qf_ops->check_quota_file(sb, type))
2223 goto out_file_init;
2224
2225 dqopt->ops[type] = fmt->qf_ops;
2226 dqopt->info[type].dqi_format = fmt;
Jan Kara0ff5af82008-04-28 02:14:33 -07002227 dqopt->info[type].dqi_fmt_id = format_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
Ingo Molnard3be9152006-03-23 03:00:29 -08002229 mutex_lock(&dqopt->dqio_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002230 error = dqopt->ops[type]->read_file_info(sb, type);
2231 if (error < 0) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002232 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233 goto out_file_init;
2234 }
Jan Kara46fe44c2011-11-16 15:03:59 +01002235 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2236 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
Ingo Molnard3be9152006-03-23 03:00:29 -08002237 mutex_unlock(&dqopt->dqio_mutex);
Jan Karacc334122009-01-12 17:23:05 +01002238 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002239 dqopt->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002240 spin_unlock(&dq_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241
2242 add_dquot_ref(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08002243 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244
2245 return 0;
2246
2247out_file_init:
2248 dqopt->files[type] = NULL;
2249 iput(inode);
2250out_lock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251 if (oldflags != -1) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002252 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 /* Set the flags back (in the case of accidental quotaon()
2254 * on a wrong file we don't want to mess up the flags) */
2255 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2256 inode->i_flags |= oldflags;
Jan Karadee86562009-07-22 18:12:17 +02002257 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258 }
Jiaying Zhangd01730d2009-07-07 18:15:21 +02002259 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260out_fmt:
2261 put_quota_format(fmt);
2262
2263 return error;
2264}
2265
Jan Kara0ff5af82008-04-28 02:14:33 -07002266/* Reenable quotas on remount RW */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002267int dquot_resume(struct super_block *sb, int type)
Jan Kara0ff5af82008-04-28 02:14:33 -07002268{
2269 struct quota_info *dqopt = sb_dqopt(sb);
2270 struct inode *inode;
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002271 int ret = 0, cnt;
Jan Karaf55abc02008-08-20 17:50:32 +02002272 unsigned int flags;
Jan Kara0ff5af82008-04-28 02:14:33 -07002273
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002274 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2275 if (type != -1 && cnt != type)
2276 continue;
Jan Kara0ff5af82008-04-28 02:14:33 -07002277
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002278 mutex_lock(&dqopt->dqonoff_mutex);
2279 if (!sb_has_quota_suspended(sb, cnt)) {
2280 mutex_unlock(&dqopt->dqonoff_mutex);
2281 continue;
2282 }
2283 inode = dqopt->files[cnt];
2284 dqopt->files[cnt] = NULL;
2285 spin_lock(&dq_state_lock);
2286 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2287 DQUOT_LIMITS_ENABLED,
2288 cnt);
2289 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2290 spin_unlock(&dq_state_lock);
2291 mutex_unlock(&dqopt->dqonoff_mutex);
2292
2293 flags = dquot_generic_flag(flags, cnt);
2294 ret = vfs_load_quota_inode(inode, cnt,
2295 dqopt->info[cnt].dqi_fmt_id, flags);
2296 iput(inode);
2297 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002298
2299 return ret;
2300}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002301EXPORT_SYMBOL(dquot_resume);
Jan Kara0ff5af82008-04-28 02:14:33 -07002302
Jan Karaf00c9e42010-09-15 17:38:58 +02002303int dquot_quota_on(struct super_block *sb, int type, int format_id,
2304 struct path *path)
Al Viro77e69da2008-08-01 04:29:18 -04002305{
2306 int error = security_quota_on(path->dentry);
2307 if (error)
2308 return error;
2309 /* Quota file not on the same filesystem? */
Al Virod8c95842011-12-07 18:16:57 -05002310 if (path->dentry->d_sb != sb)
Al Viro77e69da2008-08-01 04:29:18 -04002311 error = -EXDEV;
2312 else
Jan Karaf55abc02008-08-20 17:50:32 +02002313 error = vfs_load_quota_inode(path->dentry->d_inode, type,
2314 format_id, DQUOT_USAGE_ENABLED |
2315 DQUOT_LIMITS_ENABLED);
Al Viro77e69da2008-08-01 04:29:18 -04002316 return error;
2317}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002318EXPORT_SYMBOL(dquot_quota_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002319
2320/*
Jan Karaf55abc02008-08-20 17:50:32 +02002321 * More powerful function for turning on quotas allowing setting
2322 * of individual quota flags
2323 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002324int dquot_enable(struct inode *inode, int type, int format_id,
2325 unsigned int flags)
Jan Karaf55abc02008-08-20 17:50:32 +02002326{
2327 int ret = 0;
2328 struct super_block *sb = inode->i_sb;
2329 struct quota_info *dqopt = sb_dqopt(sb);
2330
2331 /* Just unsuspend quotas? */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002332 BUG_ON(flags & DQUOT_SUSPENDED);
2333
Jan Karaf55abc02008-08-20 17:50:32 +02002334 if (!flags)
2335 return 0;
2336 /* Just updating flags needed? */
2337 if (sb_has_quota_loaded(sb, type)) {
2338 mutex_lock(&dqopt->dqonoff_mutex);
2339 /* Now do a reliable test... */
2340 if (!sb_has_quota_loaded(sb, type)) {
2341 mutex_unlock(&dqopt->dqonoff_mutex);
2342 goto load_quota;
2343 }
2344 if (flags & DQUOT_USAGE_ENABLED &&
2345 sb_has_quota_usage_enabled(sb, type)) {
2346 ret = -EBUSY;
2347 goto out_lock;
2348 }
2349 if (flags & DQUOT_LIMITS_ENABLED &&
2350 sb_has_quota_limits_enabled(sb, type)) {
2351 ret = -EBUSY;
2352 goto out_lock;
2353 }
Jan Karacc334122009-01-12 17:23:05 +01002354 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002355 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002356 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002357out_lock:
2358 mutex_unlock(&dqopt->dqonoff_mutex);
2359 return ret;
2360 }
2361
2362load_quota:
2363 return vfs_load_quota_inode(inode, type, format_id, flags);
2364}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002365EXPORT_SYMBOL(dquot_enable);
Jan Karaf55abc02008-08-20 17:50:32 +02002366
2367/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002368 * This function is used when filesystem needs to initialize quotas
2369 * during mount time.
2370 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002371int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Christoph Hellwig84de8562005-06-23 00:09:16 -07002372 int format_id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373{
Christoph Hellwig84de8562005-06-23 00:09:16 -07002374 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 int error;
2376
Jan Karac56818d2009-11-12 15:42:08 +01002377 mutex_lock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig2fa389c2005-06-23 00:09:16 -07002378 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
Jan Karac56818d2009-11-12 15:42:08 +01002379 mutex_unlock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002380 if (IS_ERR(dentry))
2381 return PTR_ERR(dentry);
2382
Jan Kara154f4842005-11-28 13:44:14 -08002383 if (!dentry->d_inode) {
2384 error = -ENOENT;
2385 goto out;
2386 }
2387
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 error = security_quota_on(dentry);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002389 if (!error)
Jan Karaf55abc02008-08-20 17:50:32 +02002390 error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
2391 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002392
Jan Kara154f4842005-11-28 13:44:14 -08002393out:
Christoph Hellwig84de8562005-06-23 00:09:16 -07002394 dput(dentry);
2395 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002396}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002397EXPORT_SYMBOL(dquot_quota_on_mount);
Jan Karab85f4b82008-07-25 01:46:50 -07002398
Jan Kara12095462008-08-20 14:45:12 +02002399static inline qsize_t qbtos(qsize_t blocks)
2400{
2401 return blocks << QIF_DQBLKSIZE_BITS;
2402}
2403
2404static inline qsize_t stoqb(qsize_t space)
2405{
2406 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
2407}
2408
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409/* Generic routine for getting common part of quota structure */
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002410static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002411{
2412 struct mem_dqblk *dm = &dquot->dq_dqb;
2413
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002414 memset(di, 0, sizeof(*di));
2415 di->d_version = FS_DQUOT_VERSION;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002416 di->d_flags = dquot->dq_id.type == USRQUOTA ?
Christoph Hellwigade7ce32010-06-04 10:56:01 +02002417 FS_USER_QUOTA : FS_GROUP_QUOTA;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002418 di->d_id = from_kqid_munged(current_user_ns(), dquot->dq_id);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002419
Linus Torvalds1da177e2005-04-16 15:20:36 -07002420 spin_lock(&dq_data_lock);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002421 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
2422 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
2423 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2424 di->d_ino_softlimit = dm->dqb_isoftlimit;
2425 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
2426 di->d_icount = dm->dqb_curinodes;
2427 di->d_btimer = dm->dqb_btime;
2428 di->d_itimer = dm->dqb_itime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002429 spin_unlock(&dq_data_lock);
2430}
2431
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002432int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
Christoph Hellwig287a8092010-05-19 07:16:45 -04002433 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002434{
2435 struct dquot *dquot;
2436
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002437 dquot = dqget(sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +01002438 if (!dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002439 return -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002440 do_get_dqblk(dquot, di);
2441 dqput(dquot);
Jan Karacc334122009-01-12 17:23:05 +01002442
Linus Torvalds1da177e2005-04-16 15:20:36 -07002443 return 0;
2444}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002445EXPORT_SYMBOL(dquot_get_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002446
Christoph Hellwigc472b432010-05-06 17:05:17 -04002447#define VFS_FS_DQ_MASK \
2448 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
2449 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
2450 FS_DQ_BTIMER | FS_DQ_ITIMER)
2451
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452/* Generic routine for setting common part of quota structure */
Christoph Hellwigc472b432010-05-06 17:05:17 -04002453static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002454{
2455 struct mem_dqblk *dm = &dquot->dq_dqb;
2456 int check_blim = 0, check_ilim = 0;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002457 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002458
Christoph Hellwigc472b432010-05-06 17:05:17 -04002459 if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
2460 return -EINVAL;
2461
2462 if (((di->d_fieldmask & FS_DQ_BSOFT) &&
2463 (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
2464 ((di->d_fieldmask & FS_DQ_BHARD) &&
2465 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
2466 ((di->d_fieldmask & FS_DQ_ISOFT) &&
2467 (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
2468 ((di->d_fieldmask & FS_DQ_IHARD) &&
2469 (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002470 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471
2472 spin_lock(&dq_data_lock);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002473 if (di->d_fieldmask & FS_DQ_BCOUNT) {
2474 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002476 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002477 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002478
2479 if (di->d_fieldmask & FS_DQ_BSOFT)
2480 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
2481 if (di->d_fieldmask & FS_DQ_BHARD)
2482 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
2483 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002485 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002486 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002487
2488 if (di->d_fieldmask & FS_DQ_ICOUNT) {
2489 dm->dqb_curinodes = di->d_icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002491 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002492 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002493
2494 if (di->d_fieldmask & FS_DQ_ISOFT)
2495 dm->dqb_isoftlimit = di->d_ino_softlimit;
2496 if (di->d_fieldmask & FS_DQ_IHARD)
2497 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2498 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002500 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002501 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002502
2503 if (di->d_fieldmask & FS_DQ_BTIMER) {
2504 dm->dqb_btime = di->d_btimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002505 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002506 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002507 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002508
2509 if (di->d_fieldmask & FS_DQ_ITIMER) {
2510 dm->dqb_itime = di->d_itimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002511 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002512 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002513 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514
2515 if (check_blim) {
Jan Kara268157b2009-01-27 15:47:22 +01002516 if (!dm->dqb_bsoftlimit ||
2517 dm->dqb_curspace < dm->dqb_bsoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518 dm->dqb_btime = 0;
2519 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002520 } else if (!(di->d_fieldmask & FS_DQ_BTIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002521 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002522 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002523 }
2524 if (check_ilim) {
Jan Kara268157b2009-01-27 15:47:22 +01002525 if (!dm->dqb_isoftlimit ||
2526 dm->dqb_curinodes < dm->dqb_isoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527 dm->dqb_itime = 0;
2528 clear_bit(DQ_INODES_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002529 } else if (!(di->d_fieldmask & FS_DQ_ITIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002530 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002531 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532 }
Jan Kara268157b2009-01-27 15:47:22 +01002533 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2534 dm->dqb_isoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002535 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2536 else
2537 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2538 spin_unlock(&dq_data_lock);
2539 mark_dquot_dirty(dquot);
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002540
2541 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542}
2543
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002544int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
Christoph Hellwigc472b432010-05-06 17:05:17 -04002545 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002546{
2547 struct dquot *dquot;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002548 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002550 dquot = dqget(sb, qid);
Jan Karaf55abc02008-08-20 17:50:32 +02002551 if (!dquot) {
2552 rc = -ESRCH;
2553 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002554 }
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002555 rc = do_set_dqblk(dquot, di);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002556 dqput(dquot);
Jan Karaf55abc02008-08-20 17:50:32 +02002557out:
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002558 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002560EXPORT_SYMBOL(dquot_set_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561
2562/* Generic routine for getting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002563int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002564{
2565 struct mem_dqinfo *mi;
2566
Ingo Molnard3be9152006-03-23 03:00:29 -08002567 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002568 if (!sb_has_quota_active(sb, type)) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002569 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002570 return -ESRCH;
2571 }
2572 mi = sb_dqopt(sb)->info + type;
2573 spin_lock(&dq_data_lock);
2574 ii->dqi_bgrace = mi->dqi_bgrace;
2575 ii->dqi_igrace = mi->dqi_igrace;
Jan Kara46fe44c2011-11-16 15:03:59 +01002576 ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577 ii->dqi_valid = IIF_ALL;
2578 spin_unlock(&dq_data_lock);
Ingo Molnard3be9152006-03-23 03:00:29 -08002579 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002580 return 0;
2581}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002582EXPORT_SYMBOL(dquot_get_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583
2584/* Generic routine for setting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002585int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002586{
2587 struct mem_dqinfo *mi;
Jan Karaf55abc02008-08-20 17:50:32 +02002588 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002589
Ingo Molnard3be9152006-03-23 03:00:29 -08002590 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002591 if (!sb_has_quota_active(sb, type)) {
2592 err = -ESRCH;
2593 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002594 }
2595 mi = sb_dqopt(sb)->info + type;
2596 spin_lock(&dq_data_lock);
2597 if (ii->dqi_valid & IIF_BGRACE)
2598 mi->dqi_bgrace = ii->dqi_bgrace;
2599 if (ii->dqi_valid & IIF_IGRACE)
2600 mi->dqi_igrace = ii->dqi_igrace;
2601 if (ii->dqi_valid & IIF_FLAGS)
Jan Kara46fe44c2011-11-16 15:03:59 +01002602 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) |
2603 (ii->dqi_flags & DQF_SETINFO_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002604 spin_unlock(&dq_data_lock);
2605 mark_info_dirty(sb, type);
2606 /* Force write to disk */
2607 sb->dq_op->write_info(sb, type);
Jan Karaf55abc02008-08-20 17:50:32 +02002608out:
Ingo Molnard3be9152006-03-23 03:00:29 -08002609 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002610 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002612EXPORT_SYMBOL(dquot_set_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002613
Christoph Hellwig287a8092010-05-19 07:16:45 -04002614const struct quotactl_ops dquot_quotactl_ops = {
2615 .quota_on = dquot_quota_on,
2616 .quota_off = dquot_quota_off,
2617 .quota_sync = dquot_quota_sync,
2618 .get_info = dquot_get_dqinfo,
2619 .set_info = dquot_set_dqinfo,
2620 .get_dqblk = dquot_get_dqblk,
2621 .set_dqblk = dquot_set_dqblk
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622};
Christoph Hellwig287a8092010-05-19 07:16:45 -04002623EXPORT_SYMBOL(dquot_quotactl_ops);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002624
2625static int do_proc_dqstats(struct ctl_table *table, int write,
2626 void __user *buffer, size_t *lenp, loff_t *ppos)
2627{
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002628 unsigned int type = (int *)table->data - dqstats.stat;
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002629
2630 /* Update global table */
2631 dqstats.stat[type] =
2632 percpu_counter_sum_positive(&dqstats.counter[type]);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002633 return proc_dointvec(table, write, buffer, lenp, ppos);
2634}
2635
Joe Perchese6287532013-06-13 19:37:49 -07002636static struct ctl_table fs_dqstats_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002637 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002638 .procname = "lookups",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002639 .data = &dqstats.stat[DQST_LOOKUPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 .maxlen = sizeof(int),
2641 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002642 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002643 },
2644 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002645 .procname = "drops",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002646 .data = &dqstats.stat[DQST_DROPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002647 .maxlen = sizeof(int),
2648 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002649 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 },
2651 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002652 .procname = "reads",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002653 .data = &dqstats.stat[DQST_READS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002654 .maxlen = sizeof(int),
2655 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002656 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002657 },
2658 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 .procname = "writes",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002660 .data = &dqstats.stat[DQST_WRITES],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661 .maxlen = sizeof(int),
2662 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002663 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002664 },
2665 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666 .procname = "cache_hits",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002667 .data = &dqstats.stat[DQST_CACHE_HITS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002668 .maxlen = sizeof(int),
2669 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002670 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671 },
2672 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002673 .procname = "allocated_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002674 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002675 .maxlen = sizeof(int),
2676 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002677 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002678 },
2679 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 .procname = "free_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002681 .data = &dqstats.stat[DQST_FREE_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002682 .maxlen = sizeof(int),
2683 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002684 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685 },
2686 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002687 .procname = "syncs",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002688 .data = &dqstats.stat[DQST_SYNCS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002689 .maxlen = sizeof(int),
2690 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002691 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002692 },
Jan Kara8e893462007-10-16 23:29:31 -07002693#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07002694 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 .procname = "warnings",
2696 .data = &flag_print_warnings,
2697 .maxlen = sizeof(int),
2698 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08002699 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 },
Jan Kara8e893462007-10-16 23:29:31 -07002701#endif
Eric W. Biedermanab092032009-11-05 14:25:10 -08002702 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002703};
2704
Joe Perchese6287532013-06-13 19:37:49 -07002705static struct ctl_table fs_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 .procname = "quota",
2708 .mode = 0555,
2709 .child = fs_dqstats_table,
2710 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002711 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002712};
2713
Joe Perchese6287532013-06-13 19:37:49 -07002714static struct ctl_table sys_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716 .procname = "fs",
2717 .mode = 0555,
2718 .child = fs_table,
2719 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002720 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002721};
2722
2723static int __init dquot_init(void)
2724{
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002725 int i, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726 unsigned long nr_hash, order;
2727
2728 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2729
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08002730 register_sysctl_table(sys_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002731
Paul Mundt20c2df82007-07-20 10:11:58 +09002732 dquot_cachep = kmem_cache_create("dquot",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002733 sizeof(struct dquot), sizeof(unsigned long) * 4,
Paul Jacksonfffb60f2006-03-24 03:16:06 -08002734 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2735 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +09002736 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737
2738 order = 0;
2739 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2740 if (!dquot_hash)
2741 panic("Cannot create dquot hash table");
2742
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002743 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2744 ret = percpu_counter_init(&dqstats.counter[i], 0);
2745 if (ret)
2746 panic("Cannot create dquot stat counters");
2747 }
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002748
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749 /* Find power-of-two hlist_heads which can fit into allocation */
2750 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2751 dq_hash_bits = 0;
2752 do {
2753 dq_hash_bits++;
2754 } while (nr_hash >> dq_hash_bits);
2755 dq_hash_bits--;
2756
2757 nr_hash = 1UL << dq_hash_bits;
2758 dq_hash_mask = nr_hash - 1;
2759 for (i = 0; i < nr_hash; i++)
2760 INIT_HLIST_HEAD(dquot_hash + i);
2761
2762 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2763 nr_hash, order, (PAGE_SIZE << order));
2764
Rusty Russell8e1f9362007-07-17 04:03:17 -07002765 register_shrinker(&dqcache_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002766
Linus Torvalds1da177e2005-04-16 15:20:36 -07002767 return 0;
2768}
2769module_init(dquot_init);