projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
wrappers for ->i_mutex access
[deliverable/linux.git] / fs / quota / dquot.c
CommitLineData
1da177e4
LT		 1/*
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 *
1da177e4
LT		 12 * 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>
1da177e4
LT		 70#include <linux/init.h>
71#include <linux/module.h>
72#include <linux/proc_fs.h>
73#include <linux/security.h>
40401530 74#include <linux/sched.h>
1da177e4
LT		 75#include <linux/kmod.h>
76#include <linux/namei.h>
16f7e0fe 77#include <linux/capability.h>
be586bab 78#include <linux/quotaops.h>
55fa6091 79#include "../internal.h" /* ugh */
1da177e4 80
f3da9310 81#include <linux/uaccess.h>
1da177e4 82
1da177e4 83/*
cc33412f 84 * There are three quota SMP locks. dq_list_lock protects all lists with quotas
dde95888 85 * and quota formats.
cc33412f
JK		 86 * 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.
1da177e4 88 * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly
cc33412f
JK		 89 * 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.
1da177e4 92 *
cc33412f
JK		 93 * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock,
94 * dq_list_lock > dq_state_lock
1da177e4
LT		 95 *
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 *
b9ba6f94
NY		 99 * Operation accessing dquots via inode pointers are protected by dquot_srcu.
100 * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and
101 * synchronize_srcu(&dquot_srcu) is called after clearing pointers from
102 * inode and before dropping dquot references to avoid use of dquots after
103 * they are freed. dq_data_lock is used to serialize the pointer setting and
104 * clearing operations.
26245c94
JK		 105 * Special care needs to be taken about S_NOQUOTA inode flag (marking that
106 * inode is a quota file). Functions adding pointers from inode to dquots have
b9ba6f94
NY		 107 * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they
108 * have to do all pointer modifications before dropping dq_data_lock. This makes
26245c94
JK		 109 * sure they cannot race with quotaon which first sets S_NOQUOTA flag and
110 * then drops all pointers to dquots from an inode.
1da177e4 111 *
d3be915f 112 * Each dquot has its dq_lock mutex. Locked dquots might not be referenced
1da177e4
LT		 113 * from inodes (dquot_alloc_space() and such don't check the dq_lock).
114 * Currently dquot is locked only when it is being read to memory (or space for
115 * it is being allocated) on the first dqget() and when it is being released on
116 * the last dqput(). The allocation and release oparations are serialized by
117 * the dq_lock and by checking the use count in dquot_release(). Write
118 * operations on dquots don't hold dq_lock as they copy data under dq_data_lock
119 * spinlock to internal buffers before writing.
120 *
121 * Lock ordering (including related VFS locks) is the following:
b9ba6f94 122 * dqonoff_mutex > i_mutex > journal_lock > dquot->dq_lock > dqio_mutex
a80b12c3 123 * dqonoff_mutex > i_mutex comes from dquot_quota_sync, dquot_enable, etc.
1da177e4
LT		 124 */
125
c516610c
JK		 126static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock);
127static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
128__cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
08d0350c 129EXPORT_SYMBOL(dq_data_lock);
b9ba6f94 130DEFINE_STATIC_SRCU(dquot_srcu);
1da177e4 131
fb5ffb0e 132void __quota_error(struct super_block *sb, const char *func,
055adcbd 133 const char *fmt, ...)
fb5ffb0e 134{
fb5ffb0e 135 if (printk_ratelimit()) {
055adcbd
JP		 136 va_list args;
137 struct va_format vaf;
138
fb5ffb0e 139 va_start(args, fmt);
055adcbd
JP		 140
141 vaf.fmt = fmt;
142 vaf.va = &args;
143
144 printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
145 sb->s_id, func, &vaf);
146
fb5ffb0e
JZ		 147 va_end(args);
148 }
149}
150EXPORT_SYMBOL(__quota_error);
151
da8d1ba2 152#if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
1da177e4 153static char *quotatypes[] = INITQFNAMES;
da8d1ba2 154#endif
1da177e4
LT		 155static struct quota_format_type *quota_formats; /* List of registered formats */
156static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;
157
158/* SLAB cache for dquot structures */
e18b890b 159static struct kmem_cache *dquot_cachep;
1da177e4
LT		 160
161int register_quota_format(struct quota_format_type *fmt)
162{
163 spin_lock(&dq_list_lock);
164 fmt->qf_next = quota_formats;
165 quota_formats = fmt;
166 spin_unlock(&dq_list_lock);
167 return 0;
168}
08d0350c 169EXPORT_SYMBOL(register_quota_format);
1da177e4
LT		 170
171void unregister_quota_format(struct quota_format_type *fmt)
172{
173 struct quota_format_type **actqf;
174
175 spin_lock(&dq_list_lock);
268157ba
JK		 176 for (actqf = &quota_formats; *actqf && *actqf != fmt;
177 actqf = &(*actqf)->qf_next)
178 ;
1da177e4
LT		 179 if (*actqf)
180 *actqf = (*actqf)->qf_next;
181 spin_unlock(&dq_list_lock);
182}
08d0350c 183EXPORT_SYMBOL(unregister_quota_format);
1da177e4
LT		 184
185static struct quota_format_type *find_quota_format(int id)
186{
187 struct quota_format_type *actqf;
188
189 spin_lock(&dq_list_lock);
268157ba
JK		 190 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
191 actqf = actqf->qf_next)
192 ;
1da177e4
LT		 193 if (!actqf || !try_module_get(actqf->qf_owner)) {
194 int qm;
195
196 spin_unlock(&dq_list_lock);
197
268157ba
JK		 198 for (qm = 0; module_names[qm].qm_fmt_id &&
199 module_names[qm].qm_fmt_id != id; qm++)
200 ;
201 if (!module_names[qm].qm_fmt_id ||
202 request_module(module_names[qm].qm_mod_name))
1da177e4
LT		 203 return NULL;
204
205 spin_lock(&dq_list_lock);
268157ba
JK		 206 for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
207 actqf = actqf->qf_next)
208 ;
1da177e4
LT		 209 if (actqf && !try_module_get(actqf->qf_owner))
210 actqf = NULL;
211 }
212 spin_unlock(&dq_list_lock);
213 return actqf;
214}
215
216static void put_quota_format(struct quota_format_type *fmt)
217{
218 module_put(fmt->qf_owner);
219}
220
221/*
222 * Dquot List Management:
223 * The quota code uses three lists for dquot management: the inuse_list,
224 * free_dquots, and dquot_hash[] array. A single dquot structure may be
225 * on all three lists, depending on its current state.
226 *
227 * All dquots are placed to the end of inuse_list when first created, and this
228 * list is used for invalidate operation, which must look at every dquot.
229 *
230 * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
231 * and this list is searched whenever we need an available dquot. Dquots are
232 * removed from the list as soon as they are used again, and
233 * dqstats.free_dquots gives the number of dquots on the list. When
234 * dquot is invalidated it's completely released from memory.
235 *
236 * Dquots with a specific identity (device, type and id) are placed on
237 * one of the dquot_hash[] hash chains. The provides an efficient search
238 * mechanism to locate a specific dquot.
239 */
240
241static LIST_HEAD(inuse_list);
242static LIST_HEAD(free_dquots);
243static unsigned int dq_hash_bits, dq_hash_mask;
244static struct hlist_head *dquot_hash;
245
246struct dqstats dqstats;
08d0350c 247EXPORT_SYMBOL(dqstats);
1da177e4 248
0a5a9c72 249static qsize_t inode_get_rsv_space(struct inode *inode);
6184fc0b 250static int __dquot_initialize(struct inode *inode, int type);
0a5a9c72 251
1da177e4 252static inline unsigned int
1a06d420 253hashfn(const struct super_block *sb, struct kqid qid)
1da177e4 254{
1a06d420
EB		 255 unsigned int id = from_kqid(&init_user_ns, qid);
256 int type = qid.type;
1da177e4
LT		 257 unsigned long tmp;
258
259 tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
260 return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
261}
262
263/*
264 * Following list functions expect dq_list_lock to be held
265 */
266static inline void insert_dquot_hash(struct dquot *dquot)
267{
268157ba 268 struct hlist_head *head;
1a06d420 269 head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id);
1da177e4
LT		 270 hlist_add_head(&dquot->dq_hash, head);
271}
272
273static inline void remove_dquot_hash(struct dquot *dquot)
274{
275 hlist_del_init(&dquot->dq_hash);
276}
277
7a2435d8 278static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
1a06d420 279 struct kqid qid)
1da177e4
LT		 280{
281 struct hlist_node *node;
282 struct dquot *dquot;
283
284 hlist_for_each (node, dquot_hash+hashent) {
285 dquot = hlist_entry(node, struct dquot, dq_hash);
4c376dca 286 if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid))
1da177e4
LT		 287 return dquot;
288 }
dd6f3c6d 289 return NULL;
1da177e4
LT		 290}
291
292/* Add a dquot to the tail of the free list */
293static inline void put_dquot_last(struct dquot *dquot)
294{
8e13059a 295 list_add_tail(&dquot->dq_free, &free_dquots);
dde95888 296 dqstats_inc(DQST_FREE_DQUOTS);
1da177e4
LT		 297}
298
299static inline void remove_free_dquot(struct dquot *dquot)
300{
301 if (list_empty(&dquot->dq_free))
302 return;
303 list_del_init(&dquot->dq_free);
dde95888 304 dqstats_dec(DQST_FREE_DQUOTS);
1da177e4
LT		 305}
306
307static inline void put_inuse(struct dquot *dquot)
308{
309 /* We add to the back of inuse list so we don't have to restart
310 * when traversing this list and we block */
8e13059a 311 list_add_tail(&dquot->dq_inuse, &inuse_list);
dde95888 312 dqstats_inc(DQST_ALLOC_DQUOTS);
1da177e4
LT		 313}
314
315static inline void remove_inuse(struct dquot *dquot)
316{
dde95888 317 dqstats_dec(DQST_ALLOC_DQUOTS);
1da177e4
LT		 318 list_del(&dquot->dq_inuse);
319}
320/*
321 * End of list functions needing dq_list_lock
322 */
323
324static void wait_on_dquot(struct dquot *dquot)
325{
d3be915f
IM		 326 mutex_lock(&dquot->dq_lock);
327 mutex_unlock(&dquot->dq_lock);
1da177e4
LT		 328}
329
03f6e92b
JK		 330static inline int dquot_dirty(struct dquot *dquot)
331{
332 return test_bit(DQ_MOD_B, &dquot->dq_flags);
333}
334
335static inline int mark_dquot_dirty(struct dquot *dquot)
336{
337 return dquot->dq_sb->dq_op->mark_dirty(dquot);
338}
1da177e4 339
eabf290d 340/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
1da177e4
LT		 341int dquot_mark_dquot_dirty(struct dquot *dquot)
342{
eabf290d
DM		 343 int ret = 1;
344
345 /* If quota is dirty already, we don't have to acquire dq_list_lock */
346 if (test_bit(DQ_MOD_B, &dquot->dq_flags))
347 return 1;
348
1da177e4 349 spin_lock(&dq_list_lock);
eabf290d 350 if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
1da177e4 351 list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
4c376dca 352 info[dquot->dq_id.type].dqi_dirty_list);
eabf290d
DM		 353 ret = 0;
354 }
1da177e4 355 spin_unlock(&dq_list_lock);
eabf290d 356 return ret;
1da177e4 357}
08d0350c 358EXPORT_SYMBOL(dquot_mark_dquot_dirty);
1da177e4 359
dc52dd3a
DM		 360/* Dirtify all the dquots - this can block when journalling */
361static inline int mark_all_dquot_dirty(struct dquot * const *dquot)
362{
363 int ret, err, cnt;
364
365 ret = err = 0;
366 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
367 if (dquot[cnt])
368 /* Even in case of error we have to continue */
369 ret = mark_dquot_dirty(dquot[cnt]);
370 if (!err)
371 err = ret;
372 }
373 return err;
374}
375
376static inline void dqput_all(struct dquot **dquot)
377{
378 unsigned int cnt;
379
380 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
381 dqput(dquot[cnt]);
382}
383
1da177e4
LT		 384/* This function needs dq_list_lock */
385static inline int clear_dquot_dirty(struct dquot *dquot)
386{
387 if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags))
388 return 0;
389 list_del_init(&dquot->dq_dirty);
390 return 1;
391}
392
393void mark_info_dirty(struct super_block *sb, int type)
394{
395 set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags);
396}
397EXPORT_SYMBOL(mark_info_dirty);
398
399/*
400 * Read dquot from disk and alloc space for it
401 */
402
403int dquot_acquire(struct dquot *dquot)
404{
405 int ret = 0, ret2 = 0;
406 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
407
d3be915f
IM		 408 mutex_lock(&dquot->dq_lock);
409 mutex_lock(&dqopt->dqio_mutex);
1da177e4 410 if (!test_bit(DQ_READ_B, &dquot->dq_flags))
4c376dca 411 ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot);
1da177e4
LT		 412 if (ret < 0)
413 goto out_iolock;
414 set_bit(DQ_READ_B, &dquot->dq_flags);
415 /* Instantiate dquot if needed */
416 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
4c376dca 417 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
1da177e4 418 /* Write the info if needed */
4c376dca
EB		 419 if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
420 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
421 dquot->dq_sb, dquot->dq_id.type);
268157ba 422 }
1da177e4
LT		 423 if (ret < 0)
424 goto out_iolock;
425 if (ret2 < 0) {
426 ret = ret2;
427 goto out_iolock;
428 }
429 }
430 set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
431out_iolock:
d3be915f
IM		 432 mutex_unlock(&dqopt->dqio_mutex);
433 mutex_unlock(&dquot->dq_lock);
1da177e4
LT		 434 return ret;
435}
08d0350c 436EXPORT_SYMBOL(dquot_acquire);
1da177e4
LT		 437
438/*
439 * Write dquot to disk
440 */
441int dquot_commit(struct dquot *dquot)
442{
b03f2456 443 int ret = 0;
1da177e4
LT		 444 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
445
d3be915f 446 mutex_lock(&dqopt->dqio_mutex);
1da177e4
LT		 447 spin_lock(&dq_list_lock);
448 if (!clear_dquot_dirty(dquot)) {
449 spin_unlock(&dq_list_lock);
450 goto out_sem;
451 }
452 spin_unlock(&dq_list_lock);
453 /* Inactive dquot can be only if there was error during read/init
454 * => we have better not writing it */
b03f2456 455 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
4c376dca 456 ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
b03f2456
JK		 457 else
458 ret = -EIO;
1da177e4 459out_sem:
d3be915f 460 mutex_unlock(&dqopt->dqio_mutex);
1da177e4
LT		 461 return ret;
462}
08d0350c 463EXPORT_SYMBOL(dquot_commit);
1da177e4
LT		 464
465/*
466 * Release dquot
467 */
468int dquot_release(struct dquot *dquot)
469{
470 int ret = 0, ret2 = 0;
471 struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);
472
d3be915f 473 mutex_lock(&dquot->dq_lock);
1da177e4
LT		 474 /* Check whether we are not racing with some other dqget() */
475 if (atomic_read(&dquot->dq_count) > 1)
476 goto out_dqlock;
d3be915f 477 mutex_lock(&dqopt->dqio_mutex);
4c376dca
EB		 478 if (dqopt->ops[dquot->dq_id.type]->release_dqblk) {
479 ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot);
1da177e4 480 /* Write the info */
4c376dca
EB		 481 if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
482 ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
483 dquot->dq_sb, dquot->dq_id.type);
268157ba 484 }
1da177e4
LT		 485 if (ret >= 0)
486 ret = ret2;
487 }
488 clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
d3be915f 489 mutex_unlock(&dqopt->dqio_mutex);
1da177e4 490out_dqlock:
d3be915f 491 mutex_unlock(&dquot->dq_lock);
1da177e4
LT		 492 return ret;
493}
08d0350c 494EXPORT_SYMBOL(dquot_release);
1da177e4 495
7d9056ba 496void dquot_destroy(struct dquot *dquot)
74f783af
JK		 497{
498 kmem_cache_free(dquot_cachep, dquot);
499}
7d9056ba 500EXPORT_SYMBOL(dquot_destroy);
74f783af
JK		 501
502static inline void do_destroy_dquot(struct dquot *dquot)
503{
504 dquot->dq_sb->dq_op->destroy_dquot(dquot);
505}
506
1da177e4
LT		 507/* Invalidate all dquots on the list. Note that this function is called after
508 * quota is disabled and pointers from inodes removed so there cannot be new
6362e4d4
JK		 509 * quota users. There can still be some users of quotas due to inodes being
510 * just deleted or pruned by prune_icache() (those are not attached to any
cc33412f 511 * list) or parallel quotactl call. We have to wait for such users.
6362e4d4 512 */
1da177e4
LT		 513static void invalidate_dquots(struct super_block *sb, int type)
514{
c33ed271 515 struct dquot *dquot, *tmp;
1da177e4 516
6362e4d4 517restart:
1da177e4 518 spin_lock(&dq_list_lock);
c33ed271 519 list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
1da177e4
LT		 520 if (dquot->dq_sb != sb)
521 continue;
4c376dca 522 if (dquot->dq_id.type != type)
1da177e4 523 continue;
6362e4d4
JK		 524 /* Wait for dquot users */
525 if (atomic_read(&dquot->dq_count)) {
526 DEFINE_WAIT(wait);
527
9f985cb6 528 dqgrab(dquot);
6362e4d4
JK		 529 prepare_to_wait(&dquot->dq_wait_unused, &wait,
530 TASK_UNINTERRUPTIBLE);
531 spin_unlock(&dq_list_lock);
532 /* Once dqput() wakes us up, we know it's time to free
533 * the dquot.
534 * IMPORTANT: we rely on the fact that there is always
535 * at most one process waiting for dquot to free.
536 * Otherwise dq_count would be > 1 and we would never
537 * wake up.
538 */
539 if (atomic_read(&dquot->dq_count) > 1)
540 schedule();
541 finish_wait(&dquot->dq_wait_unused, &wait);
542 dqput(dquot);
543 /* At this moment dquot() need not exist (it could be
544 * reclaimed by prune_dqcache(). Hence we must
545 * restart. */
546 goto restart;
547 }
548 /*
549 * Quota now has no users and it has been written on last
550 * dqput()
551 */
1da177e4
LT		 552 remove_dquot_hash(dquot);
553 remove_free_dquot(dquot);
554 remove_inuse(dquot);
74f783af 555 do_destroy_dquot(dquot);
1da177e4
LT		 556 }
557 spin_unlock(&dq_list_lock);
558}
559
12c77527
JK		 560/* Call callback for every active dquot on given filesystem */
561int dquot_scan_active(struct super_block *sb,
562 int (*fn)(struct dquot *dquot, unsigned long priv),
563 unsigned long priv)
564{
565 struct dquot *dquot, *old_dquot = NULL;
566 int ret = 0;
567
568 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
569 spin_lock(&dq_list_lock);
570 list_for_each_entry(dquot, &inuse_list, dq_inuse) {
571 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
572 continue;
573 if (dquot->dq_sb != sb)
574 continue;
575 /* Now we have active dquot so we can just increase use count */
576 atomic_inc(&dquot->dq_count);
12c77527 577 spin_unlock(&dq_list_lock);
dde95888 578 dqstats_inc(DQST_LOOKUPS);
12c77527
JK		 579 dqput(old_dquot);
580 old_dquot = dquot;
1362f4ea
JK		 581 /*
582 * ->release_dquot() can be racing with us. Our reference
583 * protects us from new calls to it so just wait for any
584 * outstanding call and recheck the DQ_ACTIVE_B after that.
585 */
586 wait_on_dquot(dquot);
587 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
588 ret = fn(dquot, priv);
589 if (ret < 0)
590 goto out;
591 }
12c77527
JK		 592 spin_lock(&dq_list_lock);
593 /* We are safe to continue now because our dquot could not
594 * be moved out of the inuse list while we hold the reference */
595 }
596 spin_unlock(&dq_list_lock);
597out:
598 dqput(old_dquot);
599 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
600 return ret;
601}
08d0350c 602EXPORT_SYMBOL(dquot_scan_active);
12c77527 603
ceed1723
JK		 604/* Write all dquot structures to quota files */
605int dquot_writeback_dquots(struct super_block *sb, int type)
1da177e4
LT		 606{
607 struct list_head *dirty;
608 struct dquot *dquot;
609 struct quota_info *dqopt = sb_dqopt(sb);
610 int cnt;
ceed1723 611 int err, ret = 0;
1da177e4 612
d3be915f 613 mutex_lock(&dqopt->dqonoff_mutex);
1da177e4
LT		 614 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
615 if (type != -1 && cnt != type)
616 continue;
f55abc0f 617 if (!sb_has_quota_active(sb, cnt))
1da177e4
LT		 618 continue;
619 spin_lock(&dq_list_lock);
620 dirty = &dqopt->info[cnt].dqi_dirty_list;
621 while (!list_empty(dirty)) {
268157ba
JK		 622 dquot = list_first_entry(dirty, struct dquot,
623 dq_dirty);
1da177e4
LT		 624 /* Dirty and inactive can be only bad dquot... */
625 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
626 clear_dquot_dirty(dquot);
627 continue;
628 }
629 /* Now we have active dquot from which someone is
630 * holding reference so we can safely just increase
631 * use count */
9f985cb6 632 dqgrab(dquot);
1da177e4 633 spin_unlock(&dq_list_lock);
dde95888 634 dqstats_inc(DQST_LOOKUPS);
ceed1723
JK		 635 err = sb->dq_op->write_dquot(dquot);
636 if (!ret && err)
474d2605 637 ret = err;
1da177e4
LT		 638 dqput(dquot);
639 spin_lock(&dq_list_lock);
640 }
641 spin_unlock(&dq_list_lock);
642 }
643
644 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
f55abc0f
JK		 645 if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
646 && info_dirty(&dqopt->info[cnt]))
1da177e4 647 sb->dq_op->write_info(sb, cnt);
dde95888 648 dqstats_inc(DQST_SYNCS);
d3be915f 649 mutex_unlock(&dqopt->dqonoff_mutex);
1da177e4 650
ceed1723
JK		 651 return ret;
652}
653EXPORT_SYMBOL(dquot_writeback_dquots);
654
655/* Write all dquot structures to disk and make them visible from userspace */
656int dquot_quota_sync(struct super_block *sb, int type)
657{
658 struct quota_info *dqopt = sb_dqopt(sb);
659 int cnt;
660 int ret;
661
662 ret = dquot_writeback_dquots(sb, type);
663 if (ret)
664 return ret;
665 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
5fb324ad
CH		 666 return 0;
667
668 /* This is not very clever (and fast) but currently I don't know about
669 * any other simple way of getting quota data to disk and we must get
670 * them there for userspace to be visible... */
671 if (sb->s_op->sync_fs)
672 sb->s_op->sync_fs(sb, 1);
673 sync_blockdev(sb->s_bdev);
674
675 /*
676 * Now when everything is written we can discard the pagecache so
677 * that userspace sees the changes.
678 */
f9ef1784 679 mutex_lock(&dqopt->dqonoff_mutex);
5fb324ad
CH		 680 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
681 if (type != -1 && cnt != type)
682 continue;
683 if (!sb_has_quota_active(sb, cnt))
684 continue;
5955102c 685 inode_lock(dqopt->files[cnt]);
f9ef1784 686 truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
5955102c 687 inode_unlock(dqopt->files[cnt]);
5fb324ad 688 }
f9ef1784 689 mutex_unlock(&dqopt->dqonoff_mutex);
5fb324ad 690
1da177e4
LT		 691 return 0;
692}
287a8095 693EXPORT_SYMBOL(dquot_quota_sync);
1da177e4 694
1ab6c499
DC		 695static unsigned long
696dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
1da177e4
LT		 697{
698 struct list_head *head;
699 struct dquot *dquot;
1ab6c499 700 unsigned long freed = 0;
1da177e4 701
d68aab6b 702 spin_lock(&dq_list_lock);
1da177e4 703 head = free_dquots.prev;
1ab6c499 704 while (head != &free_dquots && sc->nr_to_scan) {
1da177e4
LT		 705 dquot = list_entry(head, struct dquot, dq_free);
706 remove_dquot_hash(dquot);
707 remove_free_dquot(dquot);
708 remove_inuse(dquot);
74f783af 709 do_destroy_dquot(dquot);
1ab6c499
DC		 710 sc->nr_to_scan--;
711 freed++;
1da177e4
LT		 712 head = free_dquots.prev;
713 }
d68aab6b 714 spin_unlock(&dq_list_lock);
1ab6c499 715 return freed;
1da177e4
LT		 716}
717
1ab6c499
DC		 718static unsigned long
719dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
1da177e4 720{
55f841ce
GC		 721 return vfs_pressure_ratio(
722 percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]));
1da177e4
LT		 723}
724
8e1f936b 725static struct shrinker dqcache_shrinker = {
1ab6c499
DC		 726 .count_objects = dqcache_shrink_count,
727 .scan_objects = dqcache_shrink_scan,
8e1f936b
RR		 728 .seeks = DEFAULT_SEEKS,
729};
730
1da177e4
LT		 731/*
732 * Put reference to dquot
1da177e4 733 */
3d9ea253 734void dqput(struct dquot *dquot)
1da177e4 735{
b48d3805
JK		 736 int ret;
737
1da177e4
LT		 738 if (!dquot)
739 return;
62af9b52 740#ifdef CONFIG_QUOTA_DEBUG
1da177e4 741 if (!atomic_read(&dquot->dq_count)) {
fb5ffb0e 742 quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
4c376dca
EB		 743 quotatypes[dquot->dq_id.type],
744 from_kqid(&init_user_ns, dquot->dq_id));
1da177e4
LT		 745 BUG();
746 }
747#endif
dde95888 748 dqstats_inc(DQST_DROPS);
1da177e4
LT		 749we_slept:
750 spin_lock(&dq_list_lock);
751 if (atomic_read(&dquot->dq_count) > 1) {
752 /* We have more than one user... nothing to do */
753 atomic_dec(&dquot->dq_count);
6362e4d4 754 /* Releasing dquot during quotaoff phase? */
4c376dca 755 if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) &&
6362e4d4
JK		 756 atomic_read(&dquot->dq_count) == 1)
757 wake_up(&dquot->dq_wait_unused);
1da177e4
LT		 758 spin_unlock(&dq_list_lock);
759 return;
760 }
761 /* Need to release dquot? */
762 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
763 spin_unlock(&dq_list_lock);
764 /* Commit dquot before releasing */
b48d3805
JK		 765 ret = dquot->dq_sb->dq_op->write_dquot(dquot);
766 if (ret < 0) {
fb5ffb0e
JZ		 767 quota_error(dquot->dq_sb, "Can't write quota structure"
768 " (error %d). Quota may get out of sync!",
769 ret);
b48d3805
JK		 770 /*
771 * We clear dirty bit anyway, so that we avoid
772 * infinite loop here
773 */
774 spin_lock(&dq_list_lock);
775 clear_dquot_dirty(dquot);
776 spin_unlock(&dq_list_lock);
777 }
1da177e4
LT		 778 goto we_slept;
779 }
780 /* Clear flag in case dquot was inactive (something bad happened) */
781 clear_dquot_dirty(dquot);
782 if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
783 spin_unlock(&dq_list_lock);
784 dquot->dq_sb->dq_op->release_dquot(dquot);
785 goto we_slept;
786 }
787 atomic_dec(&dquot->dq_count);
62af9b52 788#ifdef CONFIG_QUOTA_DEBUG
1da177e4 789 /* sanity check */
8abf6a47 790 BUG_ON(!list_empty(&dquot->dq_free));
1da177e4
LT		 791#endif
792 put_dquot_last(dquot);
793 spin_unlock(&dq_list_lock);
794}
08d0350c 795EXPORT_SYMBOL(dqput);
1da177e4 796
7d9056ba 797struct dquot *dquot_alloc(struct super_block *sb, int type)
74f783af
JK		 798{
799 return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
800}
7d9056ba 801EXPORT_SYMBOL(dquot_alloc);
74f783af 802
1da177e4
LT		 803static struct dquot *get_empty_dquot(struct super_block *sb, int type)
804{
805 struct dquot *dquot;
806
74f783af 807 dquot = sb->dq_op->alloc_dquot(sb, type);
1da177e4 808 if(!dquot)
dd6f3c6d 809 return NULL;
1da177e4 810
d3be915f 811 mutex_init(&dquot->dq_lock);
1da177e4
LT		 812 INIT_LIST_HEAD(&dquot->dq_free);
813 INIT_LIST_HEAD(&dquot->dq_inuse);
814 INIT_HLIST_NODE(&dquot->dq_hash);
815 INIT_LIST_HEAD(&dquot->dq_dirty);
6362e4d4 816 init_waitqueue_head(&dquot->dq_wait_unused);
1da177e4 817 dquot->dq_sb = sb;
1a06d420 818 dquot->dq_id = make_kqid_invalid(type);
1da177e4
LT		 819 atomic_set(&dquot->dq_count, 1);
820
821 return dquot;
822}
823
824/*
825 * Get reference to dquot
cc33412f
JK		 826 *
827 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
828 * destroying our dquot by:
829 * a) checking for quota flags under dq_list_lock and
830 * b) getting a reference to dquot before we release dq_list_lock
1da177e4 831 */
aca645a6 832struct dquot *dqget(struct super_block *sb, struct kqid qid)
1da177e4 833{
1a06d420 834 unsigned int hashent = hashfn(sb, qid);
6184fc0b 835 struct dquot *dquot, *empty = NULL;
1da177e4 836
1a06d420 837 if (!sb_has_quota_active(sb, qid.type))
6184fc0b 838 return ERR_PTR(-ESRCH);
1da177e4
LT		 839we_slept:
840 spin_lock(&dq_list_lock);
cc33412f 841 spin_lock(&dq_state_lock);
1a06d420 842 if (!sb_has_quota_active(sb, qid.type)) {
cc33412f
JK		 843 spin_unlock(&dq_state_lock);
844 spin_unlock(&dq_list_lock);
6184fc0b 845 dquot = ERR_PTR(-ESRCH);
cc33412f
JK		 846 goto out;
847 }
848 spin_unlock(&dq_state_lock);
849
1a06d420 850 dquot = find_dquot(hashent, sb, qid);
dd6f3c6d
JK		 851 if (!dquot) {
852 if (!empty) {
1da177e4 853 spin_unlock(&dq_list_lock);
1a06d420 854 empty = get_empty_dquot(sb, qid.type);
dd6f3c6d 855 if (!empty)
1da177e4
LT		 856 schedule(); /* Try to wait for a moment... */
857 goto we_slept;
858 }
859 dquot = empty;
dd6f3c6d 860 empty = NULL;
4c376dca 861 dquot->dq_id = qid;
1da177e4
LT		 862 /* all dquots go on the inuse_list */
863 put_inuse(dquot);
864 /* hash it first so it can be found */
865 insert_dquot_hash(dquot);
1da177e4 866 spin_unlock(&dq_list_lock);
dde95888 867 dqstats_inc(DQST_LOOKUPS);
1da177e4
LT		 868 } else {
869 if (!atomic_read(&dquot->dq_count))
870 remove_free_dquot(dquot);
871 atomic_inc(&dquot->dq_count);
1da177e4 872 spin_unlock(&dq_list_lock);
dde95888
DM		 873 dqstats_inc(DQST_CACHE_HITS);
874 dqstats_inc(DQST_LOOKUPS);
1da177e4 875 }
268157ba
JK		 876 /* Wait for dq_lock - after this we know that either dquot_release() is
877 * already finished or it will be canceled due to dq_count > 1 test */
1da177e4 878 wait_on_dquot(dquot);
268157ba 879 /* Read the dquot / allocate space in quota file */
6184fc0b
JK		 880 if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
881 int err;
882
883 err = sb->dq_op->acquire_dquot(dquot);
884 if (err < 0) {
885 dqput(dquot);
886 dquot = ERR_PTR(err);
887 goto out;
888 }
1da177e4 889 }
62af9b52 890#ifdef CONFIG_QUOTA_DEBUG
8abf6a47 891 BUG_ON(!dquot->dq_sb); /* Has somebody invalidated entry under us? */
1da177e4 892#endif
cc33412f
JK		 893out:
894 if (empty)
895 do_destroy_dquot(empty);
1da177e4
LT		 896
897 return dquot;
898}
08d0350c 899EXPORT_SYMBOL(dqget);
1da177e4 900
2d0fa467
JK		 901static inline struct dquot **i_dquot(struct inode *inode)
902{
2d0fa467
JK		 903 return inode->i_sb->s_op->get_dquots(inode);
904}
905
1da177e4
LT		 906static int dqinit_needed(struct inode *inode, int type)
907{
5bcd3b6f 908 struct dquot * const *dquots;
1da177e4
LT		 909 int cnt;
910
911 if (IS_NOQUOTA(inode))
912 return 0;
5bcd3b6f
KK		 913
914 dquots = i_dquot(inode);
1da177e4 915 if (type != -1)
5bcd3b6f 916 return !dquots[type];
1da177e4 917 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
5bcd3b6f 918 if (!dquots[cnt])
1da177e4
LT		 919 return 1;
920 return 0;
921}
922
d3be915f 923/* This routine is guarded by dqonoff_mutex mutex */
1da177e4
LT		 924static void add_dquot_ref(struct super_block *sb, int type)
925{
941d2380 926 struct inode *inode, *old_inode = NULL;
62af9b52 927#ifdef CONFIG_QUOTA_DEBUG
0a5a9c72 928 int reserved = 0;
4c5e6c0e 929#endif
1da177e4 930
74278da9 931 spin_lock(&sb->s_inode_list_lock);
d003fb70 932 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
250df6ed
DC		 933 spin_lock(&inode->i_lock);
934 if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
935 !atomic_read(&inode->i_writecount) ||
936 !dqinit_needed(inode, type)) {
937 spin_unlock(&inode->i_lock);
aabb8fdb 938 continue;
250df6ed 939 }
d003fb70 940 __iget(inode);
250df6ed 941 spin_unlock(&inode->i_lock);
74278da9 942 spin_unlock(&sb->s_inode_list_lock);
d003fb70 943
d7e97117
JK		 944#ifdef CONFIG_QUOTA_DEBUG
945 if (unlikely(inode_get_rsv_space(inode) > 0))
946 reserved = 1;
947#endif
941d2380 948 iput(old_inode);
871a2931 949 __dquot_initialize(inode, type);
55fa6091
DC		 950
951 /*
952 * We hold a reference to 'inode' so it couldn't have been
953 * removed from s_inodes list while we dropped the
74278da9 954 * s_inode_list_lock. We cannot iput the inode now as we can be
55fa6091 955 * holding the last reference and we cannot iput it under
74278da9 956 * s_inode_list_lock. So we keep the reference and iput it
55fa6091
DC		 957 * later.
958 */
941d2380 959 old_inode = inode;
74278da9 960 spin_lock(&sb->s_inode_list_lock);
1da177e4 961 }
74278da9 962 spin_unlock(&sb->s_inode_list_lock);
941d2380 963 iput(old_inode);
0a5a9c72 964
62af9b52 965#ifdef CONFIG_QUOTA_DEBUG
0a5a9c72 966 if (reserved) {
fb5ffb0e
JZ		 967 quota_error(sb, "Writes happened before quota was turned on "
968 "thus quota information is probably inconsistent. "
969 "Please run quotacheck(8)");
0a5a9c72 970 }
4c5e6c0e 971#endif
1da177e4
LT		 972}
973
268157ba
JK		 974/*
975 * Remove references to dquots from inode and add dquot to list for freeing
25985edc 976 * if we have the last reference to dquot
268157ba 977 */
9eb6463f
NY		 978static void remove_inode_dquot_ref(struct inode *inode, int type,
979 struct list_head *tofree_head)
1da177e4 980{
5bcd3b6f
KK		 981 struct dquot **dquots = i_dquot(inode);
982 struct dquot *dquot = dquots[type];
1da177e4 983
9eb6463f
NY		 984 if (!dquot)
985 return;
986
5bcd3b6f 987 dquots[type] = NULL;
9eb6463f
NY		 988 if (list_empty(&dquot->dq_free)) {
989 /*
990 * The inode still has reference to dquot so it can't be in the
991 * free list
992 */
993 spin_lock(&dq_list_lock);
994 list_add(&dquot->dq_free, tofree_head);
995 spin_unlock(&dq_list_lock);
996 } else {
997 /*
998 * Dquot is already in a list to put so we won't drop the last
999 * reference here.
1000 */
1001 dqput(dquot);
1da177e4 1002 }
1da177e4
LT		 1003}
1004
268157ba
JK		 1005/*
1006 * Free list of dquots
1007 * Dquots are removed from inodes and no new references can be got so we are
1008 * the only ones holding reference
1009 */
1da177e4
LT		 1010static void put_dquot_list(struct list_head *tofree_head)
1011{
1012 struct list_head *act_head;
1013 struct dquot *dquot;
1014
1015 act_head = tofree_head->next;
1da177e4
LT		 1016 while (act_head != tofree_head) {
1017 dquot = list_entry(act_head, struct dquot, dq_free);
1018 act_head = act_head->next;
268157ba
JK		 1019 /* Remove dquot from the list so we won't have problems... */
1020 list_del_init(&dquot->dq_free);
1da177e4
LT		 1021 dqput(dquot);
1022 }
1023}
1024
fb58b731
CH		 1025static void remove_dquot_ref(struct super_block *sb, int type,
1026 struct list_head *tofree_head)
1027{
1028 struct inode *inode;
7af9cce8 1029 int reserved = 0;
fb58b731 1030
74278da9 1031 spin_lock(&sb->s_inode_list_lock);
fb58b731 1032 list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
aabb8fdb
NP		 1033 /*
1034 * We have to scan also I_NEW inodes because they can already
1035 * have quota pointer initialized. Luckily, we need to touch
1036 * only quota pointers and these have separate locking
b9ba6f94 1037 * (dq_data_lock).
aabb8fdb 1038 */
b9ba6f94 1039 spin_lock(&dq_data_lock);
7af9cce8
DM		 1040 if (!IS_NOQUOTA(inode)) {
1041 if (unlikely(inode_get_rsv_space(inode) > 0))
1042 reserved = 1;
fb58b731 1043 remove_inode_dquot_ref(inode, type, tofree_head);
7af9cce8 1044 }
b9ba6f94 1045 spin_unlock(&dq_data_lock);
fb58b731 1046 }
74278da9 1047 spin_unlock(&sb->s_inode_list_lock);
7af9cce8
DM		 1048#ifdef CONFIG_QUOTA_DEBUG
1049 if (reserved) {
1050 printk(KERN_WARNING "VFS (%s): Writes happened after quota"
1051 " was disabled thus quota information is probably "
1052 "inconsistent. Please run quotacheck(8).\n", sb->s_id);
1053 }
1054#endif
fb58b731
CH		 1055}
1056
1da177e4
LT		 1057/* Gather all references from inodes and drop them */
1058static void drop_dquot_ref(struct super_block *sb, int type)
1059{
1060 LIST_HEAD(tofree_head);
1061
fb58b731 1062 if (sb->dq_op) {
fb58b731 1063 remove_dquot_ref(sb, type, &tofree_head);
b9ba6f94 1064 synchronize_srcu(&dquot_srcu);
fb58b731
CH		 1065 put_dquot_list(&tofree_head);
1066 }
1da177e4
LT		 1067}
1068
12095460 1069static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
1da177e4
LT		 1070{
1071 dquot->dq_dqb.dqb_curinodes += number;
1072}
1073
1074static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
1075{
1076 dquot->dq_dqb.dqb_curspace += number;
1077}
1078
f18df228
MC		 1079static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
1080{
1081 dquot->dq_dqb.dqb_rsvspace += number;
1082}
1083
740d9dcd
MC		 1084/*
1085 * Claim reserved quota space
1086 */
0a5a9c72 1087static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
740d9dcd 1088{
0a5a9c72
JK		 1089 if (dquot->dq_dqb.dqb_rsvspace < number) {
1090 WARN_ON_ONCE(1);
1091 number = dquot->dq_dqb.dqb_rsvspace;
1092 }
740d9dcd
MC		 1093 dquot->dq_dqb.dqb_curspace += number;
1094 dquot->dq_dqb.dqb_rsvspace -= number;
1095}
1096
1c8924eb
JK		 1097static void dquot_reclaim_reserved_space(struct dquot *dquot, qsize_t number)
1098{
1099 if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
1100 number = dquot->dq_dqb.dqb_curspace;
1101 dquot->dq_dqb.dqb_rsvspace += number;
1102 dquot->dq_dqb.dqb_curspace -= number;
1103}
1104
740d9dcd
MC		 1105static inline
1106void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
1107{
0a5a9c72
JK		 1108 if (dquot->dq_dqb.dqb_rsvspace >= number)
1109 dquot->dq_dqb.dqb_rsvspace -= number;
1110 else {
1111 WARN_ON_ONCE(1);
1112 dquot->dq_dqb.dqb_rsvspace = 0;
1113 }
740d9dcd
MC		 1114}
1115
7a2435d8 1116static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
1da177e4 1117{
db49d2df
JK		 1118 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1119 dquot->dq_dqb.dqb_curinodes >= number)
1da177e4
LT		 1120 dquot->dq_dqb.dqb_curinodes -= number;
1121 else
1122 dquot->dq_dqb.dqb_curinodes = 0;
1123 if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
1124 dquot->dq_dqb.dqb_itime = (time_t) 0;
1125 clear_bit(DQ_INODES_B, &dquot->dq_flags);
1126}
1127
7a2435d8 1128static void dquot_decr_space(struct dquot *dquot, qsize_t number)
1da177e4 1129{
db49d2df
JK		 1130 if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
1131 dquot->dq_dqb.dqb_curspace >= number)
1da177e4
LT		 1132 dquot->dq_dqb.dqb_curspace -= number;
1133 else
1134 dquot->dq_dqb.dqb_curspace = 0;
12095460 1135 if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
1da177e4
LT		 1136 dquot->dq_dqb.dqb_btime = (time_t) 0;
1137 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
1138}
1139
bf097aaf
JK		 1140struct dquot_warn {
1141 struct super_block *w_sb;
7b9c7321 1142 struct kqid w_dq_id;
bf097aaf
JK		 1143 short w_type;
1144};
1145
c525460e
JK		 1146static int warning_issued(struct dquot *dquot, const int warntype)
1147{
1148 int flag = (warntype == QUOTA_NL_BHARDWARN ||
1149 warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
1150 ((warntype == QUOTA_NL_IHARDWARN ||
1151 warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);
1152
1153 if (!flag)
1154 return 0;
1155 return test_and_set_bit(flag, &dquot->dq_flags);
1156}
1157
8e893469 1158#ifdef CONFIG_PRINT_QUOTA_WARNING
1da177e4
LT		 1159static int flag_print_warnings = 1;
1160
bf097aaf 1161static int need_print_warning(struct dquot_warn *warn)
1da177e4
LT		 1162{
1163 if (!flag_print_warnings)
1164 return 0;
1165
7b9c7321 1166 switch (warn->w_dq_id.type) {
1da177e4 1167 case USRQUOTA:
1a06d420 1168 return uid_eq(current_fsuid(), warn->w_dq_id.uid);
1da177e4 1169 case GRPQUOTA:
7b9c7321 1170 return in_group_p(warn->w_dq_id.gid);
847aac64
LX		 1171 case PRJQUOTA:
1172 return 1;
1da177e4
LT		 1173 }
1174 return 0;
1175}
1176
1da177e4 1177/* Print warning to user which exceeded quota */
bf097aaf 1178static void print_warning(struct dquot_warn *warn)
1da177e4
LT		 1179{
1180 char *msg = NULL;
24ec839c 1181 struct tty_struct *tty;
bf097aaf 1182 int warntype = warn->w_type;
1da177e4 1183
657d3bfa
JK		 1184 if (warntype == QUOTA_NL_IHARDBELOW ||
1185 warntype == QUOTA_NL_ISOFTBELOW ||
1186 warntype == QUOTA_NL_BHARDBELOW ||
bf097aaf 1187 warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
1da177e4
LT		 1188 return;
1189
24ec839c
PZ		 1190 tty = get_current_tty();
1191 if (!tty)
452a00d2 1192 return;
bf097aaf 1193 tty_write_message(tty, warn->w_sb->s_id);
8e893469 1194 if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
24ec839c 1195 tty_write_message(tty, ": warning, ");
1da177e4 1196 else
24ec839c 1197 tty_write_message(tty, ": write failed, ");
7b9c7321 1198 tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
1da177e4 1199 switch (warntype) {
8e893469 1200 case QUOTA_NL_IHARDWARN:
1da177e4
LT		 1201 msg = " file limit reached.\r\n";
1202 break;
8e893469 1203 case QUOTA_NL_ISOFTLONGWARN:
1da177e4
LT		 1204 msg = " file quota exceeded too long.\r\n";
1205 break;
8e893469 1206 case QUOTA_NL_ISOFTWARN:
1da177e4
LT		 1207 msg = " file quota exceeded.\r\n";
1208 break;
8e893469 1209 case QUOTA_NL_BHARDWARN:
1da177e4
LT		 1210 msg = " block limit reached.\r\n";
1211 break;
8e893469 1212 case QUOTA_NL_BSOFTLONGWARN:
1da177e4
LT		 1213 msg = " block quota exceeded too long.\r\n";
1214 break;
8e893469 1215 case QUOTA_NL_BSOFTWARN:
1da177e4
LT		 1216 msg = " block quota exceeded.\r\n";
1217 break;
1218 }
24ec839c 1219 tty_write_message(tty, msg);
452a00d2 1220 tty_kref_put(tty);
1da177e4 1221}
8e893469
JK		 1222#endif
1223
bf097aaf
JK		 1224static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
1225 int warntype)
1226{
1227 if (warning_issued(dquot, warntype))
1228 return;
1229 warn->w_type = warntype;
1230 warn->w_sb = dquot->dq_sb;
1231 warn->w_dq_id = dquot->dq_id;
bf097aaf
JK		 1232}
1233
f18df228
MC		 1234/*
1235 * Write warnings to the console and send warning messages over netlink.
1236 *
bf097aaf 1237 * Note that this function can call into tty and networking code.
f18df228 1238 */
bf097aaf 1239static void flush_warnings(struct dquot_warn *warn)
1da177e4
LT		 1240{
1241 int i;
1242
86e931a3 1243 for (i = 0; i < MAXQUOTAS; i++) {
bf097aaf
JK		 1244 if (warn[i].w_type == QUOTA_NL_NOWARN)
1245 continue;
8e893469 1246#ifdef CONFIG_PRINT_QUOTA_WARNING
bf097aaf 1247 print_warning(&warn[i]);
8e893469 1248#endif
7b9c7321 1249 quota_send_warning(warn[i].w_dq_id,
bf097aaf 1250 warn[i].w_sb->s_dev, warn[i].w_type);
86e931a3 1251 }
1da177e4
LT		 1252}
1253
7a2435d8 1254static int ignore_hardlimit(struct dquot *dquot)
1da177e4 1255{
4c376dca 1256 struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
1da177e4
LT		 1257
1258 return capable(CAP_SYS_RESOURCE) &&
268157ba 1259 (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
9c45101e 1260 !(info->dqi_flags & DQF_ROOT_SQUASH));
1da177e4
LT		 1261}
1262
1263/* needs dq_data_lock */
bf097aaf
JK		 1264static int check_idq(struct dquot *dquot, qsize_t inodes,
1265 struct dquot_warn *warn)
1da177e4 1266{
268157ba
JK		 1267 qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;
1268
4c376dca 1269 if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) ||
f55abc0f 1270 test_bit(DQ_FAKE_B, &dquot->dq_flags))
efd8f0e6 1271 return 0;
1da177e4
LT		 1272
1273 if (dquot->dq_dqb.dqb_ihardlimit &&
268157ba 1274 newinodes > dquot->dq_dqb.dqb_ihardlimit &&
1da177e4 1275 !ignore_hardlimit(dquot)) {
bf097aaf 1276 prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
efd8f0e6 1277 return -EDQUOT;
1da177e4
LT		 1278 }
1279
1280 if (dquot->dq_dqb.dqb_isoftlimit &&
268157ba
JK		 1281 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1282 dquot->dq_dqb.dqb_itime &&
1283 get_seconds() >= dquot->dq_dqb.dqb_itime &&
1da177e4 1284 !ignore_hardlimit(dquot)) {
bf097aaf 1285 prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
efd8f0e6 1286 return -EDQUOT;
1da177e4
LT		 1287 }
1288
1289 if (dquot->dq_dqb.dqb_isoftlimit &&
268157ba 1290 newinodes > dquot->dq_dqb.dqb_isoftlimit &&
1da177e4 1291 dquot->dq_dqb.dqb_itime == 0) {
bf097aaf 1292 prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
268157ba 1293 dquot->dq_dqb.dqb_itime = get_seconds() +
4c376dca 1294 sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
1da177e4
LT		 1295 }
1296
efd8f0e6 1297 return 0;
1da177e4
LT		 1298}
1299
1300/* needs dq_data_lock */
bf097aaf
JK		 1301static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc,
1302 struct dquot_warn *warn)
1da177e4 1303{
f18df228 1304 qsize_t tspace;
268157ba 1305 struct super_block *sb = dquot->dq_sb;
f18df228 1306
4c376dca 1307 if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) ||
f55abc0f 1308 test_bit(DQ_FAKE_B, &dquot->dq_flags))
efd8f0e6 1309 return 0;
1da177e4 1310
f18df228
MC		 1311 tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
1312 + space;
1313
1da177e4 1314 if (dquot->dq_dqb.dqb_bhardlimit &&
f18df228 1315 tspace > dquot->dq_dqb.dqb_bhardlimit &&
1da177e4
LT		 1316 !ignore_hardlimit(dquot)) {
1317 if (!prealloc)
bf097aaf 1318 prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
efd8f0e6 1319 return -EDQUOT;
1da177e4
LT		 1320 }
1321
1322 if (dquot->dq_dqb.dqb_bsoftlimit &&
f18df228 1323 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
268157ba
JK		 1324 dquot->dq_dqb.dqb_btime &&
1325 get_seconds() >= dquot->dq_dqb.dqb_btime &&
1da177e4
LT		 1326 !ignore_hardlimit(dquot)) {
1327 if (!prealloc)
bf097aaf 1328 prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
efd8f0e6 1329 return -EDQUOT;
1da177e4
LT		 1330 }
1331
1332 if (dquot->dq_dqb.dqb_bsoftlimit &&
f18df228 1333 tspace > dquot->dq_dqb.dqb_bsoftlimit &&
1da177e4
LT		 1334 dquot->dq_dqb.dqb_btime == 0) {
1335 if (!prealloc) {
bf097aaf 1336 prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
268157ba 1337 dquot->dq_dqb.dqb_btime = get_seconds() +
4c376dca 1338 sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
1da177e4
LT		 1339 }
1340 else
1341 /*
1342 * We don't allow preallocation to exceed softlimit so exceeding will
1343 * be always printed
1344 */
efd8f0e6 1345 return -EDQUOT;
1da177e4
LT		 1346 }
1347
efd8f0e6 1348 return 0;
1da177e4
LT		 1349}
1350
12095460 1351static int info_idq_free(struct dquot *dquot, qsize_t inodes)
657d3bfa 1352{
268157ba
JK		 1353 qsize_t newinodes;
1354
657d3bfa 1355 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
f55abc0f 1356 dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
4c376dca 1357 !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type))
657d3bfa
JK		 1358 return QUOTA_NL_NOWARN;
1359
268157ba
JK		 1360 newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
1361 if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
657d3bfa
JK		 1362 return QUOTA_NL_ISOFTBELOW;
1363 if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
268157ba 1364 newinodes < dquot->dq_dqb.dqb_ihardlimit)
657d3bfa
JK		 1365 return QUOTA_NL_IHARDBELOW;
1366 return QUOTA_NL_NOWARN;
1367}
1368
1369static int info_bdq_free(struct dquot *dquot, qsize_t space)
1370{
1371 if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
12095460 1372 dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
657d3bfa
JK		 1373 return QUOTA_NL_NOWARN;
1374
12095460 1375 if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
657d3bfa 1376 return QUOTA_NL_BSOFTBELOW;
12095460
JK		 1377 if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
1378 dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
657d3bfa
JK		 1379 return QUOTA_NL_BHARDBELOW;
1380 return QUOTA_NL_NOWARN;
1381}
0a5a9c72 1382
189eef59
CH		 1383static int dquot_active(const struct inode *inode)
1384{
1385 struct super_block *sb = inode->i_sb;
1386
1387 if (IS_NOQUOTA(inode))
1388 return 0;
1389 return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
1390}
1391
1da177e4 1392/*
871a2931
CH		 1393 * Initialize quota pointers in inode
1394 *
871a2931
CH		 1395 * It is better to call this function outside of any transaction as it
1396 * might need a lot of space in journal for dquot structure allocation.
1da177e4 1397 */
6184fc0b 1398static int __dquot_initialize(struct inode *inode, int type)
1da177e4 1399{
1ea06bec 1400 int cnt, init_needed = 0;
5bcd3b6f 1401 struct dquot **dquots, *got[MAXQUOTAS];
cc33412f 1402 struct super_block *sb = inode->i_sb;
0a5a9c72 1403 qsize_t rsv;
6184fc0b 1404 int ret = 0;
1da177e4 1405
189eef59 1406 if (!dquot_active(inode))
6184fc0b 1407 return 0;
cc33412f 1408
5bcd3b6f
KK		 1409 dquots = i_dquot(inode);
1410
cc33412f
JK		 1411 /* First get references to structures we might need. */
1412 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
aca645a6 1413 struct kqid qid;
847aac64
LX		 1414 kprojid_t projid;
1415 int rc;
6184fc0b 1416 struct dquot *dquot;
847aac64 1417
ad1e6e8d 1418 got[cnt] = NULL;
cc33412f
JK		 1419 if (type != -1 && cnt != type)
1420 continue;
1ea06bec
NY		 1421 /*
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 */
5bcd3b6f 1426 if (dquots[cnt])
1ea06bec 1427 continue;
847aac64
LX		 1428
1429 if (!sb_has_quota_active(sb, cnt))
1430 continue;
1431
1ea06bec
NY		 1432 init_needed = 1;
1433
cc33412f
JK		 1434 switch (cnt) {
1435 case USRQUOTA:
aca645a6 1436 qid = make_kqid_uid(inode->i_uid);
cc33412f
JK		 1437 break;
1438 case GRPQUOTA:
aca645a6 1439 qid = make_kqid_gid(inode->i_gid);
cc33412f 1440 break;
847aac64
LX		 1441 case PRJQUOTA:
1442 rc = inode->i_sb->dq_op->get_projid(inode, &projid);
1443 if (rc)
1444 continue;
1445 qid = make_kqid_projid(projid);
1446 break;
cc33412f 1447 }
6184fc0b
JK		 1448 dquot = dqget(sb, qid);
1449 if (IS_ERR(dquot)) {
1450 /* We raced with somebody turning quotas off... */
1451 if (PTR_ERR(dquot) != -ESRCH) {
1452 ret = PTR_ERR(dquot);
1453 goto out_put;
1454 }
1455 dquot = NULL;
1456 }
1457 got[cnt] = dquot;
cc33412f
JK		 1458 }
1459
1ea06bec
NY		 1460 /* All required i_dquot has been initialized */
1461 if (!init_needed)
6184fc0b 1462 return 0;
1ea06bec 1463
b9ba6f94 1464 spin_lock(&dq_data_lock);
1da177e4 1465 if (IS_NOQUOTA(inode))
6184fc0b 1466 goto out_lock;
1da177e4
LT		 1467 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1468 if (type != -1 && cnt != type)
1469 continue;
cc33412f
JK		 1470 /* Avoid races with quotaoff() */
1471 if (!sb_has_quota_active(sb, cnt))
1472 continue;
4408ea41
JK		 1473 /* We could race with quotaon or dqget() could have failed */
1474 if (!got[cnt])
1475 continue;
5bcd3b6f
KK		 1476 if (!dquots[cnt]) {
1477 dquots[cnt] = got[cnt];
dd6f3c6d 1478 got[cnt] = NULL;
0a5a9c72
JK		 1479 /*
1480 * Make quota reservation system happy if someone
1481 * did a write before quota was turned on
1482 */
1483 rsv = inode_get_rsv_space(inode);
b9ba6f94 1484 if (unlikely(rsv))
5bcd3b6f 1485 dquot_resv_space(dquots[cnt], rsv);
1da177e4
LT		 1486 }
1487 }
6184fc0b 1488out_lock:
b9ba6f94 1489 spin_unlock(&dq_data_lock);
6184fc0b 1490out_put:
cc33412f 1491 /* Drop unused references */
dc52dd3a 1492 dqput_all(got);
6184fc0b
JK		 1493
1494 return ret;
871a2931
CH		 1495}
1496
6184fc0b 1497int dquot_initialize(struct inode *inode)
871a2931 1498{
6184fc0b 1499 return __dquot_initialize(inode, -1);
1da177e4 1500}
08d0350c 1501EXPORT_SYMBOL(dquot_initialize);
1da177e4
LT		 1502
1503/*
b9ba6f94
NY		 1504 * Release all quotas referenced by inode.
1505 *
1506 * This function only be called on inode free or converting
1507 * a file to quota file, no other users for the i_dquot in
1508 * both cases, so we needn't call synchronize_srcu() after
1509 * clearing i_dquot.
1da177e4 1510 */
9f754758 1511static void __dquot_drop(struct inode *inode)
1da177e4
LT		 1512{
1513 int cnt;
5bcd3b6f 1514 struct dquot **dquots = i_dquot(inode);
cc33412f 1515 struct dquot *put[MAXQUOTAS];
1da177e4 1516
b9ba6f94 1517 spin_lock(&dq_data_lock);
1da177e4 1518 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
5bcd3b6f
KK		 1519 put[cnt] = dquots[cnt];
1520 dquots[cnt] = NULL;
1da177e4 1521 }
b9ba6f94 1522 spin_unlock(&dq_data_lock);
dc52dd3a 1523 dqput_all(put);
1da177e4
LT		 1524}
1525
9f754758
CH		 1526void dquot_drop(struct inode *inode)
1527{
5bcd3b6f 1528 struct dquot * const *dquots;
9f754758
CH		 1529 int cnt;
1530
1531 if (IS_NOQUOTA(inode))
1532 return;
1533
1534 /*
1535 * Test before calling to rule out calls from proc and such
1536 * where we are not allowed to block. Note that this is
1537 * actually reliable test even without the lock - the caller
1538 * must assure that nobody can come after the DQUOT_DROP and
1539 * add quota pointers back anyway.
1540 */
5bcd3b6f 1541 dquots = i_dquot(inode);
9f754758 1542 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
5bcd3b6f 1543 if (dquots[cnt])
9f754758
CH		 1544 break;
1545 }
1546
1547 if (cnt < MAXQUOTAS)
1548 __dquot_drop(inode);
1549}
1550EXPORT_SYMBOL(dquot_drop);
b85f4b87 1551
fd8fbfc1
DM		 1552/*
1553 * inode_reserved_space is managed internally by quota, and protected by
1554 * i_lock similar to i_blocks+i_bytes.
1555 */
1556static qsize_t *inode_reserved_space(struct inode * inode)
1557{
1558 /* Filesystem must explicitly define it's own method in order to use
1559 * quota reservation interface */
1560 BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
1561 return inode->i_sb->dq_op->get_reserved_space(inode);
1562}
1563
c469070a 1564void inode_add_rsv_space(struct inode *inode, qsize_t number)
fd8fbfc1
DM		 1565{
1566 spin_lock(&inode->i_lock);
1567 *inode_reserved_space(inode) += number;
1568 spin_unlock(&inode->i_lock);
1569}
c469070a 1570EXPORT_SYMBOL(inode_add_rsv_space);
fd8fbfc1 1571
c469070a 1572void inode_claim_rsv_space(struct inode *inode, qsize_t number)
fd8fbfc1
DM		 1573{
1574 spin_lock(&inode->i_lock);
1575 *inode_reserved_space(inode) -= number;
1576 __inode_add_bytes(inode, number);
1577 spin_unlock(&inode->i_lock);
1578}
c469070a 1579EXPORT_SYMBOL(inode_claim_rsv_space);
fd8fbfc1 1580
1c8924eb
JK		 1581void inode_reclaim_rsv_space(struct inode *inode, qsize_t number)
1582{
1583 spin_lock(&inode->i_lock);
1584 *inode_reserved_space(inode) += number;
1585 __inode_sub_bytes(inode, number);
1586 spin_unlock(&inode->i_lock);
1587}
1588EXPORT_SYMBOL(inode_reclaim_rsv_space);
1589
c469070a 1590void inode_sub_rsv_space(struct inode *inode, qsize_t number)
fd8fbfc1
DM		 1591{
1592 spin_lock(&inode->i_lock);
1593 *inode_reserved_space(inode) -= number;
1594 spin_unlock(&inode->i_lock);
1595}
c469070a 1596EXPORT_SYMBOL(inode_sub_rsv_space);
fd8fbfc1
DM		 1597
1598static qsize_t inode_get_rsv_space(struct inode *inode)
1599{
1600 qsize_t ret;
05b5d898
JK		 1601
1602 if (!inode->i_sb->dq_op->get_reserved_space)
1603 return 0;
fd8fbfc1
DM		 1604 spin_lock(&inode->i_lock);
1605 ret = *inode_reserved_space(inode);
1606 spin_unlock(&inode->i_lock);
1607 return ret;
1608}
1609
1610static void inode_incr_space(struct inode *inode, qsize_t number,
1611 int reserve)
1612{
1613 if (reserve)
1614 inode_add_rsv_space(inode, number);
1615 else
1616 inode_add_bytes(inode, number);
1617}
1618
1619static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
1620{
1621 if (reserve)
1622 inode_sub_rsv_space(inode, number);
1623 else
1624 inode_sub_bytes(inode, number);
1625}
1626
1da177e4 1627/*
5dd4056d
CH		 1628 * This functions updates i_blocks+i_bytes fields and quota information
1629 * (together with appropriate checks).
1630 *
1631 * NOTE: We absolutely rely on the fact that caller dirties the inode
1632 * (usually helpers in quotaops.h care about this) and holds a handle for
1633 * the current transaction so that dquot write and inode write go into the
1634 * same transaction.
1da177e4
LT		 1635 */
1636
1637/*
1638 * This operation can block, but only after everything is updated
1639 */
56246f9a 1640int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
1da177e4 1641{
b9ba6f94 1642 int cnt, ret = 0, index;
bf097aaf 1643 struct dquot_warn warn[MAXQUOTAS];
56246f9a 1644 int reserve = flags & DQUOT_SPACE_RESERVE;
5bcd3b6f 1645 struct dquot **dquots;
1da177e4 1646
189eef59 1647 if (!dquot_active(inode)) {
fd8fbfc1
DM		 1648 inode_incr_space(inode, number, reserve);
1649 goto out;
1650 }
1651
1da177e4 1652 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
bf097aaf 1653 warn[cnt].w_type = QUOTA_NL_NOWARN;
1da177e4 1654
5bcd3b6f 1655 dquots = i_dquot(inode);
b9ba6f94 1656 index = srcu_read_lock(&dquot_srcu);
1da177e4
LT		 1657 spin_lock(&dq_data_lock);
1658 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
bf097aaf 1659 if (!dquots[cnt])
1da177e4 1660 continue;
bf097aaf
JK		 1661 ret = check_bdq(dquots[cnt], number,
1662 !(flags & DQUOT_SPACE_WARN), &warn[cnt]);
1663 if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
fd8fbfc1
DM		 1664 spin_unlock(&dq_data_lock);
1665 goto out_flush_warn;
f18df228 1666 }
1da177e4
LT		 1667 }
1668 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
bf097aaf 1669 if (!dquots[cnt])
1da177e4 1670 continue;
f18df228 1671 if (reserve)
bf097aaf 1672 dquot_resv_space(dquots[cnt], number);
f18df228 1673 else
bf097aaf 1674 dquot_incr_space(dquots[cnt], number);
1da177e4 1675 }
fd8fbfc1 1676 inode_incr_space(inode, number, reserve);
1da177e4 1677 spin_unlock(&dq_data_lock);
f18df228 1678
fd8fbfc1
DM		 1679 if (reserve)
1680 goto out_flush_warn;
bf097aaf 1681 mark_all_dquot_dirty(dquots);
fd8fbfc1 1682out_flush_warn:
b9ba6f94 1683 srcu_read_unlock(&dquot_srcu, index);
bf097aaf 1684 flush_warnings(warn);
f18df228
MC		 1685out:
1686 return ret;
1687}
5dd4056d 1688EXPORT_SYMBOL(__dquot_alloc_space);
1da177e4
LT		 1689
1690/*
1691 * This operation can block, but only after everything is updated
1692 */
6bab3596 1693int dquot_alloc_inode(struct inode *inode)
1da177e4 1694{
b9ba6f94 1695 int cnt, ret = 0, index;
bf097aaf 1696 struct dquot_warn warn[MAXQUOTAS];
5bcd3b6f 1697 struct dquot * const *dquots;
1da177e4 1698
189eef59 1699 if (!dquot_active(inode))
63936dda 1700 return 0;
1da177e4 1701 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
bf097aaf 1702 warn[cnt].w_type = QUOTA_NL_NOWARN;
b9ba6f94 1703
5bcd3b6f 1704 dquots = i_dquot(inode);
b9ba6f94 1705 index = srcu_read_lock(&dquot_srcu);
1da177e4
LT		 1706 spin_lock(&dq_data_lock);
1707 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
bf097aaf 1708 if (!dquots[cnt])
1da177e4 1709 continue;
bf097aaf 1710 ret = check_idq(dquots[cnt], 1, &warn[cnt]);
efd8f0e6 1711 if (ret)
1da177e4
LT		 1712 goto warn_put_all;
1713 }
1714
1715 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
bf097aaf 1716 if (!dquots[cnt])
1da177e4 1717 continue;
bf097aaf 1718 dquot_incr_inodes(dquots[cnt], 1);
1da177e4 1719 }
efd8f0e6 1720
1da177e4
LT		 1721warn_put_all:
1722 spin_unlock(&dq_data_lock);
63936dda 1723 if (ret == 0)
bf097aaf 1724 mark_all_dquot_dirty(dquots);
b9ba6f94 1725 srcu_read_unlock(&dquot_srcu, index);
bf097aaf 1726 flush_warnings(warn);
1da177e4
LT		 1727 return ret;
1728}
08d0350c 1729EXPORT_SYMBOL(dquot_alloc_inode);
1da177e4 1730
5dd4056d
CH		 1731/*
1732 * Convert in-memory reserved quotas to real consumed quotas
1733 */
1734int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
740d9dcd 1735{
5bcd3b6f 1736 struct dquot **dquots;
b9ba6f94 1737 int cnt, index;
740d9dcd 1738
189eef59 1739 if (!dquot_active(inode)) {
fd8fbfc1 1740 inode_claim_rsv_space(inode, number);
5dd4056d 1741 return 0;
740d9dcd
MC		 1742 }
1743
5bcd3b6f 1744 dquots = i_dquot(inode);
b9ba6f94 1745 index = srcu_read_lock(&dquot_srcu);
740d9dcd
MC		 1746 spin_lock(&dq_data_lock);
1747 /* Claim reserved quotas to allocated quotas */
1748 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
5bcd3b6f
KK		 1749 if (dquots[cnt])
1750 dquot_claim_reserved_space(dquots[cnt], number);
740d9dcd
MC		 1751 }
1752 /* Update inode bytes */
fd8fbfc1 1753 inode_claim_rsv_space(inode, number);
740d9dcd 1754 spin_unlock(&dq_data_lock);
5bcd3b6f 1755 mark_all_dquot_dirty(dquots);
b9ba6f94 1756 srcu_read_unlock(&dquot_srcu, index);
5dd4056d 1757 return 0;
740d9dcd 1758}
5dd4056d 1759EXPORT_SYMBOL(dquot_claim_space_nodirty);
740d9dcd 1760
1c8924eb
JK		 1761/*
1762 * Convert allocated space back to in-memory reserved quotas
1763 */
1764void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
1765{
5bcd3b6f 1766 struct dquot **dquots;
b9ba6f94 1767 int cnt, index;
1c8924eb
JK		 1768
1769 if (!dquot_active(inode)) {
1770 inode_reclaim_rsv_space(inode, number);
1771 return;
1772 }
1773
5bcd3b6f 1774 dquots = i_dquot(inode);
b9ba6f94 1775 index = srcu_read_lock(&dquot_srcu);
1c8924eb
JK		 1776 spin_lock(&dq_data_lock);
1777 /* Claim reserved quotas to allocated quotas */
1778 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
5bcd3b6f
KK		 1779 if (dquots[cnt])
1780 dquot_reclaim_reserved_space(dquots[cnt], number);
1c8924eb
JK		 1781 }
1782 /* Update inode bytes */
1783 inode_reclaim_rsv_space(inode, number);
1784 spin_unlock(&dq_data_lock);
5bcd3b6f 1785 mark_all_dquot_dirty(dquots);
b9ba6f94 1786 srcu_read_unlock(&dquot_srcu, index);
1c8924eb
JK		 1787 return;
1788}
1789EXPORT_SYMBOL(dquot_reclaim_space_nodirty);
1790
1da177e4
LT		 1791/*
1792 * This operation can block, but only after everything is updated
1793 */
56246f9a 1794void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
1da177e4
LT		 1795{
1796 unsigned int cnt;
bf097aaf 1797 struct dquot_warn warn[MAXQUOTAS];
5bcd3b6f 1798 struct dquot **dquots;
b9ba6f94 1799 int reserve = flags & DQUOT_SPACE_RESERVE, index;
1da177e4 1800
189eef59 1801 if (!dquot_active(inode)) {
fd8fbfc1 1802 inode_decr_space(inode, number, reserve);
5dd4056d 1803 return;
1da177e4 1804 }
657d3bfa 1805
5bcd3b6f 1806 dquots = i_dquot(inode);
b9ba6f94 1807 index = srcu_read_lock(&dquot_srcu);
1da177e4
LT		 1808 spin_lock(&dq_data_lock);
1809 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
bf097aaf
JK		 1810 int wtype;
1811
1812 warn[cnt].w_type = QUOTA_NL_NOWARN;
1813 if (!dquots[cnt])
1da177e4 1814 continue;
bf097aaf
JK		 1815 wtype = info_bdq_free(dquots[cnt], number);
1816 if (wtype != QUOTA_NL_NOWARN)
1817 prepare_warning(&warn[cnt], dquots[cnt], wtype);
fd8fbfc1 1818 if (reserve)
bf097aaf 1819 dquot_free_reserved_space(dquots[cnt], number);
fd8fbfc1 1820 else
bf097aaf 1821 dquot_decr_space(dquots[cnt], number);
1da177e4 1822 }
fd8fbfc1 1823 inode_decr_space(inode, number, reserve);
1da177e4 1824 spin_unlock(&dq_data_lock);
fd8fbfc1
DM		 1825
1826 if (reserve)
1827 goto out_unlock;
bf097aaf 1828 mark_all_dquot_dirty(dquots);
fd8fbfc1 1829out_unlock:
b9ba6f94 1830 srcu_read_unlock(&dquot_srcu, index);
bf097aaf 1831 flush_warnings(warn);
fd8fbfc1 1832}
5dd4056d 1833EXPORT_SYMBOL(__dquot_free_space);
fd8fbfc1 1834
1da177e4
LT		 1835/*
1836 * This operation can block, but only after everything is updated
1837 */
6bab3596 1838void dquot_free_inode(struct inode *inode)
1da177e4
LT		 1839{
1840 unsigned int cnt;
bf097aaf 1841 struct dquot_warn warn[MAXQUOTAS];
5bcd3b6f 1842 struct dquot * const *dquots;
b9ba6f94 1843 int index;
1da177e4 1844
189eef59 1845 if (!dquot_active(inode))
63936dda 1846 return;
657d3bfa 1847
5bcd3b6f 1848 dquots = i_dquot(inode);
b9ba6f94 1849 index = srcu_read_lock(&dquot_srcu);
1da177e4
LT		 1850 spin_lock(&dq_data_lock);
1851 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
bf097aaf
JK		 1852 int wtype;
1853
1854 warn[cnt].w_type = QUOTA_NL_NOWARN;
1855 if (!dquots[cnt])
1da177e4 1856 continue;
bf097aaf
JK		 1857 wtype = info_idq_free(dquots[cnt], 1);
1858 if (wtype != QUOTA_NL_NOWARN)
1859 prepare_warning(&warn[cnt], dquots[cnt], wtype);
1860 dquot_decr_inodes(dquots[cnt], 1);
1da177e4
LT		 1861 }
1862 spin_unlock(&dq_data_lock);
bf097aaf 1863 mark_all_dquot_dirty(dquots);
b9ba6f94 1864 srcu_read_unlock(&dquot_srcu, index);
bf097aaf 1865 flush_warnings(warn);
1da177e4 1866}
08d0350c 1867EXPORT_SYMBOL(dquot_free_inode);
1da177e4
LT		 1868
1869/*
1870 * Transfer the number of inode and blocks from one diskquota to an other.
bc8e5f07
JK		 1871 * On success, dquot references in transfer_to are consumed and references
1872 * to original dquots that need to be released are placed there. On failure,
1873 * references are kept untouched.
1da177e4
LT		 1874 *
1875 * This operation can block, but only after everything is updated
1876 * A transaction must be started when entering this function.
bc8e5f07 1877 *
b9ba6f94
NY		 1878 * We are holding reference on transfer_from & transfer_to, no need to
1879 * protect them by srcu_read_lock().
1da177e4 1880 */
bc8e5f07 1881int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
1da177e4 1882{
740d9dcd
MC		 1883 qsize_t space, cur_space;
1884 qsize_t rsv_space = 0;
bc8e5f07 1885 struct dquot *transfer_from[MAXQUOTAS] = {};
efd8f0e6 1886 int cnt, ret = 0;
9e32784b 1887 char is_valid[MAXQUOTAS] = {};
bf097aaf
JK		 1888 struct dquot_warn warn_to[MAXQUOTAS];
1889 struct dquot_warn warn_from_inodes[MAXQUOTAS];
1890 struct dquot_warn warn_from_space[MAXQUOTAS];
1da177e4 1891
1da177e4 1892 if (IS_NOQUOTA(inode))
efd8f0e6 1893 return 0;
cc33412f 1894 /* Initialize the arrays */
bf097aaf
JK		 1895 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1896 warn_to[cnt].w_type = QUOTA_NL_NOWARN;
1897 warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
1898 warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
1899 }
b9ba6f94
NY		 1900
1901 spin_lock(&dq_data_lock);
cc33412f 1902 if (IS_NOQUOTA(inode)) { /* File without quota accounting? */
b9ba6f94 1903 spin_unlock(&dq_data_lock);
bc8e5f07 1904 return 0;
cc33412f 1905 }
740d9dcd 1906 cur_space = inode_get_bytes(inode);
fd8fbfc1 1907 rsv_space = inode_get_rsv_space(inode);
740d9dcd 1908 space = cur_space + rsv_space;
1da177e4
LT		 1909 /* Build the transfer_from list and check the limits */
1910 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
9e32784b
D		 1911 /*
1912 * Skip changes for same uid or gid or for turned off quota-type.
1913 */
dd6f3c6d 1914 if (!transfer_to[cnt])
1da177e4 1915 continue;
9e32784b
D		 1916 /* Avoid races with quotaoff() */
1917 if (!sb_has_quota_active(inode->i_sb, cnt))
1918 continue;
1919 is_valid[cnt] = 1;
2d0fa467 1920 transfer_from[cnt] = i_dquot(inode)[cnt];
bf097aaf 1921 ret = check_idq(transfer_to[cnt], 1, &warn_to[cnt]);
efd8f0e6
CH		 1922 if (ret)
1923 goto over_quota;
bf097aaf 1924 ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
efd8f0e6 1925 if (ret)
cc33412f 1926 goto over_quota;
1da177e4
LT		 1927 }
1928
1929 /*
1930 * Finally perform the needed transfer from transfer_from to transfer_to
1931 */
1932 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
9e32784b 1933 if (!is_valid[cnt])
1da177e4 1934 continue;
1da177e4
LT		 1935 /* Due to IO error we might not have transfer_from[] structure */
1936 if (transfer_from[cnt]) {
bf097aaf
JK		 1937 int wtype;
1938 wtype = info_idq_free(transfer_from[cnt], 1);
1939 if (wtype != QUOTA_NL_NOWARN)
1940 prepare_warning(&warn_from_inodes[cnt],
1941 transfer_from[cnt], wtype);
1942 wtype = info_bdq_free(transfer_from[cnt], space);
1943 if (wtype != QUOTA_NL_NOWARN)
1944 prepare_warning(&warn_from_space[cnt],
1945 transfer_from[cnt], wtype);
1da177e4 1946 dquot_decr_inodes(transfer_from[cnt], 1);
740d9dcd
MC		 1947 dquot_decr_space(transfer_from[cnt], cur_space);
1948 dquot_free_reserved_space(transfer_from[cnt],
1949 rsv_space);
1da177e4
LT		 1950 }
1951
1952 dquot_incr_inodes(transfer_to[cnt], 1);
740d9dcd
MC		 1953 dquot_incr_space(transfer_to[cnt], cur_space);
1954 dquot_resv_space(transfer_to[cnt], rsv_space);
1da177e4 1955
2d0fa467 1956 i_dquot(inode)[cnt] = transfer_to[cnt];
1da177e4 1957 }
1da177e4 1958 spin_unlock(&dq_data_lock);
cc33412f 1959
dc52dd3a
DM		 1960 mark_all_dquot_dirty(transfer_from);
1961 mark_all_dquot_dirty(transfer_to);
bf097aaf
JK		 1962 flush_warnings(warn_to);
1963 flush_warnings(warn_from_inodes);
1964 flush_warnings(warn_from_space);
bc8e5f07 1965 /* Pass back references to put */
dc52dd3a 1966 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
9e32784b
D		 1967 if (is_valid[cnt])
1968 transfer_to[cnt] = transfer_from[cnt];
86f3cbec 1969 return 0;
cc33412f
JK		 1970over_quota:
1971 spin_unlock(&dq_data_lock);
bf097aaf 1972 flush_warnings(warn_to);
86f3cbec 1973 return ret;
1da177e4 1974}
bc8e5f07 1975EXPORT_SYMBOL(__dquot_transfer);
1da177e4 1976
8ddd69d6
DM		 1977/* Wrapper for transferring ownership of an inode for uid/gid only
1978 * Called from FSXXX_setattr()
1979 */
b43fa828 1980int dquot_transfer(struct inode *inode, struct iattr *iattr)
b85f4b87 1981{
bc8e5f07 1982 struct dquot *transfer_to[MAXQUOTAS] = {};
6184fc0b 1983 struct dquot *dquot;
bc8e5f07
JK		 1984 struct super_block *sb = inode->i_sb;
1985 int ret;
8ddd69d6 1986
189eef59 1987 if (!dquot_active(inode))
bc8e5f07 1988 return 0;
12755627 1989
6184fc0b
JK		 1990 if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)){
1991 dquot = dqget(sb, make_kqid_uid(iattr->ia_uid));
1992 if (IS_ERR(dquot)) {
1993 if (PTR_ERR(dquot) != -ESRCH) {
1994 ret = PTR_ERR(dquot);
1995 goto out_put;
1996 }
1997 dquot = NULL;
1998 }
1999 transfer_to[USRQUOTA] = dquot;
2000 }
2001 if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid)){
2002 dquot = dqget(sb, make_kqid_gid(iattr->ia_gid));
2003 if (IS_ERR(dquot)) {
2004 if (PTR_ERR(dquot) != -ESRCH) {
2005 ret = PTR_ERR(dquot);
2006 goto out_put;
2007 }
2008 dquot = NULL;
2009 }
2010 transfer_to[GRPQUOTA] = dquot;
2011 }
bc8e5f07 2012 ret = __dquot_transfer(inode, transfer_to);
6184fc0b 2013out_put:
bc8e5f07
JK		 2014 dqput_all(transfer_to);
2015 return ret;
b85f4b87 2016}
b43fa828 2017EXPORT_SYMBOL(dquot_transfer);
b85f4b87 2018
1da177e4
LT		 2019/*
2020 * Write info of quota file to disk
2021 */
2022int dquot_commit_info(struct super_block *sb, int type)
2023{
2024 int ret;
2025 struct quota_info *dqopt = sb_dqopt(sb);
2026
d3be915f 2027 mutex_lock(&dqopt->dqio_mutex);
1da177e4 2028 ret = dqopt->ops[type]->write_file_info(sb, type);
d3be915f 2029 mutex_unlock(&dqopt->dqio_mutex);
1da177e4
LT		 2030 return ret;
2031}
08d0350c 2032EXPORT_SYMBOL(dquot_commit_info);
1da177e4
LT		 2033
2034/*
2035 * Definitions of diskquota operations.
2036 */
61e225dc 2037const struct dquot_operations dquot_operations = {
1da177e4
LT		 2038 .write_dquot = dquot_commit,
2039 .acquire_dquot = dquot_acquire,
2040 .release_dquot = dquot_release,
2041 .mark_dirty = dquot_mark_dquot_dirty,
74f783af
JK		 2042 .write_info = dquot_commit_info,
2043 .alloc_dquot = dquot_alloc,
2044 .destroy_dquot = dquot_destroy,
1da177e4 2045};
123e9caf 2046EXPORT_SYMBOL(dquot_operations);
1da177e4 2047
907f4554
CH		 2048/*
2049 * Generic helper for ->open on filesystems supporting disk quotas.
2050 */
2051int dquot_file_open(struct inode *inode, struct file *file)
2052{
2053 int error;
2054
2055 error = generic_file_open(inode, file);
2056 if (!error && (file->f_mode & FMODE_WRITE))
871a2931 2057 dquot_initialize(inode);
907f4554
CH		 2058 return error;
2059}
2060EXPORT_SYMBOL(dquot_file_open);
2061
1da177e4
LT		 2062/*
2063 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
2064 */
0f0dd62f 2065int dquot_disable(struct super_block *sb, int type, unsigned int flags)
1da177e4 2066{
0ff5af83 2067 int cnt, ret = 0;
1da177e4
LT		 2068 struct quota_info *dqopt = sb_dqopt(sb);
2069 struct inode *toputinode[MAXQUOTAS];
1da177e4 2070
f55abc0f
JK		 2071 /* Cannot turn off usage accounting without turning off limits, or
2072 * suspend quotas and simultaneously turn quotas off. */
2073 if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
2074 || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
2075 DQUOT_USAGE_ENABLED)))
2076 return -EINVAL;
2077
1da177e4 2078 /* We need to serialize quota_off() for device */
d3be915f 2079 mutex_lock(&dqopt->dqonoff_mutex);
9377abd0
JK		 2080
2081 /*
2082 * Skip everything if there's nothing to do. We have to do this because
2083 * sometimes we are called when fill_super() failed and calling
2084 * sync_fs() in such cases does no good.
2085 */
f55abc0f 2086 if (!sb_any_quota_loaded(sb)) {
9377abd0
JK		 2087 mutex_unlock(&dqopt->dqonoff_mutex);
2088 return 0;
2089 }
1da177e4
LT		 2090 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2091 toputinode[cnt] = NULL;
1da177e4
LT		 2092 if (type != -1 && cnt != type)
2093 continue;
f55abc0f 2094 if (!sb_has_quota_loaded(sb, cnt))
0ff5af83 2095 continue;
f55abc0f
JK		 2096
2097 if (flags & DQUOT_SUSPENDED) {
cc33412f 2098 spin_lock(&dq_state_lock);
f55abc0f
JK		 2099 dqopt->flags |=
2100 dquot_state_flag(DQUOT_SUSPENDED, cnt);
cc33412f 2101 spin_unlock(&dq_state_lock);
f55abc0f 2102 } else {
cc33412f 2103 spin_lock(&dq_state_lock);
f55abc0f
JK		 2104 dqopt->flags &= ~dquot_state_flag(flags, cnt);
2105 /* Turning off suspended quotas? */
2106 if (!sb_has_quota_loaded(sb, cnt) &&
2107 sb_has_quota_suspended(sb, cnt)) {
2108 dqopt->flags &= ~dquot_state_flag(
2109 DQUOT_SUSPENDED, cnt);
cc33412f 2110 spin_unlock(&dq_state_lock);
f55abc0f
JK		 2111 iput(dqopt->files[cnt]);
2112 dqopt->files[cnt] = NULL;
2113 continue;
2114 }
cc33412f 2115 spin_unlock(&dq_state_lock);
0ff5af83 2116 }
f55abc0f
JK		 2117
2118 /* We still have to keep quota loaded? */
2119 if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
1da177e4 2120 continue;
1da177e4
LT		 2121
2122 /* Note: these are blocking operations */
2123 drop_dquot_ref(sb, cnt);
2124 invalidate_dquots(sb, cnt);
2125 /*
268157ba
JK		 2126 * Now all dquots should be invalidated, all writes done so we
2127 * should be only users of the info. No locks needed.
1da177e4
LT		 2128 */
2129 if (info_dirty(&dqopt->info[cnt]))
2130 sb->dq_op->write_info(sb, cnt);
2131 if (dqopt->ops[cnt]->free_file_info)
2132 dqopt->ops[cnt]->free_file_info(sb, cnt);
2133 put_quota_format(dqopt->info[cnt].dqi_format);
2134
2135 toputinode[cnt] = dqopt->files[cnt];
f55abc0f 2136 if (!sb_has_quota_loaded(sb, cnt))
0ff5af83 2137 dqopt->files[cnt] = NULL;
1da177e4
LT		 2138 dqopt->info[cnt].dqi_flags = 0;
2139 dqopt->info[cnt].dqi_igrace = 0;
2140 dqopt->info[cnt].dqi_bgrace = 0;
2141 dqopt->ops[cnt] = NULL;
2142 }
d3be915f 2143 mutex_unlock(&dqopt->dqonoff_mutex);
ca785ec6
JK		 2144
2145 /* Skip syncing and setting flags if quota files are hidden */
2146 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2147 goto put_inodes;
2148
1da177e4 2149 /* Sync the superblock so that buffers with quota data are written to
7b7b1ace 2150 * disk (and so userspace sees correct data afterwards). */
1da177e4
LT		 2151 if (sb->s_op->sync_fs)
2152 sb->s_op->sync_fs(sb, 1);
2153 sync_blockdev(sb->s_bdev);
2154 /* Now the quota files are just ordinary files and we can set the
2155 * inode flags back. Moreover we discard the pagecache so that
2156 * userspace sees the writes we did bypassing the pagecache. We
2157 * must also discard the blockdev buffers so that we see the
2158 * changes done by userspace on the next quotaon() */
2159 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2160 if (toputinode[cnt]) {
d3be915f 2161 mutex_lock(&dqopt->dqonoff_mutex);
1da177e4
LT		 2162 /* If quota was reenabled in the meantime, we have
2163 * nothing to do */
f55abc0f 2164 if (!sb_has_quota_loaded(sb, cnt)) {
5955102c 2165 inode_lock(toputinode[cnt]);
1da177e4
LT		 2166 toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
2167 S_NOATIME | S_NOQUOTA);
268157ba
JK		 2168 truncate_inode_pages(&toputinode[cnt]->i_data,
2169 0);
5955102c 2170 inode_unlock(toputinode[cnt]);
43d2932d 2171 mark_inode_dirty_sync(toputinode[cnt]);
1da177e4 2172 }
d3be915f 2173 mutex_unlock(&dqopt->dqonoff_mutex);
ca785ec6
JK		 2174 }
2175 if (sb->s_bdev)
2176 invalidate_bdev(sb->s_bdev);
2177put_inodes:
2178 for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2179 if (toputinode[cnt]) {
0ff5af83 2180 /* On remount RO, we keep the inode pointer so that we
f55abc0f
JK		 2181 * can reenable quota on the subsequent remount RW. We
2182 * have to check 'flags' variable and not use sb_has_
2183 * function because another quotaon / quotaoff could
2184 * change global state before we got here. We refuse
2185 * to suspend quotas when there is pending delete on
2186 * the quota file... */
2187 if (!(flags & DQUOT_SUSPENDED))
0ff5af83
JK		 2188 iput(toputinode[cnt]);
2189 else if (!toputinode[cnt]->i_nlink)
2190 ret = -EBUSY;
1da177e4 2191 }
0ff5af83 2192 return ret;
1da177e4 2193}
0f0dd62f 2194EXPORT_SYMBOL(dquot_disable);
1da177e4 2195
287a8095 2196int dquot_quota_off(struct super_block *sb, int type)
f55abc0f 2197{
0f0dd62f
CH		 2198 return dquot_disable(sb, type,
2199 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
f55abc0f 2200}
287a8095 2201EXPORT_SYMBOL(dquot_quota_off);
0f0dd62f 2202
1da177e4
LT		 2203/*
2204 * Turn quotas on on a device
2205 */
2206
f55abc0f
JK		 2207/*
2208 * Helper function to turn quotas on when we already have the inode of
2209 * quota file and no quota information is loaded.
2210 */
2211static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
2212 unsigned int flags)
1da177e4
LT		 2213{
2214 struct quota_format_type *fmt = find_quota_format(format_id);
2215 struct super_block *sb = inode->i_sb;
2216 struct quota_info *dqopt = sb_dqopt(sb);
2217 int error;
2218 int oldflags = -1;
2219
2220 if (!fmt)
2221 return -ESRCH;
2222 if (!S_ISREG(inode->i_mode)) {
2223 error = -EACCES;
2224 goto out_fmt;
2225 }
2226 if (IS_RDONLY(inode)) {
2227 error = -EROFS;
2228 goto out_fmt;
2229 }
847aac64
LX		 2230 if (!sb->s_op->quota_write || !sb->s_op->quota_read ||
2231 (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) {
1da177e4
LT		 2232 error = -EINVAL;
2233 goto out_fmt;
2234 }
f55abc0f
JK		 2235 /* Usage always has to be set... */
2236 if (!(flags & DQUOT_USAGE_ENABLED)) {
2237 error = -EINVAL;
2238 goto out_fmt;
2239 }
1da177e4 2240
ca785ec6 2241 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
ab94c39b
JK		 2242 /* As we bypass the pagecache we must now flush all the
2243 * dirty data and invalidate caches so that kernel sees
2244 * changes from userspace. It is not enough to just flush
2245 * the quota file since if blocksize < pagesize, invalidation
2246 * of the cache could fail because of other unrelated dirty
2247 * data */
2248 sync_filesystem(sb);
ca785ec6
JK		 2249 invalidate_bdev(sb->s_bdev);
2250 }
d3be915f 2251 mutex_lock(&dqopt->dqonoff_mutex);
f55abc0f 2252 if (sb_has_quota_loaded(sb, type)) {
1da177e4
LT		 2253 error = -EBUSY;
2254 goto out_lock;
2255 }
ca785ec6
JK		 2256
2257 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2258 /* We don't want quota and atime on quota files (deadlocks
2259 * possible) Also nobody should write to the file - we use
2260 * special IO operations which ignore the immutable bit. */
5955102c 2261 inode_lock(inode);
268157ba
JK		 2262 oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
2263 S_NOQUOTA);
ca785ec6 2264 inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
5955102c 2265 inode_unlock(inode);
26245c94
JK		 2266 /*
2267 * When S_NOQUOTA is set, remove dquot references as no more
2268 * references can be added
2269 */
9f754758 2270 __dquot_drop(inode);
ca785ec6 2271 }
1da177e4
LT		 2272
2273 error = -EIO;
2274 dqopt->files[type] = igrab(inode);
2275 if (!dqopt->files[type])
2276 goto out_lock;
2277 error = -EINVAL;
2278 if (!fmt->qf_ops->check_quota_file(sb, type))
2279 goto out_file_init;
2280
2281 dqopt->ops[type] = fmt->qf_ops;
2282 dqopt->info[type].dqi_format = fmt;
0ff5af83 2283 dqopt->info[type].dqi_fmt_id = format_id;
1da177e4 2284 INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
d3be915f 2285 mutex_lock(&dqopt->dqio_mutex);
268157ba
JK		 2286 error = dqopt->ops[type]->read_file_info(sb, type);
2287 if (error < 0) {
d3be915f 2288 mutex_unlock(&dqopt->dqio_mutex);
1da177e4
LT		 2289 goto out_file_init;
2290 }
46fe44ce
JK		 2291 if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
2292 dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
d3be915f 2293 mutex_unlock(&dqopt->dqio_mutex);
cc33412f 2294 spin_lock(&dq_state_lock);
f55abc0f 2295 dqopt->flags |= dquot_state_flag(flags, type);
cc33412f 2296 spin_unlock(&dq_state_lock);
1da177e4
LT		 2297
2298 add_dquot_ref(sb, type);
d3be915f 2299 mutex_unlock(&dqopt->dqonoff_mutex);
1da177e4
LT		 2300
2301 return 0;
2302
2303out_file_init:
2304 dqopt->files[type] = NULL;
2305 iput(inode);
2306out_lock:
1da177e4 2307 if (oldflags != -1) {
5955102c 2308 inode_lock(inode);
1da177e4
LT		 2309 /* Set the flags back (in the case of accidental quotaon()
2310 * on a wrong file we don't want to mess up the flags) */
2311 inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
2312 inode->i_flags |= oldflags;
5955102c 2313 inode_unlock(inode);
1da177e4 2314 }
d01730d7 2315 mutex_unlock(&dqopt->dqonoff_mutex);
1da177e4
LT		 2316out_fmt:
2317 put_quota_format(fmt);
2318
2319 return error;
2320}
2321
0ff5af83 2322/* Reenable quotas on remount RW */
0f0dd62f 2323int dquot_resume(struct super_block *sb, int type)
0ff5af83
JK		 2324{
2325 struct quota_info *dqopt = sb_dqopt(sb);
2326 struct inode *inode;
0f0dd62f 2327 int ret = 0, cnt;
f55abc0f 2328 unsigned int flags;
0ff5af83 2329
0f0dd62f
CH		 2330 for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
2331 if (type != -1 && cnt != type)
2332 continue;
2333
2334 mutex_lock(&dqopt->dqonoff_mutex);
2335 if (!sb_has_quota_suspended(sb, cnt)) {
2336 mutex_unlock(&dqopt->dqonoff_mutex);
2337 continue;
2338 }
2339 inode = dqopt->files[cnt];
2340 dqopt->files[cnt] = NULL;
2341 spin_lock(&dq_state_lock);
2342 flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
2343 DQUOT_LIMITS_ENABLED,
2344 cnt);
2345 dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
2346 spin_unlock(&dq_state_lock);
0ff5af83 2347 mutex_unlock(&dqopt->dqonoff_mutex);
0ff5af83 2348
0f0dd62f
CH		 2349 flags = dquot_generic_flag(flags, cnt);
2350 ret = vfs_load_quota_inode(inode, cnt,
2351 dqopt->info[cnt].dqi_fmt_id, flags);
2352 iput(inode);
2353 }
0ff5af83
JK		 2354
2355 return ret;
2356}
0f0dd62f 2357EXPORT_SYMBOL(dquot_resume);
0ff5af83 2358
f00c9e44
JK		 2359int dquot_quota_on(struct super_block *sb, int type, int format_id,
2360 struct path *path)
77e69dac
AV		 2361{
2362 int error = security_quota_on(path->dentry);
2363 if (error)
2364 return error;
2365 /* Quota file not on the same filesystem? */
d8c9584e 2366 if (path->dentry->d_sb != sb)
77e69dac
AV		 2367 error = -EXDEV;
2368 else
dea655c2 2369 error = vfs_load_quota_inode(d_inode(path->dentry), type,
f55abc0f
JK		 2370 format_id, DQUOT_USAGE_ENABLED |
2371 DQUOT_LIMITS_ENABLED);
77e69dac
AV		 2372 return error;
2373}
287a8095 2374EXPORT_SYMBOL(dquot_quota_on);
1da177e4 2375
f55abc0f
JK		 2376/*
2377 * More powerful function for turning on quotas allowing setting
2378 * of individual quota flags
2379 */
287a8095
CH		 2380int dquot_enable(struct inode *inode, int type, int format_id,
2381 unsigned int flags)
f55abc0f
JK		 2382{
2383 int ret = 0;
2384 struct super_block *sb = inode->i_sb;
2385 struct quota_info *dqopt = sb_dqopt(sb);
2386
2387 /* Just unsuspend quotas? */
0f0dd62f
CH		 2388 BUG_ON(flags & DQUOT_SUSPENDED);
2389
f55abc0f
JK		 2390 if (!flags)
2391 return 0;
2392 /* Just updating flags needed? */
2393 if (sb_has_quota_loaded(sb, type)) {
2394 mutex_lock(&dqopt->dqonoff_mutex);
2395 /* Now do a reliable test... */
2396 if (!sb_has_quota_loaded(sb, type)) {
2397 mutex_unlock(&dqopt->dqonoff_mutex);
2398 goto load_quota;
2399 }
2400 if (flags & DQUOT_USAGE_ENABLED &&
2401 sb_has_quota_usage_enabled(sb, type)) {
2402 ret = -EBUSY;
2403 goto out_lock;
2404 }
2405 if (flags & DQUOT_LIMITS_ENABLED &&
2406 sb_has_quota_limits_enabled(sb, type)) {
2407 ret = -EBUSY;
2408 goto out_lock;
2409 }
cc33412f 2410 spin_lock(&dq_state_lock);
f55abc0f 2411 sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
cc33412f 2412 spin_unlock(&dq_state_lock);
f55abc0f
JK		 2413out_lock:
2414 mutex_unlock(&dqopt->dqonoff_mutex);
2415 return ret;
2416 }
2417
2418load_quota:
2419 return vfs_load_quota_inode(inode, type, format_id, flags);
2420}
287a8095 2421EXPORT_SYMBOL(dquot_enable);
f55abc0f 2422
1da177e4
LT		 2423/*
2424 * This function is used when filesystem needs to initialize quotas
2425 * during mount time.
2426 */
287a8095 2427int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
84de856e 2428 int format_id, int type)
1da177e4 2429{
84de856e 2430 struct dentry *dentry;
1da177e4
LT		 2431 int error;
2432
5955102c 2433 inode_lock(d_inode(sb->s_root));
2fa389c5 2434 dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
5955102c 2435 inode_unlock(d_inode(sb->s_root));
84de856e
CH		 2436 if (IS_ERR(dentry))
2437 return PTR_ERR(dentry);
2438
dea655c2 2439 if (d_really_is_negative(dentry)) {
154f484b
JK		 2440 error = -ENOENT;
2441 goto out;
2442 }
2443
1da177e4 2444 error = security_quota_on(dentry);
84de856e 2445 if (!error)
dea655c2 2446 error = vfs_load_quota_inode(d_inode(dentry), type, format_id,
f55abc0f 2447 DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
84de856e 2448
154f484b 2449out:
84de856e
CH		 2450 dput(dentry);
2451 return error;
1da177e4 2452}
287a8095 2453EXPORT_SYMBOL(dquot_quota_on_mount);
b85f4b87 2454
3e2af67e
JK		 2455static int dquot_quota_enable(struct super_block *sb, unsigned int flags)
2456{
2457 int ret;
2458 int type;
2459 struct quota_info *dqopt = sb_dqopt(sb);
2460
2461 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
2462 return -ENOSYS;
2463 /* Accounting cannot be turned on while fs is mounted */
2464 flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT);
2465 if (!flags)
2466 return -EINVAL;
2467 for (type = 0; type < MAXQUOTAS; type++) {
2468 if (!(flags & qtype_enforce_flag(type)))
2469 continue;
2470 /* Can't enforce without accounting */
2471 if (!sb_has_quota_usage_enabled(sb, type))
2472 return -EINVAL;
2473 ret = dquot_enable(dqopt->files[type], type,
2474 dqopt->info[type].dqi_fmt_id,
2475 DQUOT_LIMITS_ENABLED);
2476 if (ret < 0)
2477 goto out_err;
2478 }
2479 return 0;
2480out_err:
2481 /* Backout enforcement enablement we already did */
2482 for (type--; type >= 0; type--) {
2483 if (flags & qtype_enforce_flag(type))
2484 dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
2485 }
2486 /* Error code translation for better compatibility with XFS */
2487 if (ret == -EBUSY)
2488 ret = -EEXIST;
2489 return ret;
2490}
2491
2492static int dquot_quota_disable(struct super_block *sb, unsigned int flags)
2493{
2494 int ret;
2495 int type;
2496 struct quota_info *dqopt = sb_dqopt(sb);
2497
2498 if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
2499 return -ENOSYS;
2500 /*
2501 * We don't support turning off accounting via quotactl. In principle
2502 * quota infrastructure can do this but filesystems don't expect
2503 * userspace to be able to do it.
2504 */
2505 if (flags &
2506 (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT))
2507 return -EOPNOTSUPP;
2508
2509 /* Filter out limits not enabled */
2510 for (type = 0; type < MAXQUOTAS; type++)
2511 if (!sb_has_quota_limits_enabled(sb, type))
2512 flags &= ~qtype_enforce_flag(type);
2513 /* Nothing left? */
2514 if (!flags)
2515 return -EEXIST;
2516 for (type = 0; type < MAXQUOTAS; type++) {
2517 if (flags & qtype_enforce_flag(type)) {
2518 ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
2519 if (ret < 0)
2520 goto out_err;
2521 }
2522 }
2523 return 0;
2524out_err:
2525 /* Backout enforcement disabling we already did */
2526 for (type--; type >= 0; type--) {
2527 if (flags & qtype_enforce_flag(type))
2528 dquot_enable(dqopt->files[type], type,
2529 dqopt->info[type].dqi_fmt_id,
2530 DQUOT_LIMITS_ENABLED);
2531 }
2532 return ret;
2533}
2534
1da177e4 2535/* Generic routine for getting common part of quota structure */
14bf61ff 2536static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di)
1da177e4
LT		 2537{
2538 struct mem_dqblk *dm = &dquot->dq_dqb;
2539
b9b2dd36 2540 memset(di, 0, sizeof(*di));
1da177e4 2541 spin_lock(&dq_data_lock);
14bf61ff
JK		 2542 di->d_spc_hardlimit = dm->dqb_bhardlimit;
2543 di->d_spc_softlimit = dm->dqb_bsoftlimit;
b9b2dd36
CH		 2544 di->d_ino_hardlimit = dm->dqb_ihardlimit;
2545 di->d_ino_softlimit = dm->dqb_isoftlimit;
14bf61ff
JK		 2546 di->d_space = dm->dqb_curspace + dm->dqb_rsvspace;
2547 di->d_ino_count = dm->dqb_curinodes;
2548 di->d_spc_timer = dm->dqb_btime;
2549 di->d_ino_timer = dm->dqb_itime;
1da177e4
LT		 2550 spin_unlock(&dq_data_lock);
2551}
2552
74a8a103 2553int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
14bf61ff 2554 struct qc_dqblk *di)
1da177e4
LT		 2555{
2556 struct dquot *dquot;
2557
aca645a6 2558 dquot = dqget(sb, qid);
6184fc0b
JK		 2559 if (IS_ERR(dquot))
2560 return PTR_ERR(dquot);
1da177e4
LT		 2561 do_get_dqblk(dquot, di);
2562 dqput(dquot);
cc33412f 2563
1da177e4
LT		 2564 return 0;
2565}
287a8095 2566EXPORT_SYMBOL(dquot_get_dqblk);
1da177e4 2567
14bf61ff
JK		 2568#define VFS_QC_MASK \
2569 (QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \
2570 QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \
2571 QC_SPC_TIMER | QC_INO_TIMER)
c472b432 2572
1da177e4 2573/* Generic routine for setting common part of quota structure */
14bf61ff 2574static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di)
1da177e4
LT		 2575{
2576 struct mem_dqblk *dm = &dquot->dq_dqb;
2577 int check_blim = 0, check_ilim = 0;
4c376dca 2578 struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
338bf9af 2579
14bf61ff 2580 if (di->d_fieldmask & ~VFS_QC_MASK)
c472b432
CH		 2581 return -EINVAL;
2582
14bf61ff 2583 if (((di->d_fieldmask & QC_SPC_SOFT) &&
b10a0819 2584 di->d_spc_softlimit > dqi->dqi_max_spc_limit) ||
14bf61ff 2585 ((di->d_fieldmask & QC_SPC_HARD) &&
b10a0819 2586 di->d_spc_hardlimit > dqi->dqi_max_spc_limit) ||
14bf61ff 2587 ((di->d_fieldmask & QC_INO_SOFT) &&
b10a0819 2588 (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) ||
14bf61ff 2589 ((di->d_fieldmask & QC_INO_HARD) &&
b10a0819 2590 (di->d_ino_hardlimit > dqi->dqi_max_ino_limit)))
338bf9af 2591 return -ERANGE;
1da177e4
LT		 2592
2593 spin_lock(&dq_data_lock);
14bf61ff
JK		 2594 if (di->d_fieldmask & QC_SPACE) {
2595 dm->dqb_curspace = di->d_space - dm->dqb_rsvspace;
1da177e4 2596 check_blim = 1;
08261673 2597 set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
1da177e4 2598 }
c472b432 2599
14bf61ff
JK		 2600 if (di->d_fieldmask & QC_SPC_SOFT)
2601 dm->dqb_bsoftlimit = di->d_spc_softlimit;
2602 if (di->d_fieldmask & QC_SPC_HARD)
2603 dm->dqb_bhardlimit = di->d_spc_hardlimit;
2604 if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) {
1da177e4 2605 check_blim = 1;
08261673 2606 set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
1da177e4 2607 }
c472b432 2608
14bf61ff
JK		 2609 if (di->d_fieldmask & QC_INO_COUNT) {
2610 dm->dqb_curinodes = di->d_ino_count;
1da177e4 2611 check_ilim = 1;
08261673 2612 set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
1da177e4 2613 }
c472b432 2614
14bf61ff 2615 if (di->d_fieldmask & QC_INO_SOFT)
c472b432 2616 dm->dqb_isoftlimit = di->d_ino_softlimit;
14bf61ff 2617 if (di->d_fieldmask & QC_INO_HARD)
c472b432 2618 dm->dqb_ihardlimit = di->d_ino_hardlimit;
14bf61ff 2619 if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) {
1da177e4 2620 check_ilim = 1;
08261673 2621 set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
1da177e4 2622 }
c472b432 2623
14bf61ff
JK		 2624 if (di->d_fieldmask & QC_SPC_TIMER) {
2625 dm->dqb_btime = di->d_spc_timer;
e04a88a9 2626 check_blim = 1;
08261673 2627 set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
4d59bce4 2628 }
c472b432 2629
14bf61ff
JK		 2630 if (di->d_fieldmask & QC_INO_TIMER) {
2631 dm->dqb_itime = di->d_ino_timer;
e04a88a9 2632 check_ilim = 1;
08261673 2633 set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
4d59bce4 2634 }
1da177e4
LT		 2635
2636 if (check_blim) {
268157ba
JK		 2637 if (!dm->dqb_bsoftlimit ||
2638 dm->dqb_curspace < dm->dqb_bsoftlimit) {
1da177e4
LT		 2639 dm->dqb_btime = 0;
2640 clear_bit(DQ_BLKS_B, &dquot->dq_flags);
14bf61ff 2641 } else if (!(di->d_fieldmask & QC_SPC_TIMER))
268157ba 2642 /* Set grace only if user hasn't provided his own... */
338bf9af 2643 dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
1da177e4
LT		 2644 }
2645 if (check_ilim) {
268157ba
JK		 2646 if (!dm->dqb_isoftlimit ||
2647 dm->dqb_curinodes < dm->dqb_isoftlimit) {
1da177e4
LT		 2648 dm->dqb_itime = 0;
2649 clear_bit(DQ_INODES_B, &dquot->dq_flags);
14bf61ff 2650 } else if (!(di->d_fieldmask & QC_INO_TIMER))
268157ba 2651 /* Set grace only if user hasn't provided his own... */
338bf9af 2652 dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
1da177e4 2653 }
268157ba
JK		 2654 if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
2655 dm->dqb_isoftlimit)
1da177e4
LT		 2656 clear_bit(DQ_FAKE_B, &dquot->dq_flags);
2657 else
2658 set_bit(DQ_FAKE_B, &dquot->dq_flags);
2659 spin_unlock(&dq_data_lock);
2660 mark_dquot_dirty(dquot);
338bf9af
AP		 2661
2662 return 0;
1da177e4
LT		 2663}
2664
74a8a103 2665int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
14bf61ff 2666 struct qc_dqblk *di)
1da177e4
LT		 2667{
2668 struct dquot *dquot;
338bf9af 2669 int rc;
1da177e4 2670
aca645a6 2671 dquot = dqget(sb, qid);
6184fc0b
JK		 2672 if (IS_ERR(dquot)) {
2673 rc = PTR_ERR(dquot);
f55abc0f 2674 goto out;
1da177e4 2675 }
338bf9af 2676 rc = do_set_dqblk(dquot, di);
1da177e4 2677 dqput(dquot);
f55abc0f 2678out:
338bf9af 2679 return rc;
1da177e4 2680}
287a8095 2681EXPORT_SYMBOL(dquot_set_dqblk);
1da177e4
LT		 2682
2683/* Generic routine for getting common part of quota file information */
0a240339 2684int dquot_get_state(struct super_block *sb, struct qc_state *state)
1da177e4
LT		 2685{
2686 struct mem_dqinfo *mi;
0a240339
JK		 2687 struct qc_type_state *tstate;
2688 struct quota_info *dqopt = sb_dqopt(sb);
2689 int type;
1da177e4 2690
d3be915f 2691 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
0a240339
JK		 2692 memset(state, 0, sizeof(*state));
2693 for (type = 0; type < MAXQUOTAS; type++) {
2694 if (!sb_has_quota_active(sb, type))
2695 continue;
2696 tstate = state->s_state + type;
2697 mi = sb_dqopt(sb)->info + type;
2698 tstate->flags = QCI_ACCT_ENABLED;
2699 spin_lock(&dq_data_lock);
2700 if (mi->dqi_flags & DQF_SYS_FILE)
2701 tstate->flags |= QCI_SYSFILE;
2702 if (mi->dqi_flags & DQF_ROOT_SQUASH)
2703 tstate->flags |= QCI_ROOT_SQUASH;
2704 if (sb_has_quota_limits_enabled(sb, type))
2705 tstate->flags |= QCI_LIMITS_ENFORCED;
2706 tstate->spc_timelimit = mi->dqi_bgrace;
2707 tstate->ino_timelimit = mi->dqi_igrace;
2708 tstate->ino = dqopt->files[type]->i_ino;
2709 tstate->blocks = dqopt->files[type]->i_blocks;
2710 tstate->nextents = 1; /* We don't know... */
2711 spin_unlock(&dq_data_lock);
1da177e4 2712 }
d3be915f 2713 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
1da177e4
LT		 2714 return 0;
2715}
0a240339 2716EXPORT_SYMBOL(dquot_get_state);
1da177e4
LT		 2717
2718/* Generic routine for setting common part of quota file information */
5eacb2ac 2719int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii)
1da177e4
LT		 2720{
2721 struct mem_dqinfo *mi;
f55abc0f 2722 int err = 0;
1da177e4 2723
5eacb2ac
JK		 2724 if ((ii->i_fieldmask & QC_WARNS_MASK) ||
2725 (ii->i_fieldmask & QC_RT_SPC_TIMER))
2726 return -EINVAL;
d3be915f 2727 mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
f55abc0f
JK		 2728 if (!sb_has_quota_active(sb, type)) {
2729 err = -ESRCH;
2730 goto out;
1da177e4
LT		 2731 }
2732 mi = sb_dqopt(sb)->info + type;
5eacb2ac
JK		 2733 if (ii->i_fieldmask & QC_FLAGS) {
2734 if ((ii->i_flags & QCI_ROOT_SQUASH &&
ca6cb091
JK		 2735 mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD)) {
2736 err = -EINVAL;
2737 goto out;
2738 }
2739 }
1da177e4 2740 spin_lock(&dq_data_lock);
5eacb2ac
JK		 2741 if (ii->i_fieldmask & QC_SPC_TIMER)
2742 mi->dqi_bgrace = ii->i_spc_timelimit;
2743 if (ii->i_fieldmask & QC_INO_TIMER)
2744 mi->dqi_igrace = ii->i_ino_timelimit;
2745 if (ii->i_fieldmask & QC_FLAGS) {
2746 if (ii->i_flags & QCI_ROOT_SQUASH)
2747 mi->dqi_flags |= DQF_ROOT_SQUASH;
2748 else
2749 mi->dqi_flags &= ~DQF_ROOT_SQUASH;
2750 }
1da177e4
LT		 2751 spin_unlock(&dq_data_lock);
2752 mark_info_dirty(sb, type);
2753 /* Force write to disk */
2754 sb->dq_op->write_info(sb, type);
f55abc0f 2755out:
d3be915f 2756 mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
f55abc0f 2757 return err;
1da177e4 2758}
287a8095 2759EXPORT_SYMBOL(dquot_set_dqinfo);
1da177e4 2760
287a8095
CH		 2761const struct quotactl_ops dquot_quotactl_ops = {
2762 .quota_on = dquot_quota_on,
2763 .quota_off = dquot_quota_off,
2764 .quota_sync = dquot_quota_sync,
0a240339 2765 .get_state = dquot_get_state,
287a8095
CH		 2766 .set_info = dquot_set_dqinfo,
2767 .get_dqblk = dquot_get_dqblk,
2768 .set_dqblk = dquot_set_dqblk
1da177e4 2769};
287a8095 2770EXPORT_SYMBOL(dquot_quotactl_ops);
dde95888 2771
3e2af67e
JK		 2772const struct quotactl_ops dquot_quotactl_sysfile_ops = {
2773 .quota_enable = dquot_quota_enable,
2774 .quota_disable = dquot_quota_disable,
2775 .quota_sync = dquot_quota_sync,
0a240339 2776 .get_state = dquot_get_state,
3e2af67e
JK		 2777 .set_info = dquot_set_dqinfo,
2778 .get_dqblk = dquot_get_dqblk,
2779 .set_dqblk = dquot_set_dqblk
2780};
2781EXPORT_SYMBOL(dquot_quotactl_sysfile_ops);
2782
dde95888
DM		 2783static int do_proc_dqstats(struct ctl_table *table, int write,
2784 void __user *buffer, size_t *lenp, loff_t *ppos)
2785{
dde95888 2786 unsigned int type = (int *)table->data - dqstats.stat;
f32764bd
DM		 2787
2788 /* Update global table */
2789 dqstats.stat[type] =
2790 percpu_counter_sum_positive(&dqstats.counter[type]);
dde95888
DM		 2791 return proc_dointvec(table, write, buffer, lenp, ppos);
2792}
2793
e628753b 2794static struct ctl_table fs_dqstats_table[] = {
1da177e4 2795 {
1da177e4 2796 .procname = "lookups",
dde95888 2797 .data = &dqstats.stat[DQST_LOOKUPS],
1da177e4
LT		 2798 .maxlen = sizeof(int),
2799 .mode = 0444,
dde95888 2800 .proc_handler = do_proc_dqstats,
1da177e4
LT		 2801 },
2802 {
1da177e4 2803 .procname = "drops",
dde95888 2804 .data = &dqstats.stat[DQST_DROPS],
1da177e4
LT		 2805 .maxlen = sizeof(int),
2806 .mode = 0444,
dde95888 2807 .proc_handler = do_proc_dqstats,
1da177e4
LT		 2808 },
2809 {
1da177e4 2810 .procname = "reads",
dde95888 2811 .data = &dqstats.stat[DQST_READS],
1da177e4
LT		 2812 .maxlen = sizeof(int),
2813 .mode = 0444,
dde95888 2814 .proc_handler = do_proc_dqstats,
1da177e4
LT		 2815 },
2816 {
1da177e4 2817 .procname = "writes",
dde95888 2818 .data = &dqstats.stat[DQST_WRITES],
1da177e4
LT		 2819 .maxlen = sizeof(int),
2820 .mode = 0444,
dde95888 2821 .proc_handler = do_proc_dqstats,
1da177e4
LT		 2822 },
2823 {
1da177e4 2824 .procname = "cache_hits",
dde95888 2825 .data = &dqstats.stat[DQST_CACHE_HITS],
1da177e4
LT		 2826 .maxlen = sizeof(int),
2827 .mode = 0444,
dde95888 2828 .proc_handler = do_proc_dqstats,
1da177e4
LT		 2829 },
2830 {
1da177e4 2831 .procname = "allocated_dquots",
dde95888 2832 .data = &dqstats.stat[DQST_ALLOC_DQUOTS],
1da177e4
LT		 2833 .maxlen = sizeof(int),
2834 .mode = 0444,
dde95888 2835 .proc_handler = do_proc_dqstats,
1da177e4
LT		 2836 },
2837 {
1da177e4 2838 .procname = "free_dquots",
dde95888 2839 .data = &dqstats.stat[DQST_FREE_DQUOTS],
1da177e4
LT		 2840 .maxlen = sizeof(int),
2841 .mode = 0444,
dde95888 2842 .proc_handler = do_proc_dqstats,
1da177e4
LT		 2843 },
2844 {
1da177e4 2845 .procname = "syncs",
dde95888 2846 .data = &dqstats.stat[DQST_SYNCS],
1da177e4
LT		 2847 .maxlen = sizeof(int),
2848 .mode = 0444,
dde95888 2849 .proc_handler = do_proc_dqstats,
1da177e4 2850 },
8e893469 2851#ifdef CONFIG_PRINT_QUOTA_WARNING
1da177e4 2852 {
1da177e4
LT		 2853 .procname = "warnings",
2854 .data = &flag_print_warnings,
2855 .maxlen = sizeof(int),
2856 .mode = 0644,
6d456111 2857 .proc_handler = proc_dointvec,
1da177e4 2858 },
8e893469 2859#endif
ab09203e 2860 { },
1da177e4
LT		 2861};
2862
e628753b 2863static struct ctl_table fs_table[] = {
1da177e4 2864 {
1da177e4
LT		 2865 .procname = "quota",
2866 .mode = 0555,
2867 .child = fs_dqstats_table,
2868 },
ab09203e 2869 { },
1da177e4
LT		 2870};
2871
e628753b 2872static struct ctl_table sys_table[] = {
1da177e4 2873 {
1da177e4
LT		 2874 .procname = "fs",
2875 .mode = 0555,
2876 .child = fs_table,
2877 },
ab09203e 2878 { },
1da177e4
LT		 2879};
2880
2881static int __init dquot_init(void)
2882{
f32764bd 2883 int i, ret;
1da177e4
LT		 2884 unsigned long nr_hash, order;
2885
2886 printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);
2887
0b4d4147 2888 register_sysctl_table(sys_table);
1da177e4 2889
20c2df83 2890 dquot_cachep = kmem_cache_create("dquot",
1da177e4 2891 sizeof(struct dquot), sizeof(unsigned long) * 4,
fffb60f9
PJ		 2892 (SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
2893 SLAB_MEM_SPREAD|SLAB_PANIC),
20c2df83 2894 NULL);
1da177e4
LT		 2895
2896 order = 0;
2897 dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
2898 if (!dquot_hash)
2899 panic("Cannot create dquot hash table");
2900
f32764bd 2901 for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
908c7f19 2902 ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL);
f32764bd
DM		 2903 if (ret)
2904 panic("Cannot create dquot stat counters");
2905 }
dde95888 2906
1da177e4
LT		 2907 /* Find power-of-two hlist_heads which can fit into allocation */
2908 nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
2909 dq_hash_bits = 0;
2910 do {
2911 dq_hash_bits++;
2912 } while (nr_hash >> dq_hash_bits);
2913 dq_hash_bits--;
2914
2915 nr_hash = 1UL << dq_hash_bits;
2916 dq_hash_mask = nr_hash - 1;
2917 for (i = 0; i < nr_hash; i++)
2918 INIT_HLIST_HEAD(dquot_hash + i);
2919
19858e7b
AB		 2920 pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld,"
2921 " %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order));
1da177e4 2922
8e1f936b 2923 register_shrinker(&dqcache_shrinker);
1da177e4
LT		 2924
2925 return 0;
2926}
331221fa 2927fs_initcall(dquot_init);
Linux kernel - Deliverables
This page took 0.97429 seconds and 5 git commands to generate.