blob: 251771916069d9af8f1b6e507487affe4f3f5e6e [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
736 * NOTE: If you change this function please check whether dqput_blocks() works right...
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 */
Jan Kara3d9ea252008-10-10 16:12:23 +0200738void dqput(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739{
Jan Karab48d3802008-07-25 01:46:49 -0700740 int ret;
741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 if (!dquot)
743 return;
Jan Kara62af9b52010-04-19 16:47:20 +0200744#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700745 if (!atomic_read(&dquot->dq_count)) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200746 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700747 quotatypes[dquot->dq_id.type],
748 from_kqid(&init_user_ns, dquot->dq_id));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700749 BUG();
750 }
751#endif
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400752 dqstats_inc(DQST_DROPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753we_slept:
754 spin_lock(&dq_list_lock);
755 if (atomic_read(&dquot->dq_count) > 1) {
756 /* We have more than one user... nothing to do */
757 atomic_dec(&dquot->dq_count);
Jan Kara6362e4d2006-03-23 03:00:17 -0800758 /* Releasing dquot during quotaoff phase? */
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700759 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) &&
Jan Kara6362e4d2006-03-23 03:00:17 -0800760 atomic_read(&dquot->dq_count) == 1)
761 wake_up(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 spin_unlock(&dq_list_lock);
763 return;
764 }
765 /* Need to release dquot? */
766 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
767 spin_unlock(&dq_list_lock);
768 /* Commit dquot before releasing */
Jan Karab48d3802008-07-25 01:46:49 -0700769 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
770 if (ret < 0) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200771 quota_error(dquot->dq_sb, "Can't write quota structure"
772 " (error %d). Quota may get out of sync!",
773 ret);
Jan Karab48d3802008-07-25 01:46:49 -0700774 /*
775 * We clear dirty bit anyway, so that we avoid
776 * infinite loop here
777 */
778 spin_lock(&dq_list_lock);
779 clear_dquot_dirty(dquot);
780 spin_unlock(&dq_list_lock);
781 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782 goto we_slept;
783 }
784 /* Clear flag in case dquot was inactive (something bad happened) */
785 clear_dquot_dirty(dquot);
786 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
787 spin_unlock(&dq_list_lock);
788 dquot->dq_sb->dq_op->release_dquot(dquot);
789 goto we_slept;
790 }
791 atomic_dec(&dquot->dq_count);
Jan Kara62af9b52010-04-19 16:47:20 +0200792#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 /* sanity check */
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200794 BUG_ON(!list_empty(&dquot->dq_free));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700795#endif
796 put_dquot_last(dquot);
797 spin_unlock(&dq_list_lock);
798}
Mingming Cao08d03502009-01-14 16:19:32 +0100799EXPORT_SYMBOL(dqput);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700800
Jan Kara7d9056b2008-11-25 15:31:32 +0100801struct dquot *dquot_alloc(struct super_block *sb, int type)
Jan Kara74f783a2008-08-19 14:51:22 +0200802{
803 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
804}
Jan Kara7d9056b2008-11-25 15:31:32 +0100805EXPORT_SYMBOL(dquot_alloc);
Jan Kara74f783a2008-08-19 14:51:22 +0200806
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807static struct dquot *get_empty_dquot(struct super_block *sb, int type)
808{
809 struct dquot *dquot;
810
Jan Kara74f783a2008-08-19 14:51:22 +0200811 dquot = sb->dq_op->alloc_dquot(sb, type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 if(!dquot)
Jan Karadd6f3c62009-01-26 16:01:43 +0100813 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700814
Ingo Molnard3be9152006-03-23 03:00:29 -0800815 mutex_init(&dquot->dq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700816 INIT_LIST_HEAD(&dquot->dq_free);
817 INIT_LIST_HEAD(&dquot->dq_inuse);
818 INIT_HLIST_NODE(&dquot->dq_hash);
819 INIT_LIST_HEAD(&dquot->dq_dirty);
Jan Kara6362e4d2006-03-23 03:00:17 -0800820 init_waitqueue_head(&dquot->dq_wait_unused);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 dquot->dq_sb = sb;
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700822 dquot->dq_id = make_kqid_invalid(type);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700823 atomic_set(&dquot->dq_count, 1);
824
825 return dquot;
826}
827
828/*
829 * Get reference to dquot
Jan Karacc334122009-01-12 17:23:05 +0100830 *
831 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
832 * destroying our dquot by:
833 * a) checking for quota flags under dq_list_lock and
834 * b) getting a reference to dquot before we release dq_list_lock
Linus Torvalds1da177e2005-04-16 15:20:36 -0700835 */
Eric W. Biedermanaca645a2012-09-16 03:11:50 -0700836struct dquot *dqget(struct super_block *sb, struct kqid qid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700837{
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700838 unsigned int hashent = hashfn(sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +0100839 struct dquot *dquot = NULL, *empty = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700841 if (!sb_has_quota_active(sb, qid.type))
Jan Karadd6f3c62009-01-26 16:01:43 +0100842 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843we_slept:
844 spin_lock(&dq_list_lock);
Jan Karacc334122009-01-12 17:23:05 +0100845 spin_lock(&dq_state_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700846 if (!sb_has_quota_active(sb, qid.type)) {
Jan Karacc334122009-01-12 17:23:05 +0100847 spin_unlock(&dq_state_lock);
848 spin_unlock(&dq_list_lock);
849 goto out;
850 }
851 spin_unlock(&dq_state_lock);
852
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700853 dquot = find_dquot(hashent, sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +0100854 if (!dquot) {
855 if (!empty) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700856 spin_unlock(&dq_list_lock);
Eric W. Biederman1a06d422012-09-16 05:45:30 -0700857 empty = get_empty_dquot(sb, qid.type);
Jan Karadd6f3c62009-01-26 16:01:43 +0100858 if (!empty)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700859 schedule(); /* Try to wait for a moment... */
860 goto we_slept;
861 }
862 dquot = empty;
Jan Karadd6f3c62009-01-26 16:01:43 +0100863 empty = NULL;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -0700864 dquot->dq_id = qid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700865 /* all dquots go on the inuse_list */
866 put_inuse(dquot);
867 /* hash it first so it can be found */
868 insert_dquot_hash(dquot);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700869 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400870 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 } else {
872 if (!atomic_read(&dquot->dq_count))
873 remove_free_dquot(dquot);
874 atomic_inc(&dquot->dq_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700875 spin_unlock(&dq_list_lock);
Dmitry Monakhovdde95882010-04-26 20:03:33 +0400876 dqstats_inc(DQST_CACHE_HITS);
877 dqstats_inc(DQST_LOOKUPS);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700878 }
Jan Kara268157b2009-01-27 15:47:22 +0100879 /* Wait for dq_lock - after this we know that either dquot_release() is
880 * already finished or it will be canceled due to dq_count > 1 test */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 wait_on_dquot(dquot);
Jan Kara268157b2009-01-27 15:47:22 +0100882 /* Read the dquot / allocate space in quota file */
883 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
884 sb->dq_op->acquire_dquot(dquot) < 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 dqput(dquot);
Jan Karadd6f3c62009-01-26 16:01:43 +0100886 dquot = NULL;
Jan Karacc334122009-01-12 17:23:05 +0100887 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700888 }
Jan Kara62af9b52010-04-19 16:47:20 +0200889#ifdef CONFIG_QUOTA_DEBUG
Eric Sesterhenn8abf6a42006-04-02 13:36:13 +0200890 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891#endif
Jan Karacc334122009-01-12 17:23:05 +0100892out:
893 if (empty)
894 do_destroy_dquot(empty);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895
896 return dquot;
897}
Mingming Cao08d03502009-01-14 16:19:32 +0100898EXPORT_SYMBOL(dqget);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
900static int dqinit_needed(struct inode *inode, int type)
901{
902 int cnt;
903
904 if (IS_NOQUOTA(inode))
905 return 0;
906 if (type != -1)
Jan Karadd6f3c62009-01-26 16:01:43 +0100907 return !inode->i_dquot[type];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karadd6f3c62009-01-26 16:01:43 +0100909 if (!inode->i_dquot[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -0700910 return 1;
911 return 0;
912}
913
Ingo Molnard3be9152006-03-23 03:00:29 -0800914/* This routine is guarded by dqonoff_mutex mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915static void add_dquot_ref(struct super_block *sb, int type)
916{
Jan Kara941d2382008-02-06 01:37:36 -0800917 struct inode *inode, *old_inode = NULL;
Jan Kara62af9b52010-04-19 16:47:20 +0200918#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100919 int reserved = 0;
Jan Kara4c5e6c02010-04-06 18:52:47 +0200920#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921
Dave Chinner55fa6092011-03-22 22:23:40 +1100922 spin_lock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800923 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Dave Chinner250df6e2011-03-22 22:23:36 +1100924 spin_lock(&inode->i_lock);
925 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
926 !atomic_read(&inode->i_writecount) ||
927 !dqinit_needed(inode, type)) {
928 spin_unlock(&inode->i_lock);
Nick Pigginaabb8fd2009-03-11 13:17:36 -0700929 continue;
Dave Chinner250df6e2011-03-22 22:23:36 +1100930 }
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800931 __iget(inode);
Dave Chinner250df6e2011-03-22 22:23:36 +1100932 spin_unlock(&inode->i_lock);
Dave Chinner55fa6092011-03-22 22:23:40 +1100933 spin_unlock(&inode_sb_list_lock);
Christoph Hellwigd003fb72007-02-12 00:51:58 -0800934
Jan Karad7e97112012-04-24 17:08:41 +0200935#ifdef CONFIG_QUOTA_DEBUG
936 if (unlikely(inode_get_rsv_space(inode) > 0))
937 reserved = 1;
938#endif
Jan Kara941d2382008-02-06 01:37:36 -0800939 iput(old_inode);
Christoph Hellwig871a2932010-03-03 09:05:07 -0500940 __dquot_initialize(inode, type);
Dave Chinner55fa6092011-03-22 22:23:40 +1100941
942 /*
943 * We hold a reference to 'inode' so it couldn't have been
944 * removed from s_inodes list while we dropped the
945 * inode_sb_list_lock We cannot iput the inode now as we can be
946 * holding the last reference and we cannot iput it under
947 * inode_sb_list_lock. So we keep the reference and iput it
948 * later.
949 */
Jan Kara941d2382008-02-06 01:37:36 -0800950 old_inode = inode;
Dave Chinner55fa6092011-03-22 22:23:40 +1100951 spin_lock(&inode_sb_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952 }
Dave Chinner55fa6092011-03-22 22:23:40 +1100953 spin_unlock(&inode_sb_list_lock);
Jan Kara941d2382008-02-06 01:37:36 -0800954 iput(old_inode);
Jan Kara0a5a9c72010-02-09 18:20:39 +0100955
Jan Kara62af9b52010-04-19 16:47:20 +0200956#ifdef CONFIG_QUOTA_DEBUG
Jan Kara0a5a9c72010-02-09 18:20:39 +0100957 if (reserved) {
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200958 quota_error(sb, "Writes happened before quota was turned on "
959 "thus quota information is probably inconsistent. "
960 "Please run quotacheck(8)");
Jan Kara0a5a9c72010-02-09 18:20:39 +0100961 }
Jan Kara4c5e6c02010-04-06 18:52:47 +0200962#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963}
964
Jan Kara268157b2009-01-27 15:47:22 +0100965/*
966 * Return 0 if dqput() won't block.
967 * (note that 1 doesn't necessarily mean blocking)
968 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969static inline int dqput_blocks(struct dquot *dquot)
970{
971 if (atomic_read(&dquot->dq_count) <= 1)
972 return 1;
973 return 0;
974}
975
Jan Kara268157b2009-01-27 15:47:22 +0100976/*
977 * Remove references to dquots from inode and add dquot to list for freeing
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300978 * if we have the last reference to dquot
Jan Kara268157b2009-01-27 15:47:22 +0100979 * We can't race with anybody because we hold dqptr_sem for writing...
980 */
Adrian Bunke5f00f42007-05-08 00:27:22 -0700981static int remove_inode_dquot_ref(struct inode *inode, int type,
982 struct list_head *tofree_head)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983{
984 struct dquot *dquot = inode->i_dquot[type];
985
Jan Karadd6f3c62009-01-26 16:01:43 +0100986 inode->i_dquot[type] = NULL;
987 if (dquot) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 if (dqput_blocks(dquot)) {
Jan Kara62af9b52010-04-19 16:47:20 +0200989#ifdef CONFIG_QUOTA_DEBUG
Linus Torvalds1da177e2005-04-16 15:20:36 -0700990 if (atomic_read(&dquot->dq_count) != 1)
Jiaying Zhangfb5ffb02010-07-20 16:54:43 +0200991 quota_error(inode->i_sb, "Adding dquot with "
992 "dq_count %d to dispose list",
993 atomic_read(&dquot->dq_count));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994#endif
995 spin_lock(&dq_list_lock);
Jan Kara268157b2009-01-27 15:47:22 +0100996 /* As dquot must have currently users it can't be on
997 * the free list... */
998 list_add(&dquot->dq_free, tofree_head);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 spin_unlock(&dq_list_lock);
1000 return 1;
1001 }
1002 else
1003 dqput(dquot); /* We have guaranteed we won't block */
1004 }
1005 return 0;
1006}
1007
Jan Kara268157b2009-01-27 15:47:22 +01001008/*
1009 * Free list of dquots
1010 * Dquots are removed from inodes and no new references can be got so we are
1011 * the only ones holding reference
1012 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001013static void put_dquot_list(struct list_head *tofree_head)
1014{
1015 struct list_head *act_head;
1016 struct dquot *dquot;
1017
1018 act_head = tofree_head->next;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 while (act_head != tofree_head) {
1020 dquot = list_entry(act_head, struct dquot, dq_free);
1021 act_head = act_head->next;
Jan Kara268157b2009-01-27 15:47:22 +01001022 /* Remove dquot from the list so we won't have problems... */
1023 list_del_init(&dquot->dq_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 dqput(dquot);
1025 }
1026}
1027
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001028static void remove_dquot_ref(struct super_block *sb, int type,
1029 struct list_head *tofree_head)
1030{
1031 struct inode *inode;
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001032 int reserved = 0;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001033
Dave Chinner55fa6092011-03-22 22:23:40 +11001034 spin_lock(&inode_sb_list_lock);
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001035 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
Nick Pigginaabb8fd2009-03-11 13:17:36 -07001036 /*
1037 * We have to scan also I_NEW inodes because they can already
1038 * have quota pointer initialized. Luckily, we need to touch
1039 * only quota pointers and these have separate locking
1040 * (dqptr_sem).
1041 */
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001042 if (!IS_NOQUOTA(inode)) {
1043 if (unlikely(inode_get_rsv_space(inode) > 0))
1044 reserved = 1;
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001045 remove_inode_dquot_ref(inode, type, tofree_head);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001046 }
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001047 }
Dave Chinner55fa6092011-03-22 22:23:40 +11001048 spin_unlock(&inode_sb_list_lock);
Dmitry Monakhov7af9cce2010-06-01 11:39:48 +04001049#ifdef CONFIG_QUOTA_DEBUG
1050 if (reserved) {
1051 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1052 " was disabled thus quota information is probably "
1053 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1054 }
1055#endif
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001056}
1057
Linus Torvalds1da177e2005-04-16 15:20:36 -07001058/* Gather all references from inodes and drop them */
1059static void drop_dquot_ref(struct super_block *sb, int type)
1060{
1061 LIST_HEAD(tofree_head);
1062
Christoph Hellwigfb58b732007-02-12 00:51:57 -08001063 if (sb->dq_op) {
1064 down_write(&sb_dqopt(sb)->dqptr_sem);
1065 remove_dquot_ref(sb, type, &tofree_head);
1066 up_write(&sb_dqopt(sb)->dqptr_sem);
1067 put_dquot_list(&tofree_head);
1068 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001069}
1070
Jan Kara12095462008-08-20 14:45:12 +02001071static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072{
1073 dquot->dq_dqb.dqb_curinodes += number;
1074}
1075
1076static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
1077{
1078 dquot->dq_dqb.dqb_curspace += number;
1079}
1080
Mingming Caof18df222009-01-13 16:43:09 +01001081static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
1082{
1083 dquot->dq_dqb.dqb_rsvspace += number;
1084}
1085
Mingming Cao740d9dc2009-01-13 16:43:14 +01001086/*
1087 * Claim reserved quota space
1088 */
Jan Kara0a5a9c72010-02-09 18:20:39 +01001089static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001090{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001091 if (dquot->dq_dqb.dqb_rsvspace < number) {
1092 WARN_ON_ONCE(1);
1093 number = dquot->dq_dqb.dqb_rsvspace;
1094 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001095 dquot->dq_dqb.dqb_curspace += number;
1096 dquot->dq_dqb.dqb_rsvspace -= number;
1097}
1098
Jan Kara1c8924e2013-08-17 09:32:32 -04001099static void dquot_reclaim_reserved_space(struct dquot *dquot, qsize_t number)
1100{
1101 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
1102 number = dquot->dq_dqb.dqb_curspace;
1103 dquot->dq_dqb.dqb_rsvspace += number;
1104 dquot->dq_dqb.dqb_curspace -= number;
1105}
1106
Mingming Cao740d9dc2009-01-13 16:43:14 +01001107static inline
1108void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1109{
Jan Kara0a5a9c72010-02-09 18:20:39 +01001110 if (dquot->dq_dqb.dqb_rsvspace >= number)
1111 dquot->dq_dqb.dqb_rsvspace -= number;
1112 else {
1113 WARN_ON_ONCE(1);
1114 dquot->dq_dqb.dqb_rsvspace = 0;
1115 }
Mingming Cao740d9dc2009-01-13 16:43:14 +01001116}
1117
Jan Kara7a2435d2009-01-27 01:47:11 +01001118static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001119{
Jan Karadb49d2d2008-10-01 18:21:39 +02001120 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1121 dquot->dq_dqb.dqb_curinodes >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 dquot->dq_dqb.dqb_curinodes -= number;
1123 else
1124 dquot->dq_dqb.dqb_curinodes = 0;
1125 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1126 dquot->dq_dqb.dqb_itime = (time_t) 0;
1127 clear_bit(DQ_INODES_B, &dquot->dq_flags);
1128}
1129
Jan Kara7a2435d2009-01-27 01:47:11 +01001130static void dquot_decr_space(struct dquot *dquot, qsize_t number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001131{
Jan Karadb49d2d2008-10-01 18:21:39 +02001132 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1133 dquot->dq_dqb.dqb_curspace >= number)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001134 dquot->dq_dqb.dqb_curspace -= number;
1135 else
1136 dquot->dq_dqb.dqb_curspace = 0;
Jan Kara12095462008-08-20 14:45:12 +02001137 if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 dquot->dq_dqb.dqb_btime = (time_t) 0;
1139 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1140}
1141
Jan Karabf097aa2012-02-14 13:28:01 +01001142struct dquot_warn {
1143 struct super_block *w_sb;
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001144 struct kqid w_dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001145 short w_type;
1146};
1147
Jan Karac5254602007-12-22 14:03:25 -08001148static int warning_issued(struct dquot *dquot, const int warntype)
1149{
1150 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1151 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1152 ((warntype == QUOTA_NL_IHARDWARN ||
1153 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1154
1155 if (!flag)
1156 return 0;
1157 return test_and_set_bit(flag, &dquot->dq_flags);
1158}
1159
Jan Kara8e893462007-10-16 23:29:31 -07001160#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07001161static int flag_print_warnings = 1;
1162
Jan Karabf097aa2012-02-14 13:28:01 +01001163static int need_print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164{
1165 if (!flag_print_warnings)
1166 return 0;
1167
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001168 switch (warn->w_dq_id.type) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 case USRQUOTA:
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001170 return uid_eq(current_fsuid(), warn->w_dq_id.uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171 case GRPQUOTA:
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001172 return in_group_p(warn->w_dq_id.gid);
Jan Kara6c29c502012-10-09 23:30:17 +02001173 case PRJQUOTA: /* Never taken... Just make gcc happy */
1174 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 }
1176 return 0;
1177}
1178
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179/* Print warning to user which exceeded quota */
Jan Karabf097aa2012-02-14 13:28:01 +01001180static void print_warning(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001181{
1182 char *msg = NULL;
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001183 struct tty_struct *tty;
Jan Karabf097aa2012-02-14 13:28:01 +01001184 int warntype = warn->w_type;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001185
Jan Kara657d3bf2008-07-25 01:46:52 -07001186 if (warntype == QUOTA_NL_IHARDBELOW ||
1187 warntype == QUOTA_NL_ISOFTBELOW ||
1188 warntype == QUOTA_NL_BHARDBELOW ||
Jan Karabf097aa2012-02-14 13:28:01 +01001189 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190 return;
1191
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001192 tty = get_current_tty();
1193 if (!tty)
Alan Cox452a00d2008-10-13 10:39:13 +01001194 return;
Jan Karabf097aa2012-02-14 13:28:01 +01001195 tty_write_message(tty, warn->w_sb->s_id);
Jan Kara8e893462007-10-16 23:29:31 -07001196 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001197 tty_write_message(tty, ": warning, ");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198 else
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001199 tty_write_message(tty, ": write failed, ");
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001200 tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001201 switch (warntype) {
Jan Kara8e893462007-10-16 23:29:31 -07001202 case QUOTA_NL_IHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 msg = " file limit reached.\r\n";
1204 break;
Jan Kara8e893462007-10-16 23:29:31 -07001205 case QUOTA_NL_ISOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206 msg = " file quota exceeded too long.\r\n";
1207 break;
Jan Kara8e893462007-10-16 23:29:31 -07001208 case QUOTA_NL_ISOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001209 msg = " file quota exceeded.\r\n";
1210 break;
Jan Kara8e893462007-10-16 23:29:31 -07001211 case QUOTA_NL_BHARDWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001212 msg = " block limit reached.\r\n";
1213 break;
Jan Kara8e893462007-10-16 23:29:31 -07001214 case QUOTA_NL_BSOFTLONGWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001215 msg = " block quota exceeded too long.\r\n";
1216 break;
Jan Kara8e893462007-10-16 23:29:31 -07001217 case QUOTA_NL_BSOFTWARN:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001218 msg = " block quota exceeded.\r\n";
1219 break;
1220 }
Peter Zijlstra24ec8392006-12-08 02:36:04 -08001221 tty_write_message(tty, msg);
Alan Cox452a00d2008-10-13 10:39:13 +01001222 tty_kref_put(tty);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001223}
Jan Kara8e893462007-10-16 23:29:31 -07001224#endif
1225
Jan Karabf097aa2012-02-14 13:28:01 +01001226static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1227 int warntype)
1228{
1229 if (warning_issued(dquot, warntype))
1230 return;
1231 warn->w_type = warntype;
1232 warn->w_sb = dquot->dq_sb;
1233 warn->w_dq_id = dquot->dq_id;
Jan Karabf097aa2012-02-14 13:28:01 +01001234}
1235
Mingming Caof18df222009-01-13 16:43:09 +01001236/*
1237 * Write warnings to the console and send warning messages over netlink.
1238 *
Jan Karabf097aa2012-02-14 13:28:01 +01001239 * Note that this function can call into tty and networking code.
Mingming Caof18df222009-01-13 16:43:09 +01001240 */
Jan Karabf097aa2012-02-14 13:28:01 +01001241static void flush_warnings(struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242{
1243 int i;
1244
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001245 for (i = 0; i < MAXQUOTAS; i++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001246 if (warn[i].w_type == QUOTA_NL_NOWARN)
1247 continue;
Jan Kara8e893462007-10-16 23:29:31 -07001248#ifdef CONFIG_PRINT_QUOTA_WARNING
Jan Karabf097aa2012-02-14 13:28:01 +01001249 print_warning(&warn[i]);
Jan Kara8e893462007-10-16 23:29:31 -07001250#endif
Eric W. Biederman7b9c7322012-09-16 04:05:34 -07001251 quota_send_warning(warn[i].w_dq_id,
Jan Karabf097aa2012-02-14 13:28:01 +01001252 warn[i].w_sb->s_dev, warn[i].w_type);
Steven Whitehouse86e931a2009-09-28 12:35:17 +01001253 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254}
1255
Jan Kara7a2435d2009-01-27 01:47:11 +01001256static int ignore_hardlimit(struct dquot *dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001257{
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001258 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
1260 return capable(CAP_SYS_RESOURCE) &&
Jan Kara268157b2009-01-27 15:47:22 +01001261 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
1262 !(info->dqi_flags & V1_DQF_RSQUASH));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263}
1264
1265/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001266static int check_idq(struct dquot *dquot, qsize_t inodes,
1267 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268{
Jan Kara268157b2009-01-27 15:47:22 +01001269 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1270
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001271 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001272 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001273 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001274
1275 if (dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001276 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001278 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001279 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280 }
1281
1282 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001283 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1284 dquot->dq_dqb.dqb_itime &&
1285 get_seconds() >= dquot->dq_dqb.dqb_itime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001286 !ignore_hardlimit(dquot)) {
Jan Karabf097aa2012-02-14 13:28:01 +01001287 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001288 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001289 }
1290
1291 if (dquot->dq_dqb.dqb_isoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001292 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001293 dquot->dq_dqb.dqb_itime == 0) {
Jan Karabf097aa2012-02-14 13:28:01 +01001294 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001295 dquot->dq_dqb.dqb_itime = get_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001296 sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001297 }
1298
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001299 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001300}
1301
1302/* needs dq_data_lock */
Jan Karabf097aa2012-02-14 13:28:01 +01001303static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc,
1304 struct dquot_warn *warn)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305{
Mingming Caof18df222009-01-13 16:43:09 +01001306 qsize_t tspace;
Jan Kara268157b2009-01-27 15:47:22 +01001307 struct super_block *sb = dquot->dq_sb;
Mingming Caof18df222009-01-13 16:43:09 +01001308
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001309 if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001310 test_bit(DQ_FAKE_B, &dquot->dq_flags))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001311 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
Mingming Caof18df222009-01-13 16:43:09 +01001313 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1314 + space;
1315
Linus Torvalds1da177e2005-04-16 15:20:36 -07001316 if (dquot->dq_dqb.dqb_bhardlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001317 tspace > dquot->dq_dqb.dqb_bhardlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001318 !ignore_hardlimit(dquot)) {
1319 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001320 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001321 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001322 }
1323
1324 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001325 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001326 dquot->dq_dqb.dqb_btime &&
1327 get_seconds() >= dquot->dq_dqb.dqb_btime &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001328 !ignore_hardlimit(dquot)) {
1329 if (!prealloc)
Jan Karabf097aa2012-02-14 13:28:01 +01001330 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001331 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 }
1333
1334 if (dquot->dq_dqb.dqb_bsoftlimit &&
Mingming Caof18df222009-01-13 16:43:09 +01001335 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001336 dquot->dq_dqb.dqb_btime == 0) {
1337 if (!prealloc) {
Jan Karabf097aa2012-02-14 13:28:01 +01001338 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
Jan Kara268157b2009-01-27 15:47:22 +01001339 dquot->dq_dqb.dqb_btime = get_seconds() +
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001340 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001341 }
1342 else
1343 /*
1344 * We don't allow preallocation to exceed softlimit so exceeding will
1345 * be always printed
1346 */
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001347 return -EDQUOT;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348 }
1349
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001350 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001351}
1352
Jan Kara12095462008-08-20 14:45:12 +02001353static int info_idq_free(struct dquot *dquot, qsize_t inodes)
Jan Kara657d3bf2008-07-25 01:46:52 -07001354{
Jan Kara268157b2009-01-27 15:47:22 +01001355 qsize_t newinodes;
1356
Jan Kara657d3bf2008-07-25 01:46:52 -07001357 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Karaf55abc02008-08-20 17:50:32 +02001358 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07001359 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type))
Jan Kara657d3bf2008-07-25 01:46:52 -07001360 return QUOTA_NL_NOWARN;
1361
Jan Kara268157b2009-01-27 15:47:22 +01001362 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1363 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001364 return QUOTA_NL_ISOFTBELOW;
1365 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
Jan Kara268157b2009-01-27 15:47:22 +01001366 newinodes < dquot->dq_dqb.dqb_ihardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001367 return QUOTA_NL_IHARDBELOW;
1368 return QUOTA_NL_NOWARN;
1369}
1370
1371static int info_bdq_free(struct dquot *dquot, qsize_t space)
1372{
1373 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
Jan Kara12095462008-08-20 14:45:12 +02001374 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001375 return QUOTA_NL_NOWARN;
1376
Jan Kara12095462008-08-20 14:45:12 +02001377 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001378 return QUOTA_NL_BSOFTBELOW;
Jan Kara12095462008-08-20 14:45:12 +02001379 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
1380 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
Jan Kara657d3bf2008-07-25 01:46:52 -07001381 return QUOTA_NL_BHARDBELOW;
1382 return QUOTA_NL_NOWARN;
1383}
Jan Kara0a5a9c72010-02-09 18:20:39 +01001384
Christoph Hellwig189eef52010-06-04 10:56:29 +02001385static int dquot_active(const struct inode *inode)
1386{
1387 struct super_block *sb = inode->i_sb;
1388
1389 if (IS_NOQUOTA(inode))
1390 return 0;
1391 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1392}
1393
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394/*
Christoph Hellwig871a2932010-03-03 09:05:07 -05001395 * Initialize quota pointers in inode
1396 *
1397 * We do things in a bit complicated way but by that we avoid calling
1398 * dqget() and thus filesystem callbacks under dqptr_sem.
1399 *
1400 * It is better to call this function outside of any transaction as it
1401 * might need a lot of space in journal for dquot structure allocation.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 */
Christoph Hellwig871a2932010-03-03 09:05:07 -05001403static void __dquot_initialize(struct inode *inode, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001404{
Niu Yawei1ea06be2014-06-04 12:20:30 +08001405 int cnt, init_needed = 0;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001406 struct dquot *got[MAXQUOTAS];
Jan Karacc334122009-01-12 17:23:05 +01001407 struct super_block *sb = inode->i_sb;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001408 qsize_t rsv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409
Ingo Molnard3be9152006-03-23 03:00:29 -08001410 /* First test before acquiring mutex - solves deadlocks when we
1411 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001412 if (!dquot_active(inode))
Christoph Hellwig871a2932010-03-03 09:05:07 -05001413 return;
Jan Karacc334122009-01-12 17:23:05 +01001414
1415 /* First get references to structures we might need. */
1416 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001417 struct kqid qid;
Dmitry Monakhovad1e6e82010-02-16 08:31:49 +03001418 got[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001419 if (type != -1 && cnt != type)
1420 continue;
Niu Yawei1ea06be2014-06-04 12:20:30 +08001421 /*
1422 * The i_dquot should have been initialized in most cases,
1423 * we check it without locking here to avoid unnecessary
1424 * dqget()/dqput() calls.
1425 */
1426 if (inode->i_dquot[cnt])
1427 continue;
1428 init_needed = 1;
1429
Jan Karacc334122009-01-12 17:23:05 +01001430 switch (cnt) {
1431 case USRQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001432 qid = make_kqid_uid(inode->i_uid);
Jan Karacc334122009-01-12 17:23:05 +01001433 break;
1434 case GRPQUOTA:
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001435 qid = make_kqid_gid(inode->i_gid);
Jan Karacc334122009-01-12 17:23:05 +01001436 break;
1437 }
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001438 got[cnt] = dqget(sb, qid);
Jan Karacc334122009-01-12 17:23:05 +01001439 }
1440
Niu Yawei1ea06be2014-06-04 12:20:30 +08001441 /* All required i_dquot has been initialized */
1442 if (!init_needed)
1443 return;
1444
Jan Karacc334122009-01-12 17:23:05 +01001445 down_write(&sb_dqopt(sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 if (IS_NOQUOTA(inode))
1447 goto out_err;
1448 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1449 if (type != -1 && cnt != type)
1450 continue;
Jan Karacc334122009-01-12 17:23:05 +01001451 /* Avoid races with quotaoff() */
1452 if (!sb_has_quota_active(sb, cnt))
1453 continue;
Jan Kara4408ea42010-10-19 00:24:21 +02001454 /* We could race with quotaon or dqget() could have failed */
1455 if (!got[cnt])
1456 continue;
Jan Karadd6f3c62009-01-26 16:01:43 +01001457 if (!inode->i_dquot[cnt]) {
Jan Karacc334122009-01-12 17:23:05 +01001458 inode->i_dquot[cnt] = got[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001459 got[cnt] = NULL;
Jan Kara0a5a9c72010-02-09 18:20:39 +01001460 /*
1461 * Make quota reservation system happy if someone
1462 * did a write before quota was turned on
1463 */
1464 rsv = inode_get_rsv_space(inode);
Jeff Mahoney68ac8bf2013-02-27 14:43:09 -05001465 if (unlikely(rsv)) {
1466 spin_lock(&dq_data_lock);
Jan Kara0a5a9c72010-02-09 18:20:39 +01001467 dquot_resv_space(inode->i_dquot[cnt], rsv);
Jeff Mahoney68ac8bf2013-02-27 14:43:09 -05001468 spin_unlock(&dq_data_lock);
1469 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001470 }
1471 }
1472out_err:
Jan Karacc334122009-01-12 17:23:05 +01001473 up_write(&sb_dqopt(sb)->dqptr_sem);
1474 /* Drop unused references */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001475 dqput_all(got);
Christoph Hellwig871a2932010-03-03 09:05:07 -05001476}
1477
1478void dquot_initialize(struct inode *inode)
1479{
1480 __dquot_initialize(inode, -1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481}
Mingming Cao08d03502009-01-14 16:19:32 +01001482EXPORT_SYMBOL(dquot_initialize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483
1484/*
1485 * Release all quotas referenced by inode
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05001487static void __dquot_drop(struct inode *inode)
Jan Kara3d9ea252008-10-10 16:12:23 +02001488{
Jan Karacc334122009-01-12 17:23:05 +01001489 int cnt;
1490 struct dquot *put[MAXQUOTAS];
1491
Jan Kara3d9ea252008-10-10 16:12:23 +02001492 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001493 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1494 put[cnt] = inode->i_dquot[cnt];
Jan Karadd6f3c62009-01-26 16:01:43 +01001495 inode->i_dquot[cnt] = NULL;
Jan Karacc334122009-01-12 17:23:05 +01001496 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001498 dqput_all(put);
Christoph Hellwig9f754752010-03-03 09:05:05 -05001499}
1500
1501void dquot_drop(struct inode *inode)
1502{
1503 int cnt;
1504
1505 if (IS_NOQUOTA(inode))
1506 return;
1507
1508 /*
1509 * Test before calling to rule out calls from proc and such
1510 * where we are not allowed to block. Note that this is
1511 * actually reliable test even without the lock - the caller
1512 * must assure that nobody can come after the DQUOT_DROP and
1513 * add quota pointers back anyway.
1514 */
1515 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1516 if (inode->i_dquot[cnt])
1517 break;
1518 }
1519
1520 if (cnt < MAXQUOTAS)
1521 __dquot_drop(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522}
Mingming Cao08d03502009-01-14 16:19:32 +01001523EXPORT_SYMBOL(dquot_drop);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001524
1525/*
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001526 * inode_reserved_space is managed internally by quota, and protected by
1527 * i_lock similar to i_blocks+i_bytes.
1528 */
1529static qsize_t *inode_reserved_space(struct inode * inode)
1530{
1531 /* Filesystem must explicitly define it's own method in order to use
1532 * quota reservation interface */
1533 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1534 return inode->i_sb->dq_op->get_reserved_space(inode);
1535}
1536
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001537void inode_add_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001538{
1539 spin_lock(&inode->i_lock);
1540 *inode_reserved_space(inode) += number;
1541 spin_unlock(&inode->i_lock);
1542}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001543EXPORT_SYMBOL(inode_add_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001544
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001545void inode_claim_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001546{
1547 spin_lock(&inode->i_lock);
1548 *inode_reserved_space(inode) -= number;
1549 __inode_add_bytes(inode, number);
1550 spin_unlock(&inode->i_lock);
1551}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001552EXPORT_SYMBOL(inode_claim_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001553
Jan Kara1c8924e2013-08-17 09:32:32 -04001554void inode_reclaim_rsv_space(struct inode *inode, qsize_t number)
1555{
1556 spin_lock(&inode->i_lock);
1557 *inode_reserved_space(inode) += number;
1558 __inode_sub_bytes(inode, number);
1559 spin_unlock(&inode->i_lock);
1560}
1561EXPORT_SYMBOL(inode_reclaim_rsv_space);
1562
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001563void inode_sub_rsv_space(struct inode *inode, qsize_t number)
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001564{
1565 spin_lock(&inode->i_lock);
1566 *inode_reserved_space(inode) -= number;
1567 spin_unlock(&inode->i_lock);
1568}
Dmitry Monakhovc4690702010-02-09 17:53:36 +01001569EXPORT_SYMBOL(inode_sub_rsv_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001570
1571static qsize_t inode_get_rsv_space(struct inode *inode)
1572{
1573 qsize_t ret;
Jan Kara05b5d892010-01-06 18:03:36 +01001574
1575 if (!inode->i_sb->dq_op->get_reserved_space)
1576 return 0;
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001577 spin_lock(&inode->i_lock);
1578 ret = *inode_reserved_space(inode);
1579 spin_unlock(&inode->i_lock);
1580 return ret;
1581}
1582
1583static void inode_incr_space(struct inode *inode, qsize_t number,
1584 int reserve)
1585{
1586 if (reserve)
1587 inode_add_rsv_space(inode, number);
1588 else
1589 inode_add_bytes(inode, number);
1590}
1591
1592static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1593{
1594 if (reserve)
1595 inode_sub_rsv_space(inode, number);
1596 else
1597 inode_sub_bytes(inode, number);
1598}
1599
1600/*
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001601 * This functions updates i_blocks+i_bytes fields and quota information
1602 * (together with appropriate checks).
1603 *
1604 * NOTE: We absolutely rely on the fact that caller dirties the inode
1605 * (usually helpers in quotaops.h care about this) and holds a handle for
1606 * the current transaction so that dquot write and inode write go into the
1607 * same transaction.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608 */
1609
1610/*
1611 * This operation can block, but only after everything is updated
1612 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001613int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001614{
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001615 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001616 struct dquot_warn warn[MAXQUOTAS];
1617 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001618 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001620 /*
1621 * First test before acquiring mutex - solves deadlocks when we
1622 * re-enter the quota code and are already holding the mutex
1623 */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001624 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001625 inode_incr_space(inode, number, reserve);
1626 goto out;
1627 }
1628
Linus Torvalds1da177e2005-04-16 15:20:36 -07001629 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001630 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631
Jeff Liu6ea2eea2012-07-18 12:12:41 +08001632 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 spin_lock(&dq_data_lock);
1634 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001635 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001637 ret = check_bdq(dquots[cnt], number,
1638 !(flags & DQUOT_SPACE_WARN), &warn[cnt]);
1639 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001640 spin_unlock(&dq_data_lock);
1641 goto out_flush_warn;
Mingming Caof18df222009-01-13 16:43:09 +01001642 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 }
1644 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001645 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646 continue;
Mingming Caof18df222009-01-13 16:43:09 +01001647 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001648 dquot_resv_space(dquots[cnt], number);
Mingming Caof18df222009-01-13 16:43:09 +01001649 else
Jan Karabf097aa2012-02-14 13:28:01 +01001650 dquot_incr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001651 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001652 inode_incr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001654
1655 if (reserve)
1656 goto out_flush_warn;
Jan Karabf097aa2012-02-14 13:28:01 +01001657 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001658out_flush_warn:
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001659 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001660 flush_warnings(warn);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001661out:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662 return ret;
1663}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001664EXPORT_SYMBOL(__dquot_alloc_space);
Mingming Caof18df222009-01-13 16:43:09 +01001665
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666/*
1667 * This operation can block, but only after everything is updated
1668 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001669int dquot_alloc_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001670{
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001671 int cnt, ret = 0;
Jan Karabf097aa2012-02-14 13:28:01 +01001672 struct dquot_warn warn[MAXQUOTAS];
1673 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
Ingo Molnard3be9152006-03-23 03:00:29 -08001675 /* First test before acquiring mutex - solves deadlocks when we
1676 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001677 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001678 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Jan Karabf097aa2012-02-14 13:28:01 +01001680 warn[cnt].w_type = QUOTA_NL_NOWARN;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001681 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 spin_lock(&dq_data_lock);
1683 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001684 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001686 ret = check_idq(dquots[cnt], 1, &warn[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001687 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688 goto warn_put_all;
1689 }
1690
1691 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001692 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001694 dquot_incr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 }
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001696
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697warn_put_all:
1698 spin_unlock(&dq_data_lock);
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001699 if (ret == 0)
Jan Karabf097aa2012-02-14 13:28:01 +01001700 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001702 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 return ret;
1704}
Mingming Cao08d03502009-01-14 16:19:32 +01001705EXPORT_SYMBOL(dquot_alloc_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001707/*
1708 * Convert in-memory reserved quotas to real consumed quotas
1709 */
1710int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
Mingming Cao740d9dc2009-01-13 16:43:14 +01001711{
1712 int cnt;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001713
Christoph Hellwig189eef52010-06-04 10:56:29 +02001714 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001715 inode_claim_rsv_space(inode, number);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001716 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001717 }
1718
1719 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001720 spin_lock(&dq_data_lock);
1721 /* Claim reserved quotas to allocated quotas */
1722 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karadd6f3c62009-01-26 16:01:43 +01001723 if (inode->i_dquot[cnt])
Mingming Cao740d9dc2009-01-13 16:43:14 +01001724 dquot_claim_reserved_space(inode->i_dquot[cnt],
1725 number);
1726 }
1727 /* Update inode bytes */
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001728 inode_claim_rsv_space(inode, number);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001729 spin_unlock(&dq_data_lock);
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001730 mark_all_dquot_dirty(inode->i_dquot);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001731 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001732 return 0;
Mingming Cao740d9dc2009-01-13 16:43:14 +01001733}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001734EXPORT_SYMBOL(dquot_claim_space_nodirty);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001735
1736/*
Jan Kara1c8924e2013-08-17 09:32:32 -04001737 * Convert allocated space back to in-memory reserved quotas
1738 */
1739void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
1740{
1741 int cnt;
1742
1743 if (!dquot_active(inode)) {
1744 inode_reclaim_rsv_space(inode, number);
1745 return;
1746 }
1747
1748 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1749 spin_lock(&dq_data_lock);
1750 /* Claim reserved quotas to allocated quotas */
1751 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1752 if (inode->i_dquot[cnt])
1753 dquot_reclaim_reserved_space(inode->i_dquot[cnt],
1754 number);
1755 }
1756 /* Update inode bytes */
1757 inode_reclaim_rsv_space(inode, number);
1758 spin_unlock(&dq_data_lock);
1759 mark_all_dquot_dirty(inode->i_dquot);
1760 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1761 return;
1762}
1763EXPORT_SYMBOL(dquot_reclaim_space_nodirty);
1764
1765/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766 * This operation can block, but only after everything is updated
1767 */
Eric Sandeen56246f92010-05-16 09:00:00 -04001768void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001769{
1770 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001771 struct dquot_warn warn[MAXQUOTAS];
1772 struct dquot **dquots = inode->i_dquot;
Eric Sandeen56246f92010-05-16 09:00:00 -04001773 int reserve = flags & DQUOT_SPACE_RESERVE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001774
Ingo Molnard3be9152006-03-23 03:00:29 -08001775 /* First test before acquiring mutex - solves deadlocks when we
1776 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001777 if (!dquot_active(inode)) {
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001778 inode_decr_space(inode, number, reserve);
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001779 return;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001780 }
Jan Kara657d3bf2008-07-25 01:46:52 -07001781
Linus Torvalds1da177e2005-04-16 15:20:36 -07001782 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 spin_lock(&dq_data_lock);
1784 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001785 int wtype;
1786
1787 warn[cnt].w_type = QUOTA_NL_NOWARN;
1788 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001790 wtype = info_bdq_free(dquots[cnt], number);
1791 if (wtype != QUOTA_NL_NOWARN)
1792 prepare_warning(&warn[cnt], dquots[cnt], wtype);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001793 if (reserve)
Jan Karabf097aa2012-02-14 13:28:01 +01001794 dquot_free_reserved_space(dquots[cnt], number);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001795 else
Jan Karabf097aa2012-02-14 13:28:01 +01001796 dquot_decr_space(dquots[cnt], number);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797 }
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001798 inode_decr_space(inode, number, reserve);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001799 spin_unlock(&dq_data_lock);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001800
1801 if (reserve)
1802 goto out_unlock;
Jan Karabf097aa2012-02-14 13:28:01 +01001803 mark_all_dquot_dirty(dquots);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001804out_unlock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001806 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807}
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001808EXPORT_SYMBOL(__dquot_free_space);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001809
1810/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001811 * This operation can block, but only after everything is updated
1812 */
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001813void dquot_free_inode(const struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814{
1815 unsigned int cnt;
Jan Karabf097aa2012-02-14 13:28:01 +01001816 struct dquot_warn warn[MAXQUOTAS];
1817 struct dquot * const *dquots = inode->i_dquot;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001818
Ingo Molnard3be9152006-03-23 03:00:29 -08001819 /* First test before acquiring mutex - solves deadlocks when we
1820 * re-enter the quota code and are already holding the mutex */
Christoph Hellwig189eef52010-06-04 10:56:29 +02001821 if (!dquot_active(inode))
Christoph Hellwig63936dd2010-03-03 09:05:01 -05001822 return;
Jan Kara657d3bf2008-07-25 01:46:52 -07001823
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 spin_lock(&dq_data_lock);
1826 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Jan Karabf097aa2012-02-14 13:28:01 +01001827 int wtype;
1828
1829 warn[cnt].w_type = QUOTA_NL_NOWARN;
1830 if (!dquots[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 continue;
Jan Karabf097aa2012-02-14 13:28:01 +01001832 wtype = info_idq_free(dquots[cnt], 1);
1833 if (wtype != QUOTA_NL_NOWARN)
1834 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1835 dquot_decr_inodes(dquots[cnt], 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 }
1837 spin_unlock(&dq_data_lock);
Jan Karabf097aa2012-02-14 13:28:01 +01001838 mark_all_dquot_dirty(dquots);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001840 flush_warnings(warn);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841}
Mingming Cao08d03502009-01-14 16:19:32 +01001842EXPORT_SYMBOL(dquot_free_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843
1844/*
1845 * Transfer the number of inode and blocks from one diskquota to an other.
Jan Karabc8e5f02010-05-13 19:58:50 +02001846 * On success, dquot references in transfer_to are consumed and references
1847 * to original dquots that need to be released are placed there. On failure,
1848 * references are kept untouched.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849 *
1850 * This operation can block, but only after everything is updated
1851 * A transaction must be started when entering this function.
Jan Karabc8e5f02010-05-13 19:58:50 +02001852 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 */
Jan Karabc8e5f02010-05-13 19:58:50 +02001854int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855{
Mingming Cao740d9dc2009-01-13 16:43:14 +01001856 qsize_t space, cur_space;
1857 qsize_t rsv_space = 0;
Jan Karabc8e5f02010-05-13 19:58:50 +02001858 struct dquot *transfer_from[MAXQUOTAS] = {};
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001859 int cnt, ret = 0;
Dmitry9e327842010-10-09 23:15:30 +04001860 char is_valid[MAXQUOTAS] = {};
Jan Karabf097aa2012-02-14 13:28:01 +01001861 struct dquot_warn warn_to[MAXQUOTAS];
1862 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1863 struct dquot_warn warn_from_space[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
Ingo Molnard3be9152006-03-23 03:00:29 -08001865 /* First test before acquiring mutex - solves deadlocks when we
1866 * re-enter the quota code and are already holding the mutex */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 if (IS_NOQUOTA(inode))
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001868 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001869 /* Initialize the arrays */
Jan Karabf097aa2012-02-14 13:28:01 +01001870 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1871 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1872 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1873 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1874 }
Jan Karacc334122009-01-12 17:23:05 +01001875 down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karacc334122009-01-12 17:23:05 +01001876 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
1877 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabc8e5f02010-05-13 19:58:50 +02001878 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001879 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 spin_lock(&dq_data_lock);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001881 cur_space = inode_get_bytes(inode);
Dmitry Monakhovfd8fbfc2009-12-14 15:21:13 +03001882 rsv_space = inode_get_rsv_space(inode);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001883 space = cur_space + rsv_space;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 /* Build the transfer_from list and check the limits */
1885 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001886 /*
1887 * Skip changes for same uid or gid or for turned off quota-type.
1888 */
Jan Karadd6f3c62009-01-26 16:01:43 +01001889 if (!transfer_to[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001890 continue;
Dmitry9e327842010-10-09 23:15:30 +04001891 /* Avoid races with quotaoff() */
1892 if (!sb_has_quota_active(inode->i_sb, cnt))
1893 continue;
1894 is_valid[cnt] = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 transfer_from[cnt] = inode->i_dquot[cnt];
Jan Karabf097aa2012-02-14 13:28:01 +01001896 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001897 if (ret)
1898 goto over_quota;
Jan Karabf097aa2012-02-14 13:28:01 +01001899 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
Christoph Hellwigefd8f0e2010-03-03 09:05:08 -05001900 if (ret)
Jan Karacc334122009-01-12 17:23:05 +01001901 goto over_quota;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 }
1903
1904 /*
1905 * Finally perform the needed transfer from transfer_from to transfer_to
1906 */
1907 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
Dmitry9e327842010-10-09 23:15:30 +04001908 if (!is_valid[cnt])
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 /* Due to IO error we might not have transfer_from[] structure */
1911 if (transfer_from[cnt]) {
Jan Karabf097aa2012-02-14 13:28:01 +01001912 int wtype;
1913 wtype = info_idq_free(transfer_from[cnt], 1);
1914 if (wtype != QUOTA_NL_NOWARN)
1915 prepare_warning(&warn_from_inodes[cnt],
1916 transfer_from[cnt], wtype);
1917 wtype = info_bdq_free(transfer_from[cnt], space);
1918 if (wtype != QUOTA_NL_NOWARN)
1919 prepare_warning(&warn_from_space[cnt],
1920 transfer_from[cnt], wtype);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001921 dquot_decr_inodes(transfer_from[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001922 dquot_decr_space(transfer_from[cnt], cur_space);
1923 dquot_free_reserved_space(transfer_from[cnt],
1924 rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 }
1926
1927 dquot_incr_inodes(transfer_to[cnt], 1);
Mingming Cao740d9dc2009-01-13 16:43:14 +01001928 dquot_incr_space(transfer_to[cnt], cur_space);
1929 dquot_resv_space(transfer_to[cnt], rsv_space);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930
1931 inode->i_dquot[cnt] = transfer_to[cnt];
1932 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 spin_unlock(&dq_data_lock);
Jan Karacc334122009-01-12 17:23:05 +01001934 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1935
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001936 mark_all_dquot_dirty(transfer_from);
1937 mark_all_dquot_dirty(transfer_to);
Jan Karabf097aa2012-02-14 13:28:01 +01001938 flush_warnings(warn_to);
1939 flush_warnings(warn_from_inodes);
1940 flush_warnings(warn_from_space);
Jan Karabc8e5f02010-05-13 19:58:50 +02001941 /* Pass back references to put */
Dmitry Monakhovdc52dd32009-12-14 15:21:15 +03001942 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
Dmitry9e327842010-10-09 23:15:30 +04001943 if (is_valid[cnt])
1944 transfer_to[cnt] = transfer_from[cnt];
Jan Kara86f3cbe2010-10-11 15:22:21 +02001945 return 0;
Jan Karacc334122009-01-12 17:23:05 +01001946over_quota:
1947 spin_unlock(&dq_data_lock);
1948 up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
Jan Karabf097aa2012-02-14 13:28:01 +01001949 flush_warnings(warn_to);
Jan Kara86f3cbe2010-10-11 15:22:21 +02001950 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951}
Jan Karabc8e5f02010-05-13 19:58:50 +02001952EXPORT_SYMBOL(__dquot_transfer);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001953
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001954/* Wrapper for transferring ownership of an inode for uid/gid only
1955 * Called from FSXXX_setattr()
1956 */
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001957int dquot_transfer(struct inode *inode, struct iattr *iattr)
Jan Karab85f4b82008-07-25 01:46:50 -07001958{
Jan Karabc8e5f02010-05-13 19:58:50 +02001959 struct dquot *transfer_to[MAXQUOTAS] = {};
1960 struct super_block *sb = inode->i_sb;
1961 int ret;
Dmitry Monakhov8ddd69d2010-02-16 08:31:50 +03001962
Christoph Hellwig189eef52010-06-04 10:56:29 +02001963 if (!dquot_active(inode))
Jan Karabc8e5f02010-05-13 19:58:50 +02001964 return 0;
Dmitry Monakhov12755622010-04-08 22:04:20 +04001965
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001966 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid))
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001967 transfer_to[USRQUOTA] = dqget(sb, make_kqid_uid(iattr->ia_uid));
Eric W. Biederman1a06d422012-09-16 05:45:30 -07001968 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid))
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07001969 transfer_to[GRPQUOTA] = dqget(sb, make_kqid_gid(iattr->ia_gid));
Jan Karabc8e5f02010-05-13 19:58:50 +02001970
1971 ret = __dquot_transfer(inode, transfer_to);
1972 dqput_all(transfer_to);
1973 return ret;
Jan Karab85f4b82008-07-25 01:46:50 -07001974}
Christoph Hellwigb43fa822010-03-03 09:05:03 -05001975EXPORT_SYMBOL(dquot_transfer);
Jan Karab85f4b82008-07-25 01:46:50 -07001976
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977/*
1978 * Write info of quota file to disk
1979 */
1980int dquot_commit_info(struct super_block *sb, int type)
1981{
1982 int ret;
1983 struct quota_info *dqopt = sb_dqopt(sb);
1984
Ingo Molnard3be9152006-03-23 03:00:29 -08001985 mutex_lock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 ret = dqopt->ops[type]->write_file_info(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08001987 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001988 return ret;
1989}
Mingming Cao08d03502009-01-14 16:19:32 +01001990EXPORT_SYMBOL(dquot_commit_info);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
1992/*
1993 * Definitions of diskquota operations.
1994 */
Alexey Dobriyan61e225d2009-09-21 17:01:08 -07001995const struct dquot_operations dquot_operations = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 .write_dquot = dquot_commit,
1997 .acquire_dquot = dquot_acquire,
1998 .release_dquot = dquot_release,
1999 .mark_dirty = dquot_mark_dquot_dirty,
Jan Kara74f783a2008-08-19 14:51:22 +02002000 .write_info = dquot_commit_info,
2001 .alloc_dquot = dquot_alloc,
2002 .destroy_dquot = dquot_destroy,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003};
Christoph Hellwig123e9ca2010-05-19 07:16:44 -04002004EXPORT_SYMBOL(dquot_operations);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006/*
Christoph Hellwig907f4552010-03-03 09:05:06 -05002007 * Generic helper for ->open on filesystems supporting disk quotas.
2008 */
2009int dquot_file_open(struct inode *inode, struct file *file)
2010{
2011 int error;
2012
2013 error = generic_file_open(inode, file);
2014 if (!error && (file->f_mode & FMODE_WRITE))
Christoph Hellwig871a2932010-03-03 09:05:07 -05002015 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -05002016 return error;
2017}
2018EXPORT_SYMBOL(dquot_file_open);
2019
2020/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
2022 */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002023int dquot_disable(struct super_block *sb, int type, unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024{
Jan Kara0ff5af82008-04-28 02:14:33 -07002025 int cnt, ret = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002026 struct quota_info *dqopt = sb_dqopt(sb);
2027 struct inode *toputinode[MAXQUOTAS];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002028
Jan Karaf55abc02008-08-20 17:50:32 +02002029 /* Cannot turn off usage accounting without turning off limits, or
2030 * suspend quotas and simultaneously turn quotas off. */
2031 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
2032 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
2033 DQUOT_USAGE_ENABLED)))
2034 return -EINVAL;
2035
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036 /* We need to serialize quota_off() for device */
Ingo Molnard3be9152006-03-23 03:00:29 -08002037 mutex_lock(&dqopt->dqonoff_mutex);
Jan Kara9377abd2008-05-12 14:02:08 -07002038
2039 /*
2040 * Skip everything if there's nothing to do. We have to do this because
2041 * sometimes we are called when fill_super() failed and calling
2042 * sync_fs() in such cases does no good.
2043 */
Jan Karaf55abc02008-08-20 17:50:32 +02002044 if (!sb_any_quota_loaded(sb)) {
Jan Kara9377abd2008-05-12 14:02:08 -07002045 mutex_unlock(&dqopt->dqonoff_mutex);
2046 return 0;
2047 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2049 toputinode[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 if (type != -1 && cnt != type)
2051 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002052 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002053 continue;
Jan Karaf55abc02008-08-20 17:50:32 +02002054
2055 if (flags & DQUOT_SUSPENDED) {
Jan Karacc334122009-01-12 17:23:05 +01002056 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002057 dqopt->flags |=
2058 dquot_state_flag(DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002059 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002060 } else {
Jan Karacc334122009-01-12 17:23:05 +01002061 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002062 dqopt->flags &= ~dquot_state_flag(flags, cnt);
2063 /* Turning off suspended quotas? */
2064 if (!sb_has_quota_loaded(sb, cnt) &&
2065 sb_has_quota_suspended(sb, cnt)) {
2066 dqopt->flags &= ~dquot_state_flag(
2067 DQUOT_SUSPENDED, cnt);
Jan Karacc334122009-01-12 17:23:05 +01002068 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002069 iput(dqopt->files[cnt]);
2070 dqopt->files[cnt] = NULL;
2071 continue;
2072 }
Jan Karacc334122009-01-12 17:23:05 +01002073 spin_unlock(&dq_state_lock);
Jan Kara0ff5af82008-04-28 02:14:33 -07002074 }
Jan Karaf55abc02008-08-20 17:50:32 +02002075
2076 /* We still have to keep quota loaded? */
2077 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
Linus Torvalds1da177e2005-04-16 15:20:36 -07002078 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079
2080 /* Note: these are blocking operations */
2081 drop_dquot_ref(sb, cnt);
2082 invalidate_dquots(sb, cnt);
2083 /*
Jan Kara268157b2009-01-27 15:47:22 +01002084 * Now all dquots should be invalidated, all writes done so we
2085 * should be only users of the info. No locks needed.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002086 */
2087 if (info_dirty(&dqopt->info[cnt]))
2088 sb->dq_op->write_info(sb, cnt);
2089 if (dqopt->ops[cnt]->free_file_info)
2090 dqopt->ops[cnt]->free_file_info(sb, cnt);
2091 put_quota_format(dqopt->info[cnt].dqi_format);
2092
2093 toputinode[cnt] = dqopt->files[cnt];
Jan Karaf55abc02008-08-20 17:50:32 +02002094 if (!sb_has_quota_loaded(sb, cnt))
Jan Kara0ff5af82008-04-28 02:14:33 -07002095 dqopt->files[cnt] = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096 dqopt->info[cnt].dqi_flags = 0;
2097 dqopt->info[cnt].dqi_igrace = 0;
2098 dqopt->info[cnt].dqi_bgrace = 0;
2099 dqopt->ops[cnt] = NULL;
2100 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002101 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002102
2103 /* Skip syncing and setting flags if quota files are hidden */
2104 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2105 goto put_inodes;
2106
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 /* Sync the superblock so that buffers with quota data are written to
Al Viro7b7b1ac2005-11-07 17:13:39 -05002108 * disk (and so userspace sees correct data afterwards). */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002109 if (sb->s_op->sync_fs)
2110 sb->s_op->sync_fs(sb, 1);
2111 sync_blockdev(sb->s_bdev);
2112 /* Now the quota files are just ordinary files and we can set the
2113 * inode flags back. Moreover we discard the pagecache so that
2114 * userspace sees the writes we did bypassing the pagecache. We
2115 * must also discard the blockdev buffers so that we see the
2116 * changes done by userspace on the next quotaon() */
2117 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2118 if (toputinode[cnt]) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002119 mutex_lock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120 /* If quota was reenabled in the meantime, we have
2121 * nothing to do */
Jan Karaf55abc02008-08-20 17:50:32 +02002122 if (!sb_has_quota_loaded(sb, cnt)) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002123 mutex_lock(&toputinode[cnt]->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002124 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
2125 S_NOATIME | S_NOQUOTA);
Jan Kara268157b2009-01-27 15:47:22 +01002126 truncate_inode_pages(&toputinode[cnt]->i_data,
2127 0);
Jes Sorensen1b1dcc12006-01-09 15:59:24 -08002128 mutex_unlock(&toputinode[cnt]->i_mutex);
Jan Kara43d29322010-07-21 14:22:21 +02002129 mark_inode_dirty_sync(toputinode[cnt]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002130 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002131 mutex_unlock(&dqopt->dqonoff_mutex);
Jan Karaca785ec2008-09-30 17:53:37 +02002132 }
2133 if (sb->s_bdev)
2134 invalidate_bdev(sb->s_bdev);
2135put_inodes:
2136 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2137 if (toputinode[cnt]) {
Jan Kara0ff5af82008-04-28 02:14:33 -07002138 /* On remount RO, we keep the inode pointer so that we
Jan Karaf55abc02008-08-20 17:50:32 +02002139 * can reenable quota on the subsequent remount RW. We
2140 * have to check 'flags' variable and not use sb_has_
2141 * function because another quotaon / quotaoff could
2142 * change global state before we got here. We refuse
2143 * to suspend quotas when there is pending delete on
2144 * the quota file... */
2145 if (!(flags & DQUOT_SUSPENDED))
Jan Kara0ff5af82008-04-28 02:14:33 -07002146 iput(toputinode[cnt]);
2147 else if (!toputinode[cnt]->i_nlink)
2148 ret = -EBUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002150 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002152EXPORT_SYMBOL(dquot_disable);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153
Christoph Hellwig287a8092010-05-19 07:16:45 -04002154int dquot_quota_off(struct super_block *sb, int type)
Jan Karaf55abc02008-08-20 17:50:32 +02002155{
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002156 return dquot_disable(sb, type,
2157 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Jan Karaf55abc02008-08-20 17:50:32 +02002158}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002159EXPORT_SYMBOL(dquot_quota_off);
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002160
Linus Torvalds1da177e2005-04-16 15:20:36 -07002161/*
2162 * Turn quotas on on a device
2163 */
2164
Jan Karaf55abc02008-08-20 17:50:32 +02002165/*
2166 * Helper function to turn quotas on when we already have the inode of
2167 * quota file and no quota information is loaded.
2168 */
2169static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2170 unsigned int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171{
2172 struct quota_format_type *fmt = find_quota_format(format_id);
2173 struct super_block *sb = inode->i_sb;
2174 struct quota_info *dqopt = sb_dqopt(sb);
2175 int error;
2176 int oldflags = -1;
2177
2178 if (!fmt)
2179 return -ESRCH;
2180 if (!S_ISREG(inode->i_mode)) {
2181 error = -EACCES;
2182 goto out_fmt;
2183 }
2184 if (IS_RDONLY(inode)) {
2185 error = -EROFS;
2186 goto out_fmt;
2187 }
2188 if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
2189 error = -EINVAL;
2190 goto out_fmt;
2191 }
Jan Karaf55abc02008-08-20 17:50:32 +02002192 /* Usage always has to be set... */
2193 if (!(flags & DQUOT_USAGE_ENABLED)) {
2194 error = -EINVAL;
2195 goto out_fmt;
2196 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002197
Jan Karaca785ec2008-09-30 17:53:37 +02002198 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
Jan Karaab94c392010-02-22 21:07:17 +01002199 /* As we bypass the pagecache we must now flush all the
2200 * dirty data and invalidate caches so that kernel sees
2201 * changes from userspace. It is not enough to just flush
2202 * the quota file since if blocksize < pagesize, invalidation
2203 * of the cache could fail because of other unrelated dirty
2204 * data */
2205 sync_filesystem(sb);
Jan Karaca785ec2008-09-30 17:53:37 +02002206 invalidate_bdev(sb->s_bdev);
2207 }
Ingo Molnard3be9152006-03-23 03:00:29 -08002208 mutex_lock(&dqopt->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002209 if (sb_has_quota_loaded(sb, type)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002210 error = -EBUSY;
2211 goto out_lock;
2212 }
Jan Karaca785ec2008-09-30 17:53:37 +02002213
2214 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2215 /* We don't want quota and atime on quota files (deadlocks
2216 * possible) Also nobody should write to the file - we use
2217 * special IO operations which ignore the immutable bit. */
Jan Karaa80b12c2012-04-25 21:15:53 +02002218 mutex_lock(&inode->i_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002219 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2220 S_NOQUOTA);
Jan Karaca785ec2008-09-30 17:53:37 +02002221 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
Jan Karadee86562009-07-22 18:12:17 +02002222 mutex_unlock(&inode->i_mutex);
Jan Kara26245c92010-01-06 17:20:35 +01002223 /*
2224 * When S_NOQUOTA is set, remove dquot references as no more
2225 * references can be added
2226 */
Christoph Hellwig9f754752010-03-03 09:05:05 -05002227 __dquot_drop(inode);
Jan Karaca785ec2008-09-30 17:53:37 +02002228 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229
2230 error = -EIO;
2231 dqopt->files[type] = igrab(inode);
2232 if (!dqopt->files[type])
2233 goto out_lock;
2234 error = -EINVAL;
2235 if (!fmt->qf_ops->check_quota_file(sb, type))
2236 goto out_file_init;
2237
2238 dqopt->ops[type] = fmt->qf_ops;
2239 dqopt->info[type].dqi_format = fmt;
Jan Kara0ff5af82008-04-28 02:14:33 -07002240 dqopt->info[type].dqi_fmt_id = format_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
Ingo Molnard3be9152006-03-23 03:00:29 -08002242 mutex_lock(&dqopt->dqio_mutex);
Jan Kara268157b2009-01-27 15:47:22 +01002243 error = dqopt->ops[type]->read_file_info(sb, type);
2244 if (error < 0) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002245 mutex_unlock(&dqopt->dqio_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002246 goto out_file_init;
2247 }
Jan Kara46fe44c2011-11-16 15:03:59 +01002248 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2249 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
Ingo Molnard3be9152006-03-23 03:00:29 -08002250 mutex_unlock(&dqopt->dqio_mutex);
Jan Karacc334122009-01-12 17:23:05 +01002251 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002252 dqopt->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002253 spin_unlock(&dq_state_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002254
2255 add_dquot_ref(sb, type);
Ingo Molnard3be9152006-03-23 03:00:29 -08002256 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257
2258 return 0;
2259
2260out_file_init:
2261 dqopt->files[type] = NULL;
2262 iput(inode);
2263out_lock:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002264 if (oldflags != -1) {
Jan Karaa80b12c2012-04-25 21:15:53 +02002265 mutex_lock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266 /* Set the flags back (in the case of accidental quotaon()
2267 * on a wrong file we don't want to mess up the flags) */
2268 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2269 inode->i_flags |= oldflags;
Jan Karadee86562009-07-22 18:12:17 +02002270 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002271 }
Jiaying Zhangd01730d2009-07-07 18:15:21 +02002272 mutex_unlock(&dqopt->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273out_fmt:
2274 put_quota_format(fmt);
2275
2276 return error;
2277}
2278
Jan Kara0ff5af82008-04-28 02:14:33 -07002279/* Reenable quotas on remount RW */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002280int dquot_resume(struct super_block *sb, int type)
Jan Kara0ff5af82008-04-28 02:14:33 -07002281{
2282 struct quota_info *dqopt = sb_dqopt(sb);
2283 struct inode *inode;
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002284 int ret = 0, cnt;
Jan Karaf55abc02008-08-20 17:50:32 +02002285 unsigned int flags;
Jan Kara0ff5af82008-04-28 02:14:33 -07002286
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002287 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2288 if (type != -1 && cnt != type)
2289 continue;
Jan Kara0ff5af82008-04-28 02:14:33 -07002290
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002291 mutex_lock(&dqopt->dqonoff_mutex);
2292 if (!sb_has_quota_suspended(sb, cnt)) {
2293 mutex_unlock(&dqopt->dqonoff_mutex);
2294 continue;
2295 }
2296 inode = dqopt->files[cnt];
2297 dqopt->files[cnt] = NULL;
2298 spin_lock(&dq_state_lock);
2299 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2300 DQUOT_LIMITS_ENABLED,
2301 cnt);
2302 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2303 spin_unlock(&dq_state_lock);
2304 mutex_unlock(&dqopt->dqonoff_mutex);
2305
2306 flags = dquot_generic_flag(flags, cnt);
2307 ret = vfs_load_quota_inode(inode, cnt,
2308 dqopt->info[cnt].dqi_fmt_id, flags);
2309 iput(inode);
2310 }
Jan Kara0ff5af82008-04-28 02:14:33 -07002311
2312 return ret;
2313}
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002314EXPORT_SYMBOL(dquot_resume);
Jan Kara0ff5af82008-04-28 02:14:33 -07002315
Jan Karaf00c9e42010-09-15 17:38:58 +02002316int dquot_quota_on(struct super_block *sb, int type, int format_id,
2317 struct path *path)
Al Viro77e69da2008-08-01 04:29:18 -04002318{
2319 int error = security_quota_on(path->dentry);
2320 if (error)
2321 return error;
2322 /* Quota file not on the same filesystem? */
Al Virod8c95842011-12-07 18:16:57 -05002323 if (path->dentry->d_sb != sb)
Al Viro77e69da2008-08-01 04:29:18 -04002324 error = -EXDEV;
2325 else
Jan Karaf55abc02008-08-20 17:50:32 +02002326 error = vfs_load_quota_inode(path->dentry->d_inode, type,
2327 format_id, DQUOT_USAGE_ENABLED |
2328 DQUOT_LIMITS_ENABLED);
Al Viro77e69da2008-08-01 04:29:18 -04002329 return error;
2330}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002331EXPORT_SYMBOL(dquot_quota_on);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332
2333/*
Jan Karaf55abc02008-08-20 17:50:32 +02002334 * More powerful function for turning on quotas allowing setting
2335 * of individual quota flags
2336 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002337int dquot_enable(struct inode *inode, int type, int format_id,
2338 unsigned int flags)
Jan Karaf55abc02008-08-20 17:50:32 +02002339{
2340 int ret = 0;
2341 struct super_block *sb = inode->i_sb;
2342 struct quota_info *dqopt = sb_dqopt(sb);
2343
2344 /* Just unsuspend quotas? */
Christoph Hellwig0f0dd622010-05-19 07:16:41 -04002345 BUG_ON(flags & DQUOT_SUSPENDED);
2346
Jan Karaf55abc02008-08-20 17:50:32 +02002347 if (!flags)
2348 return 0;
2349 /* Just updating flags needed? */
2350 if (sb_has_quota_loaded(sb, type)) {
2351 mutex_lock(&dqopt->dqonoff_mutex);
2352 /* Now do a reliable test... */
2353 if (!sb_has_quota_loaded(sb, type)) {
2354 mutex_unlock(&dqopt->dqonoff_mutex);
2355 goto load_quota;
2356 }
2357 if (flags & DQUOT_USAGE_ENABLED &&
2358 sb_has_quota_usage_enabled(sb, type)) {
2359 ret = -EBUSY;
2360 goto out_lock;
2361 }
2362 if (flags & DQUOT_LIMITS_ENABLED &&
2363 sb_has_quota_limits_enabled(sb, type)) {
2364 ret = -EBUSY;
2365 goto out_lock;
2366 }
Jan Karacc334122009-01-12 17:23:05 +01002367 spin_lock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002368 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
Jan Karacc334122009-01-12 17:23:05 +01002369 spin_unlock(&dq_state_lock);
Jan Karaf55abc02008-08-20 17:50:32 +02002370out_lock:
2371 mutex_unlock(&dqopt->dqonoff_mutex);
2372 return ret;
2373 }
2374
2375load_quota:
2376 return vfs_load_quota_inode(inode, type, format_id, flags);
2377}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002378EXPORT_SYMBOL(dquot_enable);
Jan Karaf55abc02008-08-20 17:50:32 +02002379
2380/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002381 * This function is used when filesystem needs to initialize quotas
2382 * during mount time.
2383 */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002384int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
Christoph Hellwig84de8562005-06-23 00:09:16 -07002385 int format_id, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002386{
Christoph Hellwig84de8562005-06-23 00:09:16 -07002387 struct dentry *dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 int error;
2389
Jan Karac56818d2009-11-12 15:42:08 +01002390 mutex_lock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig2fa389c2005-06-23 00:09:16 -07002391 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
Jan Karac56818d2009-11-12 15:42:08 +01002392 mutex_unlock(&sb->s_root->d_inode->i_mutex);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002393 if (IS_ERR(dentry))
2394 return PTR_ERR(dentry);
2395
Jan Kara154f4842005-11-28 13:44:14 -08002396 if (!dentry->d_inode) {
2397 error = -ENOENT;
2398 goto out;
2399 }
2400
Linus Torvalds1da177e2005-04-16 15:20:36 -07002401 error = security_quota_on(dentry);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002402 if (!error)
Jan Karaf55abc02008-08-20 17:50:32 +02002403 error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
2404 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
Christoph Hellwig84de8562005-06-23 00:09:16 -07002405
Jan Kara154f4842005-11-28 13:44:14 -08002406out:
Christoph Hellwig84de8562005-06-23 00:09:16 -07002407 dput(dentry);
2408 return error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002409}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002410EXPORT_SYMBOL(dquot_quota_on_mount);
Jan Karab85f4b82008-07-25 01:46:50 -07002411
Jan Kara12095462008-08-20 14:45:12 +02002412static inline qsize_t qbtos(qsize_t blocks)
2413{
2414 return blocks << QIF_DQBLKSIZE_BITS;
2415}
2416
2417static inline qsize_t stoqb(qsize_t space)
2418{
2419 return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
2420}
2421
Linus Torvalds1da177e2005-04-16 15:20:36 -07002422/* Generic routine for getting common part of quota structure */
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002423static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002424{
2425 struct mem_dqblk *dm = &dquot->dq_dqb;
2426
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002427 memset(di, 0, sizeof(*di));
2428 di->d_version = FS_DQUOT_VERSION;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002429 di->d_flags = dquot->dq_id.type == USRQUOTA ?
Christoph Hellwigade7ce32010-06-04 10:56:01 +02002430 FS_USER_QUOTA : FS_GROUP_QUOTA;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002431 di->d_id = from_kqid_munged(current_user_ns(), dquot->dq_id);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002432
Linus Torvalds1da177e2005-04-16 15:20:36 -07002433 spin_lock(&dq_data_lock);
Christoph Hellwigb9b2dd32010-05-06 17:04:58 -04002434 di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
2435 di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
2436 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2437 di->d_ino_softlimit = dm->dqb_isoftlimit;
2438 di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
2439 di->d_icount = dm->dqb_curinodes;
2440 di->d_btimer = dm->dqb_btime;
2441 di->d_itimer = dm->dqb_itime;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002442 spin_unlock(&dq_data_lock);
2443}
2444
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002445int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
Christoph Hellwig287a8092010-05-19 07:16:45 -04002446 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002447{
2448 struct dquot *dquot;
2449
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002450 dquot = dqget(sb, qid);
Jan Karadd6f3c62009-01-26 16:01:43 +01002451 if (!dquot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002452 return -ESRCH;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002453 do_get_dqblk(dquot, di);
2454 dqput(dquot);
Jan Karacc334122009-01-12 17:23:05 +01002455
Linus Torvalds1da177e2005-04-16 15:20:36 -07002456 return 0;
2457}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002458EXPORT_SYMBOL(dquot_get_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459
Christoph Hellwigc472b432010-05-06 17:05:17 -04002460#define VFS_FS_DQ_MASK \
2461 (FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
2462 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
2463 FS_DQ_BTIMER | FS_DQ_ITIMER)
2464
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465/* Generic routine for setting common part of quota structure */
Christoph Hellwigc472b432010-05-06 17:05:17 -04002466static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002467{
2468 struct mem_dqblk *dm = &dquot->dq_dqb;
2469 int check_blim = 0, check_ilim = 0;
Eric W. Biederman4c376dc2012-09-16 03:56:19 -07002470 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002471
Christoph Hellwigc472b432010-05-06 17:05:17 -04002472 if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
2473 return -EINVAL;
2474
2475 if (((di->d_fieldmask & FS_DQ_BSOFT) &&
2476 (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
2477 ((di->d_fieldmask & FS_DQ_BHARD) &&
2478 (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
2479 ((di->d_fieldmask & FS_DQ_ISOFT) &&
2480 (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
2481 ((di->d_fieldmask & FS_DQ_IHARD) &&
2482 (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002483 return -ERANGE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484
2485 spin_lock(&dq_data_lock);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002486 if (di->d_fieldmask & FS_DQ_BCOUNT) {
2487 dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002488 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002489 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002490 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002491
2492 if (di->d_fieldmask & FS_DQ_BSOFT)
2493 dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
2494 if (di->d_fieldmask & FS_DQ_BHARD)
2495 dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
2496 if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002497 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002498 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002499 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002500
2501 if (di->d_fieldmask & FS_DQ_ICOUNT) {
2502 dm->dqb_curinodes = di->d_icount;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002503 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002504 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002505 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002506
2507 if (di->d_fieldmask & FS_DQ_ISOFT)
2508 dm->dqb_isoftlimit = di->d_ino_softlimit;
2509 if (di->d_fieldmask & FS_DQ_IHARD)
2510 dm->dqb_ihardlimit = di->d_ino_hardlimit;
2511 if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002512 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002513 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002514 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002515
2516 if (di->d_fieldmask & FS_DQ_BTIMER) {
2517 dm->dqb_btime = di->d_btimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002518 check_blim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002519 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002520 }
Christoph Hellwigc472b432010-05-06 17:05:17 -04002521
2522 if (di->d_fieldmask & FS_DQ_ITIMER) {
2523 dm->dqb_itime = di->d_itimer;
Jan Karae04a88a92009-01-07 18:07:29 -08002524 check_ilim = 1;
Andrew Perepechko08261672010-04-12 22:16:50 +04002525 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
Jan Kara4d59bce2008-10-02 16:48:10 +02002526 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002527
2528 if (check_blim) {
Jan Kara268157b2009-01-27 15:47:22 +01002529 if (!dm->dqb_bsoftlimit ||
2530 dm->dqb_curspace < dm->dqb_bsoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002531 dm->dqb_btime = 0;
2532 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002533 } else if (!(di->d_fieldmask & FS_DQ_BTIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002534 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002535 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002536 }
2537 if (check_ilim) {
Jan Kara268157b2009-01-27 15:47:22 +01002538 if (!dm->dqb_isoftlimit ||
2539 dm->dqb_curinodes < dm->dqb_isoftlimit) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002540 dm->dqb_itime = 0;
2541 clear_bit(DQ_INODES_B, &dquot->dq_flags);
Christoph Hellwigc472b432010-05-06 17:05:17 -04002542 } else if (!(di->d_fieldmask & FS_DQ_ITIMER))
Jan Kara268157b2009-01-27 15:47:22 +01002543 /* Set grace only if user hasn't provided his own... */
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002544 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 }
Jan Kara268157b2009-01-27 15:47:22 +01002546 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2547 dm->dqb_isoftlimit)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2549 else
2550 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2551 spin_unlock(&dq_data_lock);
2552 mark_dquot_dirty(dquot);
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002553
2554 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002555}
2556
Eric W. Biederman74a8a102012-09-16 02:07:49 -07002557int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
Christoph Hellwigc472b432010-05-06 17:05:17 -04002558 struct fs_disk_quota *di)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002559{
2560 struct dquot *dquot;
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002561 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002562
Eric W. Biedermanaca645a2012-09-16 03:11:50 -07002563 dquot = dqget(sb, qid);
Jan Karaf55abc02008-08-20 17:50:32 +02002564 if (!dquot) {
2565 rc = -ESRCH;
2566 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002567 }
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002568 rc = do_set_dqblk(dquot, di);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002569 dqput(dquot);
Jan Karaf55abc02008-08-20 17:50:32 +02002570out:
Andrew Perepechko338bf9a2008-04-28 02:14:31 -07002571 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002573EXPORT_SYMBOL(dquot_set_dqblk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574
2575/* Generic routine for getting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002576int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002577{
2578 struct mem_dqinfo *mi;
2579
Ingo Molnard3be9152006-03-23 03:00:29 -08002580 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002581 if (!sb_has_quota_active(sb, type)) {
Ingo Molnard3be9152006-03-23 03:00:29 -08002582 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002583 return -ESRCH;
2584 }
2585 mi = sb_dqopt(sb)->info + type;
2586 spin_lock(&dq_data_lock);
2587 ii->dqi_bgrace = mi->dqi_bgrace;
2588 ii->dqi_igrace = mi->dqi_igrace;
Jan Kara46fe44c2011-11-16 15:03:59 +01002589 ii->dqi_flags = mi->dqi_flags & DQF_GETINFO_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590 ii->dqi_valid = IIF_ALL;
2591 spin_unlock(&dq_data_lock);
Ingo Molnard3be9152006-03-23 03:00:29 -08002592 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002593 return 0;
2594}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002595EXPORT_SYMBOL(dquot_get_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002596
2597/* Generic routine for setting common part of quota file information */
Christoph Hellwig287a8092010-05-19 07:16:45 -04002598int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002599{
2600 struct mem_dqinfo *mi;
Jan Karaf55abc02008-08-20 17:50:32 +02002601 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002602
Ingo Molnard3be9152006-03-23 03:00:29 -08002603 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002604 if (!sb_has_quota_active(sb, type)) {
2605 err = -ESRCH;
2606 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002607 }
2608 mi = sb_dqopt(sb)->info + type;
2609 spin_lock(&dq_data_lock);
2610 if (ii->dqi_valid & IIF_BGRACE)
2611 mi->dqi_bgrace = ii->dqi_bgrace;
2612 if (ii->dqi_valid & IIF_IGRACE)
2613 mi->dqi_igrace = ii->dqi_igrace;
2614 if (ii->dqi_valid & IIF_FLAGS)
Jan Kara46fe44c2011-11-16 15:03:59 +01002615 mi->dqi_flags = (mi->dqi_flags & ~DQF_SETINFO_MASK) |
2616 (ii->dqi_flags & DQF_SETINFO_MASK);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002617 spin_unlock(&dq_data_lock);
2618 mark_info_dirty(sb, type);
2619 /* Force write to disk */
2620 sb->dq_op->write_info(sb, type);
Jan Karaf55abc02008-08-20 17:50:32 +02002621out:
Ingo Molnard3be9152006-03-23 03:00:29 -08002622 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
Jan Karaf55abc02008-08-20 17:50:32 +02002623 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002624}
Christoph Hellwig287a8092010-05-19 07:16:45 -04002625EXPORT_SYMBOL(dquot_set_dqinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002626
Christoph Hellwig287a8092010-05-19 07:16:45 -04002627const struct quotactl_ops dquot_quotactl_ops = {
2628 .quota_on = dquot_quota_on,
2629 .quota_off = dquot_quota_off,
2630 .quota_sync = dquot_quota_sync,
2631 .get_info = dquot_get_dqinfo,
2632 .set_info = dquot_set_dqinfo,
2633 .get_dqblk = dquot_get_dqblk,
2634 .set_dqblk = dquot_set_dqblk
Linus Torvalds1da177e2005-04-16 15:20:36 -07002635};
Christoph Hellwig287a8092010-05-19 07:16:45 -04002636EXPORT_SYMBOL(dquot_quotactl_ops);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002637
2638static int do_proc_dqstats(struct ctl_table *table, int write,
2639 void __user *buffer, size_t *lenp, loff_t *ppos)
2640{
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002641 unsigned int type = (int *)table->data - dqstats.stat;
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002642
2643 /* Update global table */
2644 dqstats.stat[type] =
2645 percpu_counter_sum_positive(&dqstats.counter[type]);
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002646 return proc_dointvec(table, write, buffer, lenp, ppos);
2647}
2648
Joe Perchese6287532013-06-13 19:37:49 -07002649static struct ctl_table fs_dqstats_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002651 .procname = "lookups",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002652 .data = &dqstats.stat[DQST_LOOKUPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002653 .maxlen = sizeof(int),
2654 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002655 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002656 },
2657 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002658 .procname = "drops",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002659 .data = &dqstats.stat[DQST_DROPS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002660 .maxlen = sizeof(int),
2661 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002662 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663 },
2664 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 .procname = "reads",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002666 .data = &dqstats.stat[DQST_READS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002667 .maxlen = sizeof(int),
2668 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002669 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002670 },
2671 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002672 .procname = "writes",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002673 .data = &dqstats.stat[DQST_WRITES],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002674 .maxlen = sizeof(int),
2675 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002676 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002677 },
2678 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 .procname = "cache_hits",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002680 .data = &dqstats.stat[DQST_CACHE_HITS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 .maxlen = sizeof(int),
2682 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002683 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002684 },
2685 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002686 .procname = "allocated_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002687 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002688 .maxlen = sizeof(int),
2689 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002690 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002691 },
2692 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002693 .procname = "free_dquots",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002694 .data = &dqstats.stat[DQST_FREE_DQUOTS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002695 .maxlen = sizeof(int),
2696 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002697 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002698 },
2699 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002700 .procname = "syncs",
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002701 .data = &dqstats.stat[DQST_SYNCS],
Linus Torvalds1da177e2005-04-16 15:20:36 -07002702 .maxlen = sizeof(int),
2703 .mode = 0444,
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002704 .proc_handler = do_proc_dqstats,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002705 },
Jan Kara8e893462007-10-16 23:29:31 -07002706#ifdef CONFIG_PRINT_QUOTA_WARNING
Linus Torvalds1da177e2005-04-16 15:20:36 -07002707 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002708 .procname = "warnings",
2709 .data = &flag_print_warnings,
2710 .maxlen = sizeof(int),
2711 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -08002712 .proc_handler = proc_dointvec,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 },
Jan Kara8e893462007-10-16 23:29:31 -07002714#endif
Eric W. Biedermanab092032009-11-05 14:25:10 -08002715 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716};
2717
Joe Perchese6287532013-06-13 19:37:49 -07002718static struct ctl_table fs_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002719 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002720 .procname = "quota",
2721 .mode = 0555,
2722 .child = fs_dqstats_table,
2723 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002724 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002725};
2726
Joe Perchese6287532013-06-13 19:37:49 -07002727static struct ctl_table sys_table[] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002728 {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002729 .procname = "fs",
2730 .mode = 0555,
2731 .child = fs_table,
2732 },
Eric W. Biedermanab092032009-11-05 14:25:10 -08002733 { },
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734};
2735
2736static int __init dquot_init(void)
2737{
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002738 int i, ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002739 unsigned long nr_hash, order;
2740
2741 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2742
Eric W. Biederman0b4d4142007-02-14 00:34:09 -08002743 register_sysctl_table(sys_table);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002744
Paul Mundt20c2df82007-07-20 10:11:58 +09002745 dquot_cachep = kmem_cache_create("dquot",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002746 sizeof(struct dquot), sizeof(unsigned long) * 4,
Paul Jacksonfffb60f2006-03-24 03:16:06 -08002747 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2748 SLAB_MEM_SPREAD|SLAB_PANIC),
Paul Mundt20c2df82007-07-20 10:11:58 +09002749 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002750
2751 order = 0;
2752 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2753 if (!dquot_hash)
2754 panic("Cannot create dquot hash table");
2755
Dmitry Monakhovf32764b2010-05-26 23:21:58 +02002756 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2757 ret = percpu_counter_init(&dqstats.counter[i], 0);
2758 if (ret)
2759 panic("Cannot create dquot stat counters");
2760 }
Dmitry Monakhovdde95882010-04-26 20:03:33 +04002761
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 /* Find power-of-two hlist_heads which can fit into allocation */
2763 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2764 dq_hash_bits = 0;
2765 do {
2766 dq_hash_bits++;
2767 } while (nr_hash >> dq_hash_bits);
2768 dq_hash_bits--;
2769
2770 nr_hash = 1UL << dq_hash_bits;
2771 dq_hash_mask = nr_hash - 1;
2772 for (i = 0; i < nr_hash; i++)
2773 INIT_HLIST_HEAD(dquot_hash + i);
2774
2775 printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
2776 nr_hash, order, (PAGE_SIZE << order));
2777
Rusty Russell8e1f9362007-07-17 04:03:17 -07002778 register_shrinker(&dqcache_shrinker);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002779
Linus Torvalds1da177e2005-04-16 15:20:36 -07002780 return 0;
2781}
2782module_init(dquot_init);