dquot.c 76.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
/*
 * Implementation of the diskquota system for the LINUX operating system. QUOTA
 * is implemented using the BSD system call interface as the means of
 * communication with the user level. This file contains the generic routines
 * called by the different filesystems on allocation of an inode or block.
 * These routines take care of the administration needed to have a consistent
 * diskquota tracking system. The ideas of both user and group quotas are based
 * on the Melbourne quota system as used on BSD derived systems. The internal
 * implementation is based on one of the several variants of the LINUX
 * inode-subsystem with added complexity of the diskquota system.
 * 
 * Author:	Marco van Wieringen <mvw@planets.elm.net>
 *
 * Fixes:   Dmitry Gorodchanin <pgmdsg@ibi.com>, 11 Feb 96
 *
 *		Revised list management to avoid races
 *		-- Bill Hawes, <whawes@star.net>, 9/98
 *
 *		Fixed races in dquot_transfer(), dqget() and dquot_alloc_...().
 *		As the consequence the locking was moved from dquot_decr_...(),
 *		dquot_incr_...() to calling functions.
 *		invalidate_dquots() now writes modified dquots.
 *		Serialized quota_off() and quota_on() for mount point.
 *		Fixed a few bugs in grow_dquots().
 *		Fixed deadlock in write_dquot() - we no longer account quotas on
 *		quota files
 *		remove_dquot_ref() moved to inode.c - it now traverses through inodes
 *		add_dquot_ref() restarts after blocking
 *		Added check for bogus uid and fixed check for group in quotactl.
 *		Jan Kara, <jack@suse.cz>, sponsored by SuSE CR, 10-11/99
 *
 *		Used struct list_head instead of own list struct
 *		Invalidation of referenced dquots is no longer possible
 *		Improved free_dquots list management
 *		Quota and i_blocks are now updated in one place to avoid races
 *		Warnings are now delayed so we won't block in critical section
 *		Write updated not to require dquot lock
 *		Jan Kara, <jack@suse.cz>, 9/2000
 *
 *		Added dynamic quota structure allocation
 *		Jan Kara <jack@suse.cz> 12/2000
 *
 *		Rewritten quota interface. Implemented new quota format and
 *		formats registering.
 *		Jan Kara, <jack@suse.cz>, 2001,2002
 *
 *		New SMP locking.
 *		Jan Kara, <jack@suse.cz>, 10/2002
 *
 *		Added journalled quota support, fix lock inversion problems
 *		Jan Kara, <jack@suse.cz>, 2003,2004
 *
 * (C) Copyright 1994 - 1997 Marco van Wieringen 
 */

#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/mm.h>
#include <linux/time.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/tty.h>
#include <linux/file.h>
#include <linux/slab.h>
#include <linux/sysctl.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/security.h>
A
Al Viro 已提交
74
#include <linux/sched.h>
75
#include <linux/cred.h>
L
Linus Torvalds 已提交
76 77
#include <linux/kmod.h>
#include <linux/namei.h>
78
#include <linux/capability.h>
A
Adrian Bunk 已提交
79
#include <linux/quotaops.h>
80
#include "../internal.h" /* ugh */
L
Linus Torvalds 已提交
81

82
#include <linux/uaccess.h>
L
Linus Torvalds 已提交
83 84

/*
J
Jan Kara 已提交
85
 * There are three quota SMP locks. dq_list_lock protects all lists with quotas
86
 * and quota formats.
J
Jan Kara 已提交
87 88
 * dq_data_lock protects data from dq_dqb and also mem_dqinfo structures and
 * also guards consistency of dquot->dq_dqb with inode->i_blocks, i_bytes.
L
Linus Torvalds 已提交
89
 * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly
J
Jan Kara 已提交
90 91 92
 * in inode_add_bytes() and inode_sub_bytes(). dq_state_lock protects
 * modifications of quota state (on quotaon and quotaoff) and readers who care
 * about latest values take it as well.
L
Linus Torvalds 已提交
93
 *
J
Jan Kara 已提交
94 95
 * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock,
 *   dq_list_lock > dq_state_lock
L
Linus Torvalds 已提交
96 97 98 99
 *
 * Note that some things (eg. sb pointer, type, id) doesn't change during
 * the life of the dquot structure and so needn't to be protected by a lock
 *
N
Niu Yawei 已提交
100 101 102 103 104 105
 * Operation accessing dquots via inode pointers are protected by dquot_srcu.
 * Operation of reading pointer needs srcu_read_lock(&dquot_srcu), and
 * synchronize_srcu(&dquot_srcu) is called after clearing pointers from
 * inode and before dropping dquot references to avoid use of dquots after
 * they are freed. dq_data_lock is used to serialize the pointer setting and
 * clearing operations.
J
Jan Kara 已提交
106 107
 * Special care needs to be taken about S_NOQUOTA inode flag (marking that
 * inode is a quota file). Functions adding pointers from inode to dquots have
N
Niu Yawei 已提交
108 109
 * to check this flag under dq_data_lock and then (if S_NOQUOTA is not set) they
 * have to do all pointer modifications before dropping dq_data_lock. This makes
J
Jan Kara 已提交
110 111
 * sure they cannot race with quotaon which first sets S_NOQUOTA flag and
 * then drops all pointers to dquots from an inode.
L
Linus Torvalds 已提交
112
 *
113 114 115 116 117
 * Each dquot has its dq_lock mutex.  Dquot is locked when it is being read to
 * memory (or space for it is being allocated) on the first dqget(), when it is
 * being written out, and when it is being released on the last dqput(). The
 * allocation and release operations are serialized by the dq_lock and by
 * checking the use count in dquot_release().
L
Linus Torvalds 已提交
118 119
 *
 * Lock ordering (including related VFS locks) is the following:
J
Jan Kara 已提交
120
 *   s_umount > i_mutex > journal_lock > dquot->dq_lock > dqio_sem
L
Linus Torvalds 已提交
121 122
 */

123 124 125
static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_list_lock);
static __cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_state_lock);
__cacheline_aligned_in_smp DEFINE_SPINLOCK(dq_data_lock);
126
EXPORT_SYMBOL(dq_data_lock);
N
Niu Yawei 已提交
127
DEFINE_STATIC_SRCU(dquot_srcu);
L
Linus Torvalds 已提交
128

129 130
static DECLARE_WAIT_QUEUE_HEAD(dquot_ref_wq);

131
void __quota_error(struct super_block *sb, const char *func,
132
		   const char *fmt, ...)
133 134
{
	if (printk_ratelimit()) {
135 136 137
		va_list args;
		struct va_format vaf;

138
		va_start(args, fmt);
139 140 141 142 143 144 145

		vaf.fmt = fmt;
		vaf.va = &args;

		printk(KERN_ERR "Quota error (device %s): %s: %pV\n",
		       sb->s_id, func, &vaf);

146 147 148 149 150
		va_end(args);
	}
}
EXPORT_SYMBOL(__quota_error);

151
#if defined(CONFIG_QUOTA_DEBUG) || defined(CONFIG_PRINT_QUOTA_WARNING)
L
Linus Torvalds 已提交
152
static char *quotatypes[] = INITQFNAMES;
153
#endif
L
Linus Torvalds 已提交
154 155 156 157
static struct quota_format_type *quota_formats;	/* List of registered formats */
static struct quota_module_name module_names[] = INIT_QUOTA_MODULE_NAMES;

/* SLAB cache for dquot structures */
158
static struct kmem_cache *dquot_cachep;
L
Linus Torvalds 已提交
159 160 161 162 163 164 165 166 167

int register_quota_format(struct quota_format_type *fmt)
{
	spin_lock(&dq_list_lock);
	fmt->qf_next = quota_formats;
	quota_formats = fmt;
	spin_unlock(&dq_list_lock);
	return 0;
}
168
EXPORT_SYMBOL(register_quota_format);
L
Linus Torvalds 已提交
169 170 171 172 173 174

void unregister_quota_format(struct quota_format_type *fmt)
{
	struct quota_format_type **actqf;

	spin_lock(&dq_list_lock);
J
Jan Kara 已提交
175 176 177
	for (actqf = &quota_formats; *actqf && *actqf != fmt;
	     actqf = &(*actqf)->qf_next)
		;
L
Linus Torvalds 已提交
178 179 180 181
	if (*actqf)
		*actqf = (*actqf)->qf_next;
	spin_unlock(&dq_list_lock);
}
182
EXPORT_SYMBOL(unregister_quota_format);
L
Linus Torvalds 已提交
183 184 185 186 187 188

static struct quota_format_type *find_quota_format(int id)
{
	struct quota_format_type *actqf;

	spin_lock(&dq_list_lock);
J
Jan Kara 已提交
189 190 191
	for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
	     actqf = actqf->qf_next)
		;
L
Linus Torvalds 已提交
192 193 194 195 196
	if (!actqf || !try_module_get(actqf->qf_owner)) {
		int qm;

		spin_unlock(&dq_list_lock);
		
J
Jan Kara 已提交
197 198 199 200 201
		for (qm = 0; module_names[qm].qm_fmt_id &&
			     module_names[qm].qm_fmt_id != id; qm++)
			;
		if (!module_names[qm].qm_fmt_id ||
		    request_module(module_names[qm].qm_mod_name))
L
Linus Torvalds 已提交
202 203 204
			return NULL;

		spin_lock(&dq_list_lock);
J
Jan Kara 已提交
205 206 207
		for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
		     actqf = actqf->qf_next)
			;
L
Linus Torvalds 已提交
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245
		if (actqf && !try_module_get(actqf->qf_owner))
			actqf = NULL;
	}
	spin_unlock(&dq_list_lock);
	return actqf;
}

static void put_quota_format(struct quota_format_type *fmt)
{
	module_put(fmt->qf_owner);
}

/*
 * Dquot List Management:
 * The quota code uses three lists for dquot management: the inuse_list,
 * free_dquots, and dquot_hash[] array. A single dquot structure may be
 * on all three lists, depending on its current state.
 *
 * All dquots are placed to the end of inuse_list when first created, and this
 * list is used for invalidate operation, which must look at every dquot.
 *
 * Unused dquots (dq_count == 0) are added to the free_dquots list when freed,
 * and this list is searched whenever we need an available dquot.  Dquots are
 * removed from the list as soon as they are used again, and
 * dqstats.free_dquots gives the number of dquots on the list. When
 * dquot is invalidated it's completely released from memory.
 *
 * Dquots with a specific identity (device, type and id) are placed on
 * one of the dquot_hash[] hash chains. The provides an efficient search
 * mechanism to locate a specific dquot.
 */

static LIST_HEAD(inuse_list);
static LIST_HEAD(free_dquots);
static unsigned int dq_hash_bits, dq_hash_mask;
static struct hlist_head *dquot_hash;

struct dqstats dqstats;
246
EXPORT_SYMBOL(dqstats);
L
Linus Torvalds 已提交
247

248
static qsize_t inode_get_rsv_space(struct inode *inode);
249
static int __dquot_initialize(struct inode *inode, int type);
250

L
Linus Torvalds 已提交
251
static inline unsigned int
E
Eric W. Biederman 已提交
252
hashfn(const struct super_block *sb, struct kqid qid)
L
Linus Torvalds 已提交
253
{
E
Eric W. Biederman 已提交
254 255
	unsigned int id = from_kqid(&init_user_ns, qid);
	int type = qid.type;
L
Linus Torvalds 已提交
256 257 258 259 260 261 262 263 264 265 266
	unsigned long tmp;

	tmp = (((unsigned long)sb>>L1_CACHE_SHIFT) ^ id) * (MAXQUOTAS - type);
	return (tmp + (tmp >> dq_hash_bits)) & dq_hash_mask;
}

/*
 * Following list functions expect dq_list_lock to be held
 */
static inline void insert_dquot_hash(struct dquot *dquot)
{
J
Jan Kara 已提交
267
	struct hlist_head *head;
E
Eric W. Biederman 已提交
268
	head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id);
L
Linus Torvalds 已提交
269 270 271 272 273 274 275 276
	hlist_add_head(&dquot->dq_hash, head);
}

static inline void remove_dquot_hash(struct dquot *dquot)
{
	hlist_del_init(&dquot->dq_hash);
}

J
Jan Kara 已提交
277
static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
E
Eric W. Biederman 已提交
278
				struct kqid qid)
L
Linus Torvalds 已提交
279 280 281 282 283 284
{
	struct hlist_node *node;
	struct dquot *dquot;

	hlist_for_each (node, dquot_hash+hashent) {
		dquot = hlist_entry(node, struct dquot, dq_hash);
285
		if (dquot->dq_sb == sb && qid_eq(dquot->dq_id, qid))
L
Linus Torvalds 已提交
286 287
			return dquot;
	}
J
Jan Kara 已提交
288
	return NULL;
L
Linus Torvalds 已提交
289 290 291 292 293
}

/* Add a dquot to the tail of the free list */
static inline void put_dquot_last(struct dquot *dquot)
{
294
	list_add_tail(&dquot->dq_free, &free_dquots);
295
	dqstats_inc(DQST_FREE_DQUOTS);
L
Linus Torvalds 已提交
296 297 298 299 300 301 302
}

static inline void remove_free_dquot(struct dquot *dquot)
{
	if (list_empty(&dquot->dq_free))
		return;
	list_del_init(&dquot->dq_free);
303
	dqstats_dec(DQST_FREE_DQUOTS);
L
Linus Torvalds 已提交
304 305 306 307 308 309
}

static inline void put_inuse(struct dquot *dquot)
{
	/* We add to the back of inuse list so we don't have to restart
	 * when traversing this list and we block */
310
	list_add_tail(&dquot->dq_inuse, &inuse_list);
311
	dqstats_inc(DQST_ALLOC_DQUOTS);
L
Linus Torvalds 已提交
312 313 314 315
}

static inline void remove_inuse(struct dquot *dquot)
{
316
	dqstats_dec(DQST_ALLOC_DQUOTS);
L
Linus Torvalds 已提交
317 318 319 320 321 322 323 324
	list_del(&dquot->dq_inuse);
}
/*
 * End of list functions needing dq_list_lock
 */

static void wait_on_dquot(struct dquot *dquot)
{
I
Ingo Molnar 已提交
325 326
	mutex_lock(&dquot->dq_lock);
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
327 328
}

J
Jan Kara 已提交
329 330 331 332 333 334 335 336 337
static inline int dquot_dirty(struct dquot *dquot)
{
	return test_bit(DQ_MOD_B, &dquot->dq_flags);
}

static inline int mark_dquot_dirty(struct dquot *dquot)
{
	return dquot->dq_sb->dq_op->mark_dirty(dquot);
}
L
Linus Torvalds 已提交
338

339
/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
L
Linus Torvalds 已提交
340 341
int dquot_mark_dquot_dirty(struct dquot *dquot)
{
342 343
	int ret = 1;

J
Jan Kara 已提交
344 345 346
	if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
		return 0;

347 348 349
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
		return test_and_set_bit(DQ_MOD_B, &dquot->dq_flags);

350 351 352 353
	/* If quota is dirty already, we don't have to acquire dq_list_lock */
	if (test_bit(DQ_MOD_B, &dquot->dq_flags))
		return 1;

L
Linus Torvalds 已提交
354
	spin_lock(&dq_list_lock);
355
	if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
L
Linus Torvalds 已提交
356
		list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
357
				info[dquot->dq_id.type].dqi_dirty_list);
358 359
		ret = 0;
	}
L
Linus Torvalds 已提交
360
	spin_unlock(&dq_list_lock);
361
	return ret;
L
Linus Torvalds 已提交
362
}
363
EXPORT_SYMBOL(dquot_mark_dquot_dirty);
L
Linus Torvalds 已提交
364

365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388
/* Dirtify all the dquots - this can block when journalling */
static inline int mark_all_dquot_dirty(struct dquot * const *dquot)
{
	int ret, err, cnt;

	ret = err = 0;
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (dquot[cnt])
			/* Even in case of error we have to continue */
			ret = mark_dquot_dirty(dquot[cnt]);
		if (!err)
			err = ret;
	}
	return err;
}

static inline void dqput_all(struct dquot **dquot)
{
	unsigned int cnt;

	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
		dqput(dquot[cnt]);
}

L
Linus Torvalds 已提交
389 390
static inline int clear_dquot_dirty(struct dquot *dquot)
{
391 392 393
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NOLIST_DIRTY)
		return test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags);

394 395 396
	spin_lock(&dq_list_lock);
	if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags)) {
		spin_unlock(&dq_list_lock);
L
Linus Torvalds 已提交
397
		return 0;
398
	}
L
Linus Torvalds 已提交
399
	list_del_init(&dquot->dq_dirty);
400
	spin_unlock(&dq_list_lock);
L
Linus Torvalds 已提交
401 402 403 404 405
	return 1;
}

void mark_info_dirty(struct super_block *sb, int type)
{
406 407 408
	spin_lock(&dq_data_lock);
	sb_dqopt(sb)->info[type].dqi_flags |= DQF_INFO_DIRTY;
	spin_unlock(&dq_data_lock);
L
Linus Torvalds 已提交
409 410 411 412 413 414 415 416 417 418 419 420
}
EXPORT_SYMBOL(mark_info_dirty);

/*
 *	Read dquot from disk and alloc space for it
 */

int dquot_acquire(struct dquot *dquot)
{
	int ret = 0, ret2 = 0;
	struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);

I
Ingo Molnar 已提交
421
	mutex_lock(&dquot->dq_lock);
422
	if (!test_bit(DQ_READ_B, &dquot->dq_flags))
423
		ret = dqopt->ops[dquot->dq_id.type]->read_dqblk(dquot);
L
Linus Torvalds 已提交
424 425
	if (ret < 0)
		goto out_iolock;
426 427
	/* Make sure flags update is visible after dquot has been filled */
	smp_mb__before_atomic();
L
Linus Torvalds 已提交
428 429 430
	set_bit(DQ_READ_B, &dquot->dq_flags);
	/* Instantiate dquot if needed */
	if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
431
		ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
L
Linus Torvalds 已提交
432
		/* Write the info if needed */
433 434 435
		if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
			ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
					dquot->dq_sb, dquot->dq_id.type);
J
Jan Kara 已提交
436
		}
L
Linus Torvalds 已提交
437 438 439 440 441 442 443
		if (ret < 0)
			goto out_iolock;
		if (ret2 < 0) {
			ret = ret2;
			goto out_iolock;
		}
	}
444 445 446 447 448
	/*
	 * Make sure flags update is visible after on-disk struct has been
	 * allocated. Paired with smp_rmb() in dqget().
	 */
	smp_mb__before_atomic();
L
Linus Torvalds 已提交
449 450
	set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
out_iolock:
I
Ingo Molnar 已提交
451
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
452 453
	return ret;
}
454
EXPORT_SYMBOL(dquot_acquire);
L
Linus Torvalds 已提交
455 456 457 458 459 460

/*
 *	Write dquot to disk
 */
int dquot_commit(struct dquot *dquot)
{
461
	int ret = 0;
L
Linus Torvalds 已提交
462 463
	struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);

464
	mutex_lock(&dquot->dq_lock);
465
	if (!clear_dquot_dirty(dquot))
466
		goto out_lock;
L
Linus Torvalds 已提交
467 468
	/* Inactive dquot can be only if there was error during read/init
	 * => we have better not writing it */
469
	if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
470
		ret = dqopt->ops[dquot->dq_id.type]->commit_dqblk(dquot);
471
	else
472
		ret = -EIO;
473 474
out_lock:
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
475 476
	return ret;
}
477
EXPORT_SYMBOL(dquot_commit);
L
Linus Torvalds 已提交
478 479 480 481 482 483 484 485 486

/*
 *	Release dquot
 */
int dquot_release(struct dquot *dquot)
{
	int ret = 0, ret2 = 0;
	struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);

I
Ingo Molnar 已提交
487
	mutex_lock(&dquot->dq_lock);
L
Linus Torvalds 已提交
488 489 490
	/* Check whether we are not racing with some other dqget() */
	if (atomic_read(&dquot->dq_count) > 1)
		goto out_dqlock;
491 492
	if (dqopt->ops[dquot->dq_id.type]->release_dqblk) {
		ret = dqopt->ops[dquot->dq_id.type]->release_dqblk(dquot);
L
Linus Torvalds 已提交
493
		/* Write the info */
494 495 496
		if (info_dirty(&dqopt->info[dquot->dq_id.type])) {
			ret2 = dqopt->ops[dquot->dq_id.type]->write_file_info(
						dquot->dq_sb, dquot->dq_id.type);
J
Jan Kara 已提交
497
		}
L
Linus Torvalds 已提交
498 499 500 501 502
		if (ret >= 0)
			ret = ret2;
	}
	clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
out_dqlock:
I
Ingo Molnar 已提交
503
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
504 505
	return ret;
}
506
EXPORT_SYMBOL(dquot_release);
L
Linus Torvalds 已提交
507

508
void dquot_destroy(struct dquot *dquot)
509 510 511
{
	kmem_cache_free(dquot_cachep, dquot);
}
512
EXPORT_SYMBOL(dquot_destroy);
513 514 515 516 517 518

static inline void do_destroy_dquot(struct dquot *dquot)
{
	dquot->dq_sb->dq_op->destroy_dquot(dquot);
}

L
Linus Torvalds 已提交
519 520
/* Invalidate all dquots on the list. Note that this function is called after
 * quota is disabled and pointers from inodes removed so there cannot be new
521 522
 * quota users. There can still be some users of quotas due to inodes being
 * just deleted or pruned by prune_icache() (those are not attached to any
J
Jan Kara 已提交
523
 * list) or parallel quotactl call. We have to wait for such users.
524
 */
L
Linus Torvalds 已提交
525 526
static void invalidate_dquots(struct super_block *sb, int type)
{
527
	struct dquot *dquot, *tmp;
L
Linus Torvalds 已提交
528

529
restart:
L
Linus Torvalds 已提交
530
	spin_lock(&dq_list_lock);
531
	list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
L
Linus Torvalds 已提交
532 533
		if (dquot->dq_sb != sb)
			continue;
534
		if (dquot->dq_id.type != type)
L
Linus Torvalds 已提交
535
			continue;
536 537
		/* Wait for dquot users */
		if (atomic_read(&dquot->dq_count)) {
538
			dqgrab(dquot);
539
			spin_unlock(&dq_list_lock);
540 541
			/*
			 * Once dqput() wakes us up, we know it's time to free
542 543 544 545 546 547
			 * the dquot.
			 * IMPORTANT: we rely on the fact that there is always
			 * at most one process waiting for dquot to free.
			 * Otherwise dq_count would be > 1 and we would never
			 * wake up.
			 */
548 549
			wait_event(dquot_ref_wq,
				   atomic_read(&dquot->dq_count) == 1);
550 551 552 553 554 555 556 557 558 559
			dqput(dquot);
			/* At this moment dquot() need not exist (it could be
			 * reclaimed by prune_dqcache(). Hence we must
			 * restart. */
			goto restart;
		}
		/*
		 * Quota now has no users and it has been written on last
		 * dqput()
		 */
L
Linus Torvalds 已提交
560 561 562
		remove_dquot_hash(dquot);
		remove_free_dquot(dquot);
		remove_inuse(dquot);
563
		do_destroy_dquot(dquot);
L
Linus Torvalds 已提交
564 565 566 567
	}
	spin_unlock(&dq_list_lock);
}

568 569 570 571 572 573 574 575
/* Call callback for every active dquot on given filesystem */
int dquot_scan_active(struct super_block *sb,
		      int (*fn)(struct dquot *dquot, unsigned long priv),
		      unsigned long priv)
{
	struct dquot *dquot, *old_dquot = NULL;
	int ret = 0;

576 577
	WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));

578 579 580 581 582 583 584 585 586
	spin_lock(&dq_list_lock);
	list_for_each_entry(dquot, &inuse_list, dq_inuse) {
		if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags))
			continue;
		if (dquot->dq_sb != sb)
			continue;
		/* Now we have active dquot so we can just increase use count */
		atomic_inc(&dquot->dq_count);
		spin_unlock(&dq_list_lock);
587
		dqstats_inc(DQST_LOOKUPS);
588 589
		dqput(old_dquot);
		old_dquot = dquot;
590 591 592 593 594 595 596 597 598 599 600
		/*
		 * ->release_dquot() can be racing with us. Our reference
		 * protects us from new calls to it so just wait for any
		 * outstanding call and recheck the DQ_ACTIVE_B after that.
		 */
		wait_on_dquot(dquot);
		if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
			ret = fn(dquot, priv);
			if (ret < 0)
				goto out;
		}
601 602 603 604 605 606 607 608 609
		spin_lock(&dq_list_lock);
		/* We are safe to continue now because our dquot could not
		 * be moved out of the inuse list while we hold the reference */
	}
	spin_unlock(&dq_list_lock);
out:
	dqput(old_dquot);
	return ret;
}
610
EXPORT_SYMBOL(dquot_scan_active);
611

612 613
/* Write all dquot structures to quota files */
int dquot_writeback_dquots(struct super_block *sb, int type)
L
Linus Torvalds 已提交
614 615 616 617 618
{
	struct list_head *dirty;
	struct dquot *dquot;
	struct quota_info *dqopt = sb_dqopt(sb);
	int cnt;
619
	int err, ret = 0;
L
Linus Torvalds 已提交
620

621 622
	WARN_ON_ONCE(!rwsem_is_locked(&sb->s_umount));

L
Linus Torvalds 已提交
623 624 625
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
626
		if (!sb_has_quota_active(sb, cnt))
L
Linus Torvalds 已提交
627 628 629 630
			continue;
		spin_lock(&dq_list_lock);
		dirty = &dqopt->info[cnt].dqi_dirty_list;
		while (!list_empty(dirty)) {
J
Jan Kara 已提交
631 632
			dquot = list_first_entry(dirty, struct dquot,
						 dq_dirty);
J
Jan Kara 已提交
633 634 635

			WARN_ON(!test_bit(DQ_ACTIVE_B, &dquot->dq_flags));

L
Linus Torvalds 已提交
636 637 638
			/* Now we have active dquot from which someone is
 			 * holding reference so we can safely just increase
			 * use count */
639
			dqgrab(dquot);
L
Linus Torvalds 已提交
640
			spin_unlock(&dq_list_lock);
641
			dqstats_inc(DQST_LOOKUPS);
642 643
			err = sb->dq_op->write_dquot(dquot);
			if (!ret && err)
644
				ret = err;
L
Linus Torvalds 已提交
645 646 647 648 649 650 651
			dqput(dquot);
			spin_lock(&dq_list_lock);
		}
		spin_unlock(&dq_list_lock);
	}

	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
652 653
		if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
		    && info_dirty(&dqopt->info[cnt]))
L
Linus Torvalds 已提交
654
			sb->dq_op->write_info(sb, cnt);
655
	dqstats_inc(DQST_SYNCS);
L
Linus Torvalds 已提交
656

657 658 659 660 661 662 663 664 665 666 667 668 669 670 671
	return ret;
}
EXPORT_SYMBOL(dquot_writeback_dquots);

/* Write all dquot structures to disk and make them visible from userspace */
int dquot_quota_sync(struct super_block *sb, int type)
{
	struct quota_info *dqopt = sb_dqopt(sb);
	int cnt;
	int ret;

	ret = dquot_writeback_dquots(sb, type);
	if (ret)
		return ret;
	if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689
		return 0;

	/* This is not very clever (and fast) but currently I don't know about
	 * any other simple way of getting quota data to disk and we must get
	 * them there for userspace to be visible... */
	if (sb->s_op->sync_fs)
		sb->s_op->sync_fs(sb, 1);
	sync_blockdev(sb->s_bdev);

	/*
	 * Now when everything is written we can discard the pagecache so
	 * that userspace sees the changes.
	 */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
		if (!sb_has_quota_active(sb, cnt))
			continue;
A
Al Viro 已提交
690
		inode_lock(dqopt->files[cnt]);
691
		truncate_inode_pages(&dqopt->files[cnt]->i_data, 0);
A
Al Viro 已提交
692
		inode_unlock(dqopt->files[cnt]);
693 694
	}

L
Linus Torvalds 已提交
695 696
	return 0;
}
697
EXPORT_SYMBOL(dquot_quota_sync);
L
Linus Torvalds 已提交
698

699 700
static unsigned long
dqcache_shrink_scan(struct shrinker *shrink, struct shrink_control *sc)
L
Linus Torvalds 已提交
701 702 703
{
	struct list_head *head;
	struct dquot *dquot;
704
	unsigned long freed = 0;
L
Linus Torvalds 已提交
705

706
	spin_lock(&dq_list_lock);
L
Linus Torvalds 已提交
707
	head = free_dquots.prev;
708
	while (head != &free_dquots && sc->nr_to_scan) {
L
Linus Torvalds 已提交
709 710 711 712
		dquot = list_entry(head, struct dquot, dq_free);
		remove_dquot_hash(dquot);
		remove_free_dquot(dquot);
		remove_inuse(dquot);
713
		do_destroy_dquot(dquot);
714 715
		sc->nr_to_scan--;
		freed++;
L
Linus Torvalds 已提交
716 717
		head = free_dquots.prev;
	}
718
	spin_unlock(&dq_list_lock);
719
	return freed;
L
Linus Torvalds 已提交
720 721
}

722 723
static unsigned long
dqcache_shrink_count(struct shrinker *shrink, struct shrink_control *sc)
L
Linus Torvalds 已提交
724
{
725 726
	return vfs_pressure_ratio(
	percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS]));
L
Linus Torvalds 已提交
727 728
}

729
static struct shrinker dqcache_shrinker = {
730 731
	.count_objects = dqcache_shrink_count,
	.scan_objects = dqcache_shrink_scan,
732 733 734
	.seeks = DEFAULT_SEEKS,
};

L
Linus Torvalds 已提交
735 736 737
/*
 * Put reference to dquot
 */
738
void dqput(struct dquot *dquot)
L
Linus Torvalds 已提交
739
{
740 741
	int ret;

L
Linus Torvalds 已提交
742 743
	if (!dquot)
		return;
744
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
745
	if (!atomic_read(&dquot->dq_count)) {
746
		quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
747 748
			    quotatypes[dquot->dq_id.type],
			    from_kqid(&init_user_ns, dquot->dq_id));
L
Linus Torvalds 已提交
749 750 751
		BUG();
	}
#endif
752
	dqstats_inc(DQST_DROPS);
L
Linus Torvalds 已提交
753 754 755 756 757
we_slept:
	spin_lock(&dq_list_lock);
	if (atomic_read(&dquot->dq_count) > 1) {
		/* We have more than one user... nothing to do */
		atomic_dec(&dquot->dq_count);
758
		/* Releasing dquot during quotaoff phase? */
759
		if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_id.type) &&
760
		    atomic_read(&dquot->dq_count) == 1)
761
			wake_up(&dquot_ref_wq);
L
Linus Torvalds 已提交
762 763 764 765
		spin_unlock(&dq_list_lock);
		return;
	}
	/* Need to release dquot? */
J
Jan Kara 已提交
766
	if (dquot_dirty(dquot)) {
L
Linus Torvalds 已提交
767 768
		spin_unlock(&dq_list_lock);
		/* Commit dquot before releasing */
769 770
		ret = dquot->dq_sb->dq_op->write_dquot(dquot);
		if (ret < 0) {
771 772 773
			quota_error(dquot->dq_sb, "Can't write quota structure"
				    " (error %d). Quota may get out of sync!",
				    ret);
774 775 776 777 778 779
			/*
			 * We clear dirty bit anyway, so that we avoid
			 * infinite loop here
			 */
			clear_dquot_dirty(dquot);
		}
L
Linus Torvalds 已提交
780 781 782 783 784 785 786 787
		goto we_slept;
	}
	if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
		spin_unlock(&dq_list_lock);
		dquot->dq_sb->dq_op->release_dquot(dquot);
		goto we_slept;
	}
	atomic_dec(&dquot->dq_count);
788
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
789
	/* sanity check */
790
	BUG_ON(!list_empty(&dquot->dq_free));
L
Linus Torvalds 已提交
791 792 793 794
#endif
	put_dquot_last(dquot);
	spin_unlock(&dq_list_lock);
}
795
EXPORT_SYMBOL(dqput);
L
Linus Torvalds 已提交
796

797
struct dquot *dquot_alloc(struct super_block *sb, int type)
798 799 800
{
	return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
}
801
EXPORT_SYMBOL(dquot_alloc);
802

L
Linus Torvalds 已提交
803 804 805 806
static struct dquot *get_empty_dquot(struct super_block *sb, int type)
{
	struct dquot *dquot;

807
	dquot = sb->dq_op->alloc_dquot(sb, type);
L
Linus Torvalds 已提交
808
	if(!dquot)
J
Jan Kara 已提交
809
		return NULL;
L
Linus Torvalds 已提交
810

I
Ingo Molnar 已提交
811
	mutex_init(&dquot->dq_lock);
L
Linus Torvalds 已提交
812 813 814 815 816
	INIT_LIST_HEAD(&dquot->dq_free);
	INIT_LIST_HEAD(&dquot->dq_inuse);
	INIT_HLIST_NODE(&dquot->dq_hash);
	INIT_LIST_HEAD(&dquot->dq_dirty);
	dquot->dq_sb = sb;
E
Eric W. Biederman 已提交
817
	dquot->dq_id = make_kqid_invalid(type);
L
Linus Torvalds 已提交
818 819 820 821 822 823 824
	atomic_set(&dquot->dq_count, 1);

	return dquot;
}

/*
 * Get reference to dquot
J
Jan Kara 已提交
825 826 827 828 829
 *
 * Locking is slightly tricky here. We are guarded from parallel quotaoff()
 * destroying our dquot by:
 *   a) checking for quota flags under dq_list_lock and
 *   b) getting a reference to dquot before we release dq_list_lock
L
Linus Torvalds 已提交
830
 */
831
struct dquot *dqget(struct super_block *sb, struct kqid qid)
L
Linus Torvalds 已提交
832
{
E
Eric W. Biederman 已提交
833
	unsigned int hashent = hashfn(sb, qid);
834
	struct dquot *dquot, *empty = NULL;
L
Linus Torvalds 已提交
835

836 837 838
	if (!qid_has_mapping(sb->s_user_ns, qid))
		return ERR_PTR(-EINVAL);

E
Eric W. Biederman 已提交
839
        if (!sb_has_quota_active(sb, qid.type))
840
		return ERR_PTR(-ESRCH);
L
Linus Torvalds 已提交
841 842
we_slept:
	spin_lock(&dq_list_lock);
J
Jan Kara 已提交
843
	spin_lock(&dq_state_lock);
E
Eric W. Biederman 已提交
844
	if (!sb_has_quota_active(sb, qid.type)) {
J
Jan Kara 已提交
845 846
		spin_unlock(&dq_state_lock);
		spin_unlock(&dq_list_lock);
847
		dquot = ERR_PTR(-ESRCH);
J
Jan Kara 已提交
848 849 850 851
		goto out;
	}
	spin_unlock(&dq_state_lock);

E
Eric W. Biederman 已提交
852
	dquot = find_dquot(hashent, sb, qid);
J
Jan Kara 已提交
853 854
	if (!dquot) {
		if (!empty) {
L
Linus Torvalds 已提交
855
			spin_unlock(&dq_list_lock);
E
Eric W. Biederman 已提交
856
			empty = get_empty_dquot(sb, qid.type);
J
Jan Kara 已提交
857
			if (!empty)
L
Linus Torvalds 已提交
858 859 860 861
				schedule();	/* Try to wait for a moment... */
			goto we_slept;
		}
		dquot = empty;
J
Jan Kara 已提交
862
		empty = NULL;
863
		dquot->dq_id = qid;
L
Linus Torvalds 已提交
864 865 866 867 868
		/* all dquots go on the inuse_list */
		put_inuse(dquot);
		/* hash it first so it can be found */
		insert_dquot_hash(dquot);
		spin_unlock(&dq_list_lock);
869
		dqstats_inc(DQST_LOOKUPS);
L
Linus Torvalds 已提交
870 871 872 873 874
	} else {
		if (!atomic_read(&dquot->dq_count))
			remove_free_dquot(dquot);
		atomic_inc(&dquot->dq_count);
		spin_unlock(&dq_list_lock);
875 876
		dqstats_inc(DQST_CACHE_HITS);
		dqstats_inc(DQST_LOOKUPS);
L
Linus Torvalds 已提交
877
	}
J
Jan Kara 已提交
878 879
	/* Wait for dq_lock - after this we know that either dquot_release() is
	 * already finished or it will be canceled due to dq_count > 1 test */
L
Linus Torvalds 已提交
880
	wait_on_dquot(dquot);
J
Jan Kara 已提交
881
	/* Read the dquot / allocate space in quota file */
882 883 884 885 886 887 888 889 890
	if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
		int err;

		err = sb->dq_op->acquire_dquot(dquot);
		if (err < 0) {
			dqput(dquot);
			dquot = ERR_PTR(err);
			goto out;
		}
L
Linus Torvalds 已提交
891
	}
892 893 894 895 896
	/*
	 * Make sure following reads see filled structure - paired with
	 * smp_mb__before_atomic() in dquot_acquire().
	 */
	smp_rmb();
897
#ifdef CONFIG_QUOTA_DEBUG
898
	BUG_ON(!dquot->dq_sb);	/* Has somebody invalidated entry under us? */
L
Linus Torvalds 已提交
899
#endif
J
Jan Kara 已提交
900 901 902
out:
	if (empty)
		do_destroy_dquot(empty);
L
Linus Torvalds 已提交
903 904 905

	return dquot;
}
906
EXPORT_SYMBOL(dqget);
L
Linus Torvalds 已提交
907

908 909 910 911 912
static inline struct dquot **i_dquot(struct inode *inode)
{
	return inode->i_sb->s_op->get_dquots(inode);
}

L
Linus Torvalds 已提交
913 914
static int dqinit_needed(struct inode *inode, int type)
{
915
	struct dquot * const *dquots;
L
Linus Torvalds 已提交
916 917 918 919
	int cnt;

	if (IS_NOQUOTA(inode))
		return 0;
920 921

	dquots = i_dquot(inode);
L
Linus Torvalds 已提交
922
	if (type != -1)
923
		return !dquots[type];
L
Linus Torvalds 已提交
924
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
925
		if (!dquots[cnt])
L
Linus Torvalds 已提交
926 927 928 929
			return 1;
	return 0;
}

J
Jan Kara 已提交
930
/* This routine is guarded by s_umount semaphore */
L
Linus Torvalds 已提交
931 932
static void add_dquot_ref(struct super_block *sb, int type)
{
933
	struct inode *inode, *old_inode = NULL;
934
#ifdef CONFIG_QUOTA_DEBUG
935
	int reserved = 0;
936
#endif
L
Linus Torvalds 已提交
937

938
	spin_lock(&sb->s_inode_list_lock);
939
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
940 941 942 943 944
		spin_lock(&inode->i_lock);
		if ((inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW)) ||
		    !atomic_read(&inode->i_writecount) ||
		    !dqinit_needed(inode, type)) {
			spin_unlock(&inode->i_lock);
N
Nick Piggin 已提交
945
			continue;
946
		}
947
		__iget(inode);
948
		spin_unlock(&inode->i_lock);
949
		spin_unlock(&sb->s_inode_list_lock);
950

951 952 953 954
#ifdef CONFIG_QUOTA_DEBUG
		if (unlikely(inode_get_rsv_space(inode) > 0))
			reserved = 1;
#endif
955
		iput(old_inode);
956
		__dquot_initialize(inode, type);
957 958 959 960

		/*
		 * We hold a reference to 'inode' so it couldn't have been
		 * removed from s_inodes list while we dropped the
961
		 * s_inode_list_lock. We cannot iput the inode now as we can be
962
		 * holding the last reference and we cannot iput it under
963
		 * s_inode_list_lock. So we keep the reference and iput it
964 965
		 * later.
		 */
966
		old_inode = inode;
967
		spin_lock(&sb->s_inode_list_lock);
L
Linus Torvalds 已提交
968
	}
969
	spin_unlock(&sb->s_inode_list_lock);
970
	iput(old_inode);
971

972
#ifdef CONFIG_QUOTA_DEBUG
973
	if (reserved) {
974 975 976
		quota_error(sb, "Writes happened before quota was turned on "
			"thus quota information is probably inconsistent. "
			"Please run quotacheck(8)");
977
	}
978
#endif
L
Linus Torvalds 已提交
979 980
}

J
Jan Kara 已提交
981 982
/*
 * Remove references to dquots from inode and add dquot to list for freeing
L
Lucas De Marchi 已提交
983
 * if we have the last reference to dquot
J
Jan Kara 已提交
984
 */
985 986
static void remove_inode_dquot_ref(struct inode *inode, int type,
				   struct list_head *tofree_head)
L
Linus Torvalds 已提交
987
{
988 989
	struct dquot **dquots = i_dquot(inode);
	struct dquot *dquot = dquots[type];
L
Linus Torvalds 已提交
990

991 992 993
	if (!dquot)
		return;

994
	dquots[type] = NULL;
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
	if (list_empty(&dquot->dq_free)) {
		/*
		 * The inode still has reference to dquot so it can't be in the
		 * free list
		 */
		spin_lock(&dq_list_lock);
		list_add(&dquot->dq_free, tofree_head);
		spin_unlock(&dq_list_lock);
	} else {
		/*
		 * Dquot is already in a list to put so we won't drop the last
		 * reference here.
		 */
		dqput(dquot);
L
Linus Torvalds 已提交
1009 1010 1011
	}
}

J
Jan Kara 已提交
1012 1013 1014 1015 1016
/*
 * Free list of dquots
 * Dquots are removed from inodes and no new references can be got so we are
 * the only ones holding reference
 */
L
Linus Torvalds 已提交
1017 1018 1019 1020 1021 1022 1023 1024 1025
static void put_dquot_list(struct list_head *tofree_head)
{
	struct list_head *act_head;
	struct dquot *dquot;

	act_head = tofree_head->next;
	while (act_head != tofree_head) {
		dquot = list_entry(act_head, struct dquot, dq_free);
		act_head = act_head->next;
J
Jan Kara 已提交
1026 1027
		/* Remove dquot from the list so we won't have problems... */
		list_del_init(&dquot->dq_free);
L
Linus Torvalds 已提交
1028 1029 1030 1031
		dqput(dquot);
	}
}

1032 1033 1034 1035
static void remove_dquot_ref(struct super_block *sb, int type,
		struct list_head *tofree_head)
{
	struct inode *inode;
1036
	int reserved = 0;
1037

1038
	spin_lock(&sb->s_inode_list_lock);
1039
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
N
Nick Piggin 已提交
1040 1041 1042 1043
		/*
		 *  We have to scan also I_NEW inodes because they can already
		 *  have quota pointer initialized. Luckily, we need to touch
		 *  only quota pointers and these have separate locking
N
Niu Yawei 已提交
1044
		 *  (dq_data_lock).
N
Nick Piggin 已提交
1045
		 */
N
Niu Yawei 已提交
1046
		spin_lock(&dq_data_lock);
1047 1048 1049
		if (!IS_NOQUOTA(inode)) {
			if (unlikely(inode_get_rsv_space(inode) > 0))
				reserved = 1;
1050
			remove_inode_dquot_ref(inode, type, tofree_head);
1051
		}
N
Niu Yawei 已提交
1052
		spin_unlock(&dq_data_lock);
1053
	}
1054
	spin_unlock(&sb->s_inode_list_lock);
1055 1056 1057 1058 1059 1060 1061
#ifdef CONFIG_QUOTA_DEBUG
	if (reserved) {
		printk(KERN_WARNING "VFS (%s): Writes happened after quota"
			" was disabled thus quota information is probably "
			"inconsistent. Please run quotacheck(8).\n", sb->s_id);
	}
#endif
1062 1063
}

L
Linus Torvalds 已提交
1064 1065 1066 1067 1068
/* Gather all references from inodes and drop them */
static void drop_dquot_ref(struct super_block *sb, int type)
{
	LIST_HEAD(tofree_head);

1069 1070
	if (sb->dq_op) {
		remove_dquot_ref(sb, type, &tofree_head);
N
Niu Yawei 已提交
1071
		synchronize_srcu(&dquot_srcu);
1072 1073
		put_dquot_list(&tofree_head);
	}
L
Linus Torvalds 已提交
1074 1075
}

1076
static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1077 1078 1079 1080 1081 1082 1083 1084 1085
{
	dquot->dq_dqb.dqb_curinodes += number;
}

static inline void dquot_incr_space(struct dquot *dquot, qsize_t number)
{
	dquot->dq_dqb.dqb_curspace += number;
}

1086 1087 1088 1089 1090
static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
{
	dquot->dq_dqb.dqb_rsvspace += number;
}

1091 1092 1093
static inline
void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
{
1094 1095 1096 1097 1098 1099
	if (dquot->dq_dqb.dqb_rsvspace >= number)
		dquot->dq_dqb.dqb_rsvspace -= number;
	else {
		WARN_ON_ONCE(1);
		dquot->dq_dqb.dqb_rsvspace = 0;
	}
1100 1101
}

J
Jan Kara 已提交
1102
static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1103
{
1104 1105
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curinodes >= number)
L
Linus Torvalds 已提交
1106 1107 1108 1109
		dquot->dq_dqb.dqb_curinodes -= number;
	else
		dquot->dq_dqb.dqb_curinodes = 0;
	if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
A
Arnd Bergmann 已提交
1110
		dquot->dq_dqb.dqb_itime = (time64_t) 0;
L
Linus Torvalds 已提交
1111 1112 1113
	clear_bit(DQ_INODES_B, &dquot->dq_flags);
}

J
Jan Kara 已提交
1114
static void dquot_decr_space(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1115
{
1116 1117
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curspace >= number)
L
Linus Torvalds 已提交
1118 1119 1120
		dquot->dq_dqb.dqb_curspace -= number;
	else
		dquot->dq_dqb.dqb_curspace = 0;
1121
	if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
A
Arnd Bergmann 已提交
1122
		dquot->dq_dqb.dqb_btime = (time64_t) 0;
L
Linus Torvalds 已提交
1123 1124 1125
	clear_bit(DQ_BLKS_B, &dquot->dq_flags);
}

1126 1127
struct dquot_warn {
	struct super_block *w_sb;
1128
	struct kqid w_dq_id;
1129 1130 1131
	short w_type;
};

1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143
static int warning_issued(struct dquot *dquot, const int warntype)
{
	int flag = (warntype == QUOTA_NL_BHARDWARN ||
		warntype == QUOTA_NL_BSOFTLONGWARN) ? DQ_BLKS_B :
		((warntype == QUOTA_NL_IHARDWARN ||
		warntype == QUOTA_NL_ISOFTLONGWARN) ? DQ_INODES_B : 0);

	if (!flag)
		return 0;
	return test_and_set_bit(flag, &dquot->dq_flags);
}

J
Jan Kara 已提交
1144
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
1145 1146
static int flag_print_warnings = 1;

1147
static int need_print_warning(struct dquot_warn *warn)
L
Linus Torvalds 已提交
1148 1149 1150 1151
{
	if (!flag_print_warnings)
		return 0;

1152
	switch (warn->w_dq_id.type) {
L
Linus Torvalds 已提交
1153
		case USRQUOTA:
E
Eric W. Biederman 已提交
1154
			return uid_eq(current_fsuid(), warn->w_dq_id.uid);
L
Linus Torvalds 已提交
1155
		case GRPQUOTA:
1156
			return in_group_p(warn->w_dq_id.gid);
1157 1158
		case PRJQUOTA:
			return 1;
L
Linus Torvalds 已提交
1159 1160 1161 1162 1163
	}
	return 0;
}

/* Print warning to user which exceeded quota */
1164
static void print_warning(struct dquot_warn *warn)
L
Linus Torvalds 已提交
1165 1166
{
	char *msg = NULL;
1167
	struct tty_struct *tty;
1168
	int warntype = warn->w_type;
L
Linus Torvalds 已提交
1169

1170 1171 1172
	if (warntype == QUOTA_NL_IHARDBELOW ||
	    warntype == QUOTA_NL_ISOFTBELOW ||
	    warntype == QUOTA_NL_BHARDBELOW ||
1173
	    warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(warn))
L
Linus Torvalds 已提交
1174 1175
		return;

1176 1177
	tty = get_current_tty();
	if (!tty)
A
Alan Cox 已提交
1178
		return;
1179
	tty_write_message(tty, warn->w_sb->s_id);
J
Jan Kara 已提交
1180
	if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
1181
		tty_write_message(tty, ": warning, ");
L
Linus Torvalds 已提交
1182
	else
1183
		tty_write_message(tty, ": write failed, ");
1184
	tty_write_message(tty, quotatypes[warn->w_dq_id.type]);
L
Linus Torvalds 已提交
1185
	switch (warntype) {
J
Jan Kara 已提交
1186
		case QUOTA_NL_IHARDWARN:
L
Linus Torvalds 已提交
1187 1188
			msg = " file limit reached.\r\n";
			break;
J
Jan Kara 已提交
1189
		case QUOTA_NL_ISOFTLONGWARN:
L
Linus Torvalds 已提交
1190 1191
			msg = " file quota exceeded too long.\r\n";
			break;
J
Jan Kara 已提交
1192
		case QUOTA_NL_ISOFTWARN:
L
Linus Torvalds 已提交
1193 1194
			msg = " file quota exceeded.\r\n";
			break;
J
Jan Kara 已提交
1195
		case QUOTA_NL_BHARDWARN:
L
Linus Torvalds 已提交
1196 1197
			msg = " block limit reached.\r\n";
			break;
J
Jan Kara 已提交
1198
		case QUOTA_NL_BSOFTLONGWARN:
L
Linus Torvalds 已提交
1199 1200
			msg = " block quota exceeded too long.\r\n";
			break;
J
Jan Kara 已提交
1201
		case QUOTA_NL_BSOFTWARN:
L
Linus Torvalds 已提交
1202 1203 1204
			msg = " block quota exceeded.\r\n";
			break;
	}
1205
	tty_write_message(tty, msg);
A
Alan Cox 已提交
1206
	tty_kref_put(tty);
L
Linus Torvalds 已提交
1207
}
J
Jan Kara 已提交
1208 1209
#endif

1210 1211 1212 1213 1214 1215 1216 1217 1218 1219
static void prepare_warning(struct dquot_warn *warn, struct dquot *dquot,
			    int warntype)
{
	if (warning_issued(dquot, warntype))
		return;
	warn->w_type = warntype;
	warn->w_sb = dquot->dq_sb;
	warn->w_dq_id = dquot->dq_id;
}

1220 1221 1222
/*
 * Write warnings to the console and send warning messages over netlink.
 *
1223
 * Note that this function can call into tty and networking code.
1224
 */
1225
static void flush_warnings(struct dquot_warn *warn)
L
Linus Torvalds 已提交
1226 1227 1228
{
	int i;

S
Steven Whitehouse 已提交
1229
	for (i = 0; i < MAXQUOTAS; i++) {
1230 1231
		if (warn[i].w_type == QUOTA_NL_NOWARN)
			continue;
J
Jan Kara 已提交
1232
#ifdef CONFIG_PRINT_QUOTA_WARNING
1233
		print_warning(&warn[i]);
J
Jan Kara 已提交
1234
#endif
1235
		quota_send_warning(warn[i].w_dq_id,
1236
				   warn[i].w_sb->s_dev, warn[i].w_type);
S
Steven Whitehouse 已提交
1237
	}
L
Linus Torvalds 已提交
1238 1239
}

J
Jan Kara 已提交
1240
static int ignore_hardlimit(struct dquot *dquot)
L
Linus Torvalds 已提交
1241
{
1242
	struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
L
Linus Torvalds 已提交
1243 1244

	return capable(CAP_SYS_RESOURCE) &&
J
Jan Kara 已提交
1245
	       (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
J
Jan Kara 已提交
1246
		!(info->dqi_flags & DQF_ROOT_SQUASH));
L
Linus Torvalds 已提交
1247 1248 1249
}

/* needs dq_data_lock */
1250 1251
static int check_idq(struct dquot *dquot, qsize_t inodes,
		     struct dquot_warn *warn)
L
Linus Torvalds 已提交
1252
{
J
Jan Kara 已提交
1253 1254
	qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;

1255
	if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type) ||
1256
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1257
		return 0;
L
Linus Torvalds 已提交
1258 1259

	if (dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1260
	    newinodes > dquot->dq_dqb.dqb_ihardlimit &&
L
Linus Torvalds 已提交
1261
            !ignore_hardlimit(dquot)) {
1262
		prepare_warning(warn, dquot, QUOTA_NL_IHARDWARN);
1263
		return -EDQUOT;
L
Linus Torvalds 已提交
1264 1265 1266
	}

	if (dquot->dq_dqb.dqb_isoftlimit &&
J
Jan Kara 已提交
1267 1268
	    newinodes > dquot->dq_dqb.dqb_isoftlimit &&
	    dquot->dq_dqb.dqb_itime &&
A
Arnd Bergmann 已提交
1269
	    ktime_get_real_seconds() >= dquot->dq_dqb.dqb_itime &&
L
Linus Torvalds 已提交
1270
            !ignore_hardlimit(dquot)) {
1271
		prepare_warning(warn, dquot, QUOTA_NL_ISOFTLONGWARN);
1272
		return -EDQUOT;
L
Linus Torvalds 已提交
1273 1274 1275
	}

	if (dquot->dq_dqb.dqb_isoftlimit &&
J
Jan Kara 已提交
1276
	    newinodes > dquot->dq_dqb.dqb_isoftlimit &&
L
Linus Torvalds 已提交
1277
	    dquot->dq_dqb.dqb_itime == 0) {
1278
		prepare_warning(warn, dquot, QUOTA_NL_ISOFTWARN);
A
Arnd Bergmann 已提交
1279
		dquot->dq_dqb.dqb_itime = ktime_get_real_seconds() +
1280
		    sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type].dqi_igrace;
L
Linus Torvalds 已提交
1281 1282
	}

1283
	return 0;
L
Linus Torvalds 已提交
1284 1285 1286
}

/* needs dq_data_lock */
1287 1288
static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc,
		     struct dquot_warn *warn)
L
Linus Torvalds 已提交
1289
{
1290
	qsize_t tspace;
J
Jan Kara 已提交
1291
	struct super_block *sb = dquot->dq_sb;
1292

1293
	if (!sb_has_quota_limits_enabled(sb, dquot->dq_id.type) ||
1294
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1295
		return 0;
L
Linus Torvalds 已提交
1296

1297 1298 1299
	tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
		+ space;

L
Linus Torvalds 已提交
1300
	if (dquot->dq_dqb.dqb_bhardlimit &&
1301
	    tspace > dquot->dq_dqb.dqb_bhardlimit &&
L
Linus Torvalds 已提交
1302 1303
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1304
			prepare_warning(warn, dquot, QUOTA_NL_BHARDWARN);
1305
		return -EDQUOT;
L
Linus Torvalds 已提交
1306 1307 1308
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1309
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
J
Jan Kara 已提交
1310
	    dquot->dq_dqb.dqb_btime &&
A
Arnd Bergmann 已提交
1311
	    ktime_get_real_seconds() >= dquot->dq_dqb.dqb_btime &&
L
Linus Torvalds 已提交
1312 1313
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1314
			prepare_warning(warn, dquot, QUOTA_NL_BSOFTLONGWARN);
1315
		return -EDQUOT;
L
Linus Torvalds 已提交
1316 1317 1318
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1319
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
L
Linus Torvalds 已提交
1320 1321
	    dquot->dq_dqb.dqb_btime == 0) {
		if (!prealloc) {
1322
			prepare_warning(warn, dquot, QUOTA_NL_BSOFTWARN);
A
Arnd Bergmann 已提交
1323
			dquot->dq_dqb.dqb_btime = ktime_get_real_seconds() +
1324
			    sb_dqopt(sb)->info[dquot->dq_id.type].dqi_bgrace;
L
Linus Torvalds 已提交
1325 1326 1327 1328 1329 1330
		}
		else
			/*
			 * We don't allow preallocation to exceed softlimit so exceeding will
			 * be always printed
			 */
1331
			return -EDQUOT;
L
Linus Torvalds 已提交
1332 1333
	}

1334
	return 0;
L
Linus Torvalds 已提交
1335 1336
}

1337
static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1338
{
J
Jan Kara 已提交
1339 1340
	qsize_t newinodes;

1341
	if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1342
	    dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
1343
	    !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_id.type))
1344 1345
		return QUOTA_NL_NOWARN;

J
Jan Kara 已提交
1346 1347
	newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
	if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1348 1349
		return QUOTA_NL_ISOFTBELOW;
	if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1350
	    newinodes < dquot->dq_dqb.dqb_ihardlimit)
1351 1352 1353 1354 1355 1356 1357
		return QUOTA_NL_IHARDBELOW;
	return QUOTA_NL_NOWARN;
}

static int info_bdq_free(struct dquot *dquot, qsize_t space)
{
	if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1358
	    dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
1359 1360
		return QUOTA_NL_NOWARN;

1361
	if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
1362
		return QUOTA_NL_BSOFTBELOW;
1363 1364
	if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
	    dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
1365 1366 1367
		return QUOTA_NL_BHARDBELOW;
	return QUOTA_NL_NOWARN;
}
1368

1369 1370 1371 1372 1373 1374 1375 1376 1377
static int dquot_active(const struct inode *inode)
{
	struct super_block *sb = inode->i_sb;

	if (IS_NOQUOTA(inode))
		return 0;
	return sb_any_quota_loaded(sb) & ~sb_any_quota_suspended(sb);
}

L
Linus Torvalds 已提交
1378
/*
1379 1380 1381 1382
 * Initialize quota pointers in inode
 *
 * It is better to call this function outside of any transaction as it
 * might need a lot of space in journal for dquot structure allocation.
L
Linus Torvalds 已提交
1383
 */
1384
static int __dquot_initialize(struct inode *inode, int type)
L
Linus Torvalds 已提交
1385
{
1386
	int cnt, init_needed = 0;
1387
	struct dquot **dquots, *got[MAXQUOTAS] = {};
J
Jan Kara 已提交
1388
	struct super_block *sb = inode->i_sb;
1389
	qsize_t rsv;
1390
	int ret = 0;
L
Linus Torvalds 已提交
1391

1392
	if (!dquot_active(inode))
1393
		return 0;
J
Jan Kara 已提交
1394

1395 1396
	dquots = i_dquot(inode);

J
Jan Kara 已提交
1397 1398
	/* First get references to structures we might need. */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1399
		struct kqid qid;
1400 1401
		kprojid_t projid;
		int rc;
1402
		struct dquot *dquot;
1403

J
Jan Kara 已提交
1404 1405
		if (type != -1 && cnt != type)
			continue;
1406 1407 1408 1409 1410
		/*
		 * The i_dquot should have been initialized in most cases,
		 * we check it without locking here to avoid unnecessary
		 * dqget()/dqput() calls.
		 */
1411
		if (dquots[cnt])
1412
			continue;
1413 1414 1415 1416

		if (!sb_has_quota_active(sb, cnt))
			continue;

1417 1418
		init_needed = 1;

J
Jan Kara 已提交
1419 1420
		switch (cnt) {
		case USRQUOTA:
1421
			qid = make_kqid_uid(inode->i_uid);
J
Jan Kara 已提交
1422 1423
			break;
		case GRPQUOTA:
1424
			qid = make_kqid_gid(inode->i_gid);
J
Jan Kara 已提交
1425
			break;
1426 1427 1428 1429 1430 1431
		case PRJQUOTA:
			rc = inode->i_sb->dq_op->get_projid(inode, &projid);
			if (rc)
				continue;
			qid = make_kqid_projid(projid);
			break;
J
Jan Kara 已提交
1432
		}
1433 1434 1435 1436 1437 1438 1439 1440 1441 1442
		dquot = dqget(sb, qid);
		if (IS_ERR(dquot)) {
			/* We raced with somebody turning quotas off... */
			if (PTR_ERR(dquot) != -ESRCH) {
				ret = PTR_ERR(dquot);
				goto out_put;
			}
			dquot = NULL;
		}
		got[cnt] = dquot;
J
Jan Kara 已提交
1443 1444
	}

1445 1446
	/* All required i_dquot has been initialized */
	if (!init_needed)
1447
		return 0;
1448

N
Niu Yawei 已提交
1449
	spin_lock(&dq_data_lock);
L
Linus Torvalds 已提交
1450
	if (IS_NOQUOTA(inode))
1451
		goto out_lock;
L
Linus Torvalds 已提交
1452 1453 1454
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
J
Jan Kara 已提交
1455 1456 1457
		/* Avoid races with quotaoff() */
		if (!sb_has_quota_active(sb, cnt))
			continue;
1458 1459 1460
		/* We could race with quotaon or dqget() could have failed */
		if (!got[cnt])
			continue;
1461 1462
		if (!dquots[cnt]) {
			dquots[cnt] = got[cnt];
J
Jan Kara 已提交
1463
			got[cnt] = NULL;
1464 1465 1466 1467 1468
			/*
			 * Make quota reservation system happy if someone
			 * did a write before quota was turned on
			 */
			rsv = inode_get_rsv_space(inode);
N
Niu Yawei 已提交
1469
			if (unlikely(rsv))
1470
				dquot_resv_space(dquots[cnt], rsv);
L
Linus Torvalds 已提交
1471 1472
		}
	}
1473
out_lock:
N
Niu Yawei 已提交
1474
	spin_unlock(&dq_data_lock);
1475
out_put:
J
Jan Kara 已提交
1476
	/* Drop unused references */
1477
	dqput_all(got);
1478 1479

	return ret;
1480 1481
}

1482
int dquot_initialize(struct inode *inode)
1483
{
1484
	return __dquot_initialize(inode, -1);
L
Linus Torvalds 已提交
1485
}
1486
EXPORT_SYMBOL(dquot_initialize);
L
Linus Torvalds 已提交
1487

1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503
bool dquot_initialize_needed(struct inode *inode)
{
	struct dquot **dquots;
	int i;

	if (!dquot_active(inode))
		return false;

	dquots = i_dquot(inode);
	for (i = 0; i < MAXQUOTAS; i++)
		if (!dquots[i] && sb_has_quota_active(inode->i_sb, i))
			return true;
	return false;
}
EXPORT_SYMBOL(dquot_initialize_needed);

L
Linus Torvalds 已提交
1504
/*
N
Niu Yawei 已提交
1505 1506 1507 1508 1509 1510
 * Release all quotas referenced by inode.
 *
 * This function only be called on inode free or converting
 * a file to quota file, no other users for the i_dquot in
 * both cases, so we needn't call synchronize_srcu() after
 * clearing i_dquot.
L
Linus Torvalds 已提交
1511
 */
1512
static void __dquot_drop(struct inode *inode)
L
Linus Torvalds 已提交
1513 1514
{
	int cnt;
1515
	struct dquot **dquots = i_dquot(inode);
J
Jan Kara 已提交
1516
	struct dquot *put[MAXQUOTAS];
L
Linus Torvalds 已提交
1517

N
Niu Yawei 已提交
1518
	spin_lock(&dq_data_lock);
L
Linus Torvalds 已提交
1519
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1520 1521
		put[cnt] = dquots[cnt];
		dquots[cnt] = NULL;
L
Linus Torvalds 已提交
1522
	}
N
Niu Yawei 已提交
1523
	spin_unlock(&dq_data_lock);
1524
	dqput_all(put);
L
Linus Torvalds 已提交
1525 1526
}

1527 1528
void dquot_drop(struct inode *inode)
{
1529
	struct dquot * const *dquots;
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
	int cnt;

	if (IS_NOQUOTA(inode))
		return;

	/*
	 * Test before calling to rule out calls from proc and such
	 * where we are not allowed to block. Note that this is
	 * actually reliable test even without the lock - the caller
	 * must assure that nobody can come after the DQUOT_DROP and
	 * add quota pointers back anyway.
	 */
1542
	dquots = i_dquot(inode);
1543
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1544
		if (dquots[cnt])
1545 1546 1547 1548 1549 1550 1551
			break;
	}

	if (cnt < MAXQUOTAS)
		__dquot_drop(inode);
}
EXPORT_SYMBOL(dquot_drop);
1552

1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
/*
 * inode_reserved_space is managed internally by quota, and protected by
 * i_lock similar to i_blocks+i_bytes.
 */
static qsize_t *inode_reserved_space(struct inode * inode)
{
	/* Filesystem must explicitly define it's own method in order to use
	 * quota reservation interface */
	BUG_ON(!inode->i_sb->dq_op->get_reserved_space);
	return inode->i_sb->dq_op->get_reserved_space(inode);
}

static qsize_t inode_get_rsv_space(struct inode *inode)
{
	qsize_t ret;
1568 1569 1570

	if (!inode->i_sb->dq_op->get_reserved_space)
		return 0;
1571 1572 1573 1574 1575 1576
	spin_lock(&inode->i_lock);
	ret = *inode_reserved_space(inode);
	spin_unlock(&inode->i_lock);
	return ret;
}

L
Linus Torvalds 已提交
1577
/*
1578 1579 1580 1581 1582 1583 1584
 * This functions updates i_blocks+i_bytes fields and quota information
 * (together with appropriate checks).
 *
 * NOTE: We absolutely rely on the fact that caller dirties the inode
 * (usually helpers in quotaops.h care about this) and holds a handle for
 * the current transaction so that dquot write and inode write go into the
 * same transaction.
L
Linus Torvalds 已提交
1585 1586 1587 1588 1589
 */

/*
 * This operation can block, but only after everything is updated
 */
1590
int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
L
Linus Torvalds 已提交
1591
{
N
Niu Yawei 已提交
1592
	int cnt, ret = 0, index;
1593
	struct dquot_warn warn[MAXQUOTAS];
1594
	int reserve = flags & DQUOT_SPACE_RESERVE;
1595
	struct dquot **dquots;
L
Linus Torvalds 已提交
1596

1597
	if (!dquot_active(inode)) {
1598 1599 1600 1601 1602 1603 1604
		if (reserve) {
			spin_lock(&inode->i_lock);
			*inode_reserved_space(inode) += number;
			spin_unlock(&inode->i_lock);
		} else {
			inode_add_bytes(inode, number);
		}
1605 1606 1607
		goto out;
	}

L
Linus Torvalds 已提交
1608
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1609
		warn[cnt].w_type = QUOTA_NL_NOWARN;
L
Linus Torvalds 已提交
1610

1611
	dquots = i_dquot(inode);
N
Niu Yawei 已提交
1612
	index = srcu_read_lock(&dquot_srcu);
L
Linus Torvalds 已提交
1613 1614
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1615
		if (!dquots[cnt])
L
Linus Torvalds 已提交
1616
			continue;
1617 1618 1619
		ret = check_bdq(dquots[cnt], number,
				!(flags & DQUOT_SPACE_WARN), &warn[cnt]);
		if (ret && !(flags & DQUOT_SPACE_NOFAIL)) {
1620 1621
			spin_unlock(&dq_data_lock);
			goto out_flush_warn;
1622
		}
L
Linus Torvalds 已提交
1623 1624
	}
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1625
		if (!dquots[cnt])
L
Linus Torvalds 已提交
1626
			continue;
1627
		if (reserve)
1628
			dquot_resv_space(dquots[cnt], number);
1629
		else
1630
			dquot_incr_space(dquots[cnt], number);
L
Linus Torvalds 已提交
1631
	}
1632 1633 1634 1635 1636 1637 1638
	if (reserve) {
		spin_lock(&inode->i_lock);
		*inode_reserved_space(inode) += number;
		spin_unlock(&inode->i_lock);
	} else {
		inode_add_bytes(inode, number);
	}
L
Linus Torvalds 已提交
1639
	spin_unlock(&dq_data_lock);
1640

1641 1642
	if (reserve)
		goto out_flush_warn;
1643
	mark_all_dquot_dirty(dquots);
1644
out_flush_warn:
N
Niu Yawei 已提交
1645
	srcu_read_unlock(&dquot_srcu, index);
1646
	flush_warnings(warn);
1647 1648 1649
out:
	return ret;
}
1650
EXPORT_SYMBOL(__dquot_alloc_space);
L
Linus Torvalds 已提交
1651 1652 1653 1654

/*
 * This operation can block, but only after everything is updated
 */
1655
int dquot_alloc_inode(struct inode *inode)
L
Linus Torvalds 已提交
1656
{
N
Niu Yawei 已提交
1657
	int cnt, ret = 0, index;
1658
	struct dquot_warn warn[MAXQUOTAS];
1659
	struct dquot * const *dquots;
L
Linus Torvalds 已提交
1660

1661
	if (!dquot_active(inode))
1662
		return 0;
L
Linus Torvalds 已提交
1663
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1664
		warn[cnt].w_type = QUOTA_NL_NOWARN;
N
Niu Yawei 已提交
1665

1666
	dquots = i_dquot(inode);
N
Niu Yawei 已提交
1667
	index = srcu_read_lock(&dquot_srcu);
L
Linus Torvalds 已提交
1668 1669
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1670
		if (!dquots[cnt])
L
Linus Torvalds 已提交
1671
			continue;
1672
		ret = check_idq(dquots[cnt], 1, &warn[cnt]);
1673
		if (ret)
L
Linus Torvalds 已提交
1674 1675 1676 1677
			goto warn_put_all;
	}

	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1678
		if (!dquots[cnt])
L
Linus Torvalds 已提交
1679
			continue;
1680
		dquot_incr_inodes(dquots[cnt], 1);
L
Linus Torvalds 已提交
1681
	}
1682

L
Linus Torvalds 已提交
1683 1684
warn_put_all:
	spin_unlock(&dq_data_lock);
1685
	if (ret == 0)
1686
		mark_all_dquot_dirty(dquots);
N
Niu Yawei 已提交
1687
	srcu_read_unlock(&dquot_srcu, index);
1688
	flush_warnings(warn);
L
Linus Torvalds 已提交
1689 1690
	return ret;
}
1691
EXPORT_SYMBOL(dquot_alloc_inode);
L
Linus Torvalds 已提交
1692

1693 1694 1695 1696
/*
 * Convert in-memory reserved quotas to real consumed quotas
 */
int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1697
{
1698
	struct dquot **dquots;
N
Niu Yawei 已提交
1699
	int cnt, index;
1700

1701
	if (!dquot_active(inode)) {
1702 1703 1704 1705
		spin_lock(&inode->i_lock);
		*inode_reserved_space(inode) -= number;
		__inode_add_bytes(inode, number);
		spin_unlock(&inode->i_lock);
1706
		return 0;
1707 1708
	}

1709
	dquots = i_dquot(inode);
N
Niu Yawei 已提交
1710
	index = srcu_read_lock(&dquot_srcu);
1711 1712 1713
	spin_lock(&dq_data_lock);
	/* Claim reserved quotas to allocated quotas */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1714 1715 1716 1717 1718 1719 1720 1721
		if (dquots[cnt]) {
			struct dquot *dquot = dquots[cnt];

			if (WARN_ON_ONCE(dquot->dq_dqb.dqb_rsvspace < number))
				number = dquot->dq_dqb.dqb_rsvspace;
			dquot->dq_dqb.dqb_curspace += number;
			dquot->dq_dqb.dqb_rsvspace -= number;
		}
1722 1723
	}
	/* Update inode bytes */
1724 1725 1726 1727
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) -= number;
	__inode_add_bytes(inode, number);
	spin_unlock(&inode->i_lock);
1728
	spin_unlock(&dq_data_lock);
1729
	mark_all_dquot_dirty(dquots);
N
Niu Yawei 已提交
1730
	srcu_read_unlock(&dquot_srcu, index);
1731
	return 0;
1732
}
1733
EXPORT_SYMBOL(dquot_claim_space_nodirty);
1734

1735 1736 1737 1738 1739
/*
 * Convert allocated space back to in-memory reserved quotas
 */
void dquot_reclaim_space_nodirty(struct inode *inode, qsize_t number)
{
1740
	struct dquot **dquots;
N
Niu Yawei 已提交
1741
	int cnt, index;
1742 1743

	if (!dquot_active(inode)) {
1744 1745 1746 1747
		spin_lock(&inode->i_lock);
		*inode_reserved_space(inode) += number;
		__inode_sub_bytes(inode, number);
		spin_unlock(&inode->i_lock);
1748 1749 1750
		return;
	}

1751
	dquots = i_dquot(inode);
N
Niu Yawei 已提交
1752
	index = srcu_read_lock(&dquot_srcu);
1753 1754 1755
	spin_lock(&dq_data_lock);
	/* Claim reserved quotas to allocated quotas */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1756 1757 1758 1759 1760 1761 1762 1763
		if (dquots[cnt]) {
			struct dquot *dquot = dquots[cnt];

			if (WARN_ON_ONCE(dquot->dq_dqb.dqb_curspace < number))
				number = dquot->dq_dqb.dqb_curspace;
			dquot->dq_dqb.dqb_rsvspace += number;
			dquot->dq_dqb.dqb_curspace -= number;
		}
1764 1765
	}
	/* Update inode bytes */
1766 1767 1768 1769
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) += number;
	__inode_sub_bytes(inode, number);
	spin_unlock(&inode->i_lock);
1770
	spin_unlock(&dq_data_lock);
1771
	mark_all_dquot_dirty(dquots);
N
Niu Yawei 已提交
1772
	srcu_read_unlock(&dquot_srcu, index);
1773 1774 1775 1776
	return;
}
EXPORT_SYMBOL(dquot_reclaim_space_nodirty);

L
Linus Torvalds 已提交
1777 1778 1779
/*
 * This operation can block, but only after everything is updated
 */
1780
void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
L
Linus Torvalds 已提交
1781 1782
{
	unsigned int cnt;
1783
	struct dquot_warn warn[MAXQUOTAS];
1784
	struct dquot **dquots;
N
Niu Yawei 已提交
1785
	int reserve = flags & DQUOT_SPACE_RESERVE, index;
L
Linus Torvalds 已提交
1786

1787
	if (!dquot_active(inode)) {
1788 1789 1790 1791 1792 1793 1794
		if (reserve) {
			spin_lock(&inode->i_lock);
			*inode_reserved_space(inode) -= number;
			spin_unlock(&inode->i_lock);
		} else {
			inode_sub_bytes(inode, number);
		}
1795
		return;
L
Linus Torvalds 已提交
1796
	}
1797

1798
	dquots = i_dquot(inode);
N
Niu Yawei 已提交
1799
	index = srcu_read_lock(&dquot_srcu);
L
Linus Torvalds 已提交
1800 1801
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1802 1803 1804 1805
		int wtype;

		warn[cnt].w_type = QUOTA_NL_NOWARN;
		if (!dquots[cnt])
L
Linus Torvalds 已提交
1806
			continue;
1807 1808 1809
		wtype = info_bdq_free(dquots[cnt], number);
		if (wtype != QUOTA_NL_NOWARN)
			prepare_warning(&warn[cnt], dquots[cnt], wtype);
1810
		if (reserve)
1811
			dquot_free_reserved_space(dquots[cnt], number);
1812
		else
1813
			dquot_decr_space(dquots[cnt], number);
L
Linus Torvalds 已提交
1814
	}
1815 1816 1817 1818 1819 1820 1821
	if (reserve) {
		spin_lock(&inode->i_lock);
		*inode_reserved_space(inode) -= number;
		spin_unlock(&inode->i_lock);
	} else {
		inode_sub_bytes(inode, number);
	}
L
Linus Torvalds 已提交
1822
	spin_unlock(&dq_data_lock);
1823 1824 1825

	if (reserve)
		goto out_unlock;
1826
	mark_all_dquot_dirty(dquots);
1827
out_unlock:
N
Niu Yawei 已提交
1828
	srcu_read_unlock(&dquot_srcu, index);
1829
	flush_warnings(warn);
1830
}
1831
EXPORT_SYMBOL(__dquot_free_space);
1832

L
Linus Torvalds 已提交
1833 1834 1835
/*
 * This operation can block, but only after everything is updated
 */
1836
void dquot_free_inode(struct inode *inode)
L
Linus Torvalds 已提交
1837 1838
{
	unsigned int cnt;
1839
	struct dquot_warn warn[MAXQUOTAS];
1840
	struct dquot * const *dquots;
N
Niu Yawei 已提交
1841
	int index;
L
Linus Torvalds 已提交
1842

1843
	if (!dquot_active(inode))
1844
		return;
1845

1846
	dquots = i_dquot(inode);
N
Niu Yawei 已提交
1847
	index = srcu_read_lock(&dquot_srcu);
L
Linus Torvalds 已提交
1848 1849
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1850 1851 1852 1853
		int wtype;

		warn[cnt].w_type = QUOTA_NL_NOWARN;
		if (!dquots[cnt])
L
Linus Torvalds 已提交
1854
			continue;
1855 1856 1857 1858
		wtype = info_idq_free(dquots[cnt], 1);
		if (wtype != QUOTA_NL_NOWARN)
			prepare_warning(&warn[cnt], dquots[cnt], wtype);
		dquot_decr_inodes(dquots[cnt], 1);
L
Linus Torvalds 已提交
1859 1860
	}
	spin_unlock(&dq_data_lock);
1861
	mark_all_dquot_dirty(dquots);
N
Niu Yawei 已提交
1862
	srcu_read_unlock(&dquot_srcu, index);
1863
	flush_warnings(warn);
L
Linus Torvalds 已提交
1864
}
1865
EXPORT_SYMBOL(dquot_free_inode);
L
Linus Torvalds 已提交
1866 1867 1868

/*
 * Transfer the number of inode and blocks from one diskquota to an other.
1869 1870 1871
 * On success, dquot references in transfer_to are consumed and references
 * to original dquots that need to be released are placed there. On failure,
 * references are kept untouched.
L
Linus Torvalds 已提交
1872 1873 1874
 *
 * This operation can block, but only after everything is updated
 * A transaction must be started when entering this function.
1875
 *
N
Niu Yawei 已提交
1876 1877
 * We are holding reference on transfer_from & transfer_to, no need to
 * protect them by srcu_read_lock().
L
Linus Torvalds 已提交
1878
 */
1879
int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
L
Linus Torvalds 已提交
1880
{
1881 1882
	qsize_t space, cur_space;
	qsize_t rsv_space = 0;
1883
	qsize_t inode_usage = 1;
1884
	struct dquot *transfer_from[MAXQUOTAS] = {};
1885
	int cnt, ret = 0;
1886
	char is_valid[MAXQUOTAS] = {};
1887 1888 1889
	struct dquot_warn warn_to[MAXQUOTAS];
	struct dquot_warn warn_from_inodes[MAXQUOTAS];
	struct dquot_warn warn_from_space[MAXQUOTAS];
L
Linus Torvalds 已提交
1890 1891

	if (IS_NOQUOTA(inode))
1892
		return 0;
1893 1894 1895 1896 1897 1898 1899

	if (inode->i_sb->dq_op->get_inode_usage) {
		ret = inode->i_sb->dq_op->get_inode_usage(inode, &inode_usage);
		if (ret)
			return ret;
	}

J
Jan Kara 已提交
1900
	/* Initialize the arrays */
1901 1902 1903 1904 1905
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		warn_to[cnt].w_type = QUOTA_NL_NOWARN;
		warn_from_inodes[cnt].w_type = QUOTA_NL_NOWARN;
		warn_from_space[cnt].w_type = QUOTA_NL_NOWARN;
	}
N
Niu Yawei 已提交
1906 1907

	spin_lock(&dq_data_lock);
J
Jan Kara 已提交
1908
	if (IS_NOQUOTA(inode)) {	/* File without quota accounting? */
N
Niu Yawei 已提交
1909
		spin_unlock(&dq_data_lock);
1910
		return 0;
J
Jan Kara 已提交
1911
	}
1912
	cur_space = inode_get_bytes(inode);
1913
	rsv_space = inode_get_rsv_space(inode);
1914
	space = cur_space + rsv_space;
L
Linus Torvalds 已提交
1915 1916
	/* Build the transfer_from list and check the limits */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1917 1918 1919
		/*
		 * Skip changes for same uid or gid or for turned off quota-type.
		 */
J
Jan Kara 已提交
1920
		if (!transfer_to[cnt])
L
Linus Torvalds 已提交
1921
			continue;
1922 1923 1924 1925
		/* Avoid races with quotaoff() */
		if (!sb_has_quota_active(inode->i_sb, cnt))
			continue;
		is_valid[cnt] = 1;
1926
		transfer_from[cnt] = i_dquot(inode)[cnt];
1927
		ret = check_idq(transfer_to[cnt], inode_usage, &warn_to[cnt]);
1928 1929
		if (ret)
			goto over_quota;
1930
		ret = check_bdq(transfer_to[cnt], space, 0, &warn_to[cnt]);
1931
		if (ret)
J
Jan Kara 已提交
1932
			goto over_quota;
L
Linus Torvalds 已提交
1933 1934 1935 1936 1937 1938
	}

	/*
	 * Finally perform the needed transfer from transfer_from to transfer_to
	 */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1939
		if (!is_valid[cnt])
L
Linus Torvalds 已提交
1940 1941 1942
			continue;
		/* Due to IO error we might not have transfer_from[] structure */
		if (transfer_from[cnt]) {
1943
			int wtype;
1944
			wtype = info_idq_free(transfer_from[cnt], inode_usage);
1945 1946 1947 1948 1949 1950 1951
			if (wtype != QUOTA_NL_NOWARN)
				prepare_warning(&warn_from_inodes[cnt],
						transfer_from[cnt], wtype);
			wtype = info_bdq_free(transfer_from[cnt], space);
			if (wtype != QUOTA_NL_NOWARN)
				prepare_warning(&warn_from_space[cnt],
						transfer_from[cnt], wtype);
1952
			dquot_decr_inodes(transfer_from[cnt], inode_usage);
1953 1954 1955
			dquot_decr_space(transfer_from[cnt], cur_space);
			dquot_free_reserved_space(transfer_from[cnt],
						  rsv_space);
L
Linus Torvalds 已提交
1956 1957
		}

1958
		dquot_incr_inodes(transfer_to[cnt], inode_usage);
1959 1960
		dquot_incr_space(transfer_to[cnt], cur_space);
		dquot_resv_space(transfer_to[cnt], rsv_space);
L
Linus Torvalds 已提交
1961

1962
		i_dquot(inode)[cnt] = transfer_to[cnt];
L
Linus Torvalds 已提交
1963 1964
	}
	spin_unlock(&dq_data_lock);
J
Jan Kara 已提交
1965

1966 1967
	mark_all_dquot_dirty(transfer_from);
	mark_all_dquot_dirty(transfer_to);
1968 1969 1970
	flush_warnings(warn_to);
	flush_warnings(warn_from_inodes);
	flush_warnings(warn_from_space);
1971
	/* Pass back references to put */
1972
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1973 1974
		if (is_valid[cnt])
			transfer_to[cnt] = transfer_from[cnt];
1975
	return 0;
J
Jan Kara 已提交
1976 1977
over_quota:
	spin_unlock(&dq_data_lock);
1978
	flush_warnings(warn_to);
1979
	return ret;
L
Linus Torvalds 已提交
1980
}
1981
EXPORT_SYMBOL(__dquot_transfer);
L
Linus Torvalds 已提交
1982

1983 1984 1985
/* Wrapper for transferring ownership of an inode for uid/gid only
 * Called from FSXXX_setattr()
 */
1986
int dquot_transfer(struct inode *inode, struct iattr *iattr)
1987
{
1988
	struct dquot *transfer_to[MAXQUOTAS] = {};
1989
	struct dquot *dquot;
1990 1991
	struct super_block *sb = inode->i_sb;
	int ret;
1992

1993
	if (!dquot_active(inode))
1994
		return 0;
1995

1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017
	if (iattr->ia_valid & ATTR_UID && !uid_eq(iattr->ia_uid, inode->i_uid)){
		dquot = dqget(sb, make_kqid_uid(iattr->ia_uid));
		if (IS_ERR(dquot)) {
			if (PTR_ERR(dquot) != -ESRCH) {
				ret = PTR_ERR(dquot);
				goto out_put;
			}
			dquot = NULL;
		}
		transfer_to[USRQUOTA] = dquot;
	}
	if (iattr->ia_valid & ATTR_GID && !gid_eq(iattr->ia_gid, inode->i_gid)){
		dquot = dqget(sb, make_kqid_gid(iattr->ia_gid));
		if (IS_ERR(dquot)) {
			if (PTR_ERR(dquot) != -ESRCH) {
				ret = PTR_ERR(dquot);
				goto out_put;
			}
			dquot = NULL;
		}
		transfer_to[GRPQUOTA] = dquot;
	}
2018
	ret = __dquot_transfer(inode, transfer_to);
2019
out_put:
2020 2021
	dqput_all(transfer_to);
	return ret;
2022
}
2023
EXPORT_SYMBOL(dquot_transfer);
2024

L
Linus Torvalds 已提交
2025 2026 2027 2028 2029 2030 2031
/*
 * Write info of quota file to disk
 */
int dquot_commit_info(struct super_block *sb, int type)
{
	struct quota_info *dqopt = sb_dqopt(sb);

2032
	return dqopt->ops[type]->write_file_info(sb, type);
L
Linus Torvalds 已提交
2033
}
2034
EXPORT_SYMBOL(dquot_commit_info);
L
Linus Torvalds 已提交
2035

2036 2037 2038 2039
int dquot_get_next_id(struct super_block *sb, struct kqid *qid)
{
	struct quota_info *dqopt = sb_dqopt(sb);

2040 2041 2042 2043
	if (!sb_has_quota_active(sb, qid->type))
		return -ESRCH;
	if (!dqopt->ops[qid->type]->get_next_id)
		return -ENOSYS;
2044
	return dqopt->ops[qid->type]->get_next_id(sb, qid);
2045 2046 2047
}
EXPORT_SYMBOL(dquot_get_next_id);

L
Linus Torvalds 已提交
2048 2049 2050
/*
 * Definitions of diskquota operations.
 */
2051
const struct dquot_operations dquot_operations = {
L
Linus Torvalds 已提交
2052 2053 2054 2055
	.write_dquot	= dquot_commit,
	.acquire_dquot	= dquot_acquire,
	.release_dquot	= dquot_release,
	.mark_dirty	= dquot_mark_dquot_dirty,
2056 2057 2058
	.write_info	= dquot_commit_info,
	.alloc_dquot	= dquot_alloc,
	.destroy_dquot	= dquot_destroy,
2059
	.get_next_id	= dquot_get_next_id,
L
Linus Torvalds 已提交
2060
};
2061
EXPORT_SYMBOL(dquot_operations);
L
Linus Torvalds 已提交
2062

2063 2064 2065 2066 2067 2068 2069 2070 2071
/*
 * Generic helper for ->open on filesystems supporting disk quotas.
 */
int dquot_file_open(struct inode *inode, struct file *file)
{
	int error;

	error = generic_file_open(inode, file);
	if (!error && (file->f_mode & FMODE_WRITE))
2072
		dquot_initialize(inode);
2073 2074 2075 2076
	return error;
}
EXPORT_SYMBOL(dquot_file_open);

L
Linus Torvalds 已提交
2077 2078 2079
/*
 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
 */
2080
int dquot_disable(struct super_block *sb, int type, unsigned int flags)
L
Linus Torvalds 已提交
2081
{
2082
	int cnt, ret = 0;
L
Linus Torvalds 已提交
2083 2084 2085
	struct quota_info *dqopt = sb_dqopt(sb);
	struct inode *toputinode[MAXQUOTAS];

2086 2087 2088 2089
	/* s_umount should be held in exclusive mode */
	if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
		up_read(&sb->s_umount);

2090 2091 2092 2093 2094 2095 2096
	/* Cannot turn off usage accounting without turning off limits, or
	 * suspend quotas and simultaneously turn quotas off. */
	if ((flags & DQUOT_USAGE_ENABLED && !(flags & DQUOT_LIMITS_ENABLED))
	    || (flags & DQUOT_SUSPENDED && flags & (DQUOT_LIMITS_ENABLED |
	    DQUOT_USAGE_ENABLED)))
		return -EINVAL;

2097 2098 2099 2100 2101
	/*
	 * Skip everything if there's nothing to do. We have to do this because
	 * sometimes we are called when fill_super() failed and calling
	 * sync_fs() in such cases does no good.
	 */
J
Jan Kara 已提交
2102
	if (!sb_any_quota_loaded(sb))
2103
		return 0;
J
Jan Kara 已提交
2104

L
Linus Torvalds 已提交
2105 2106 2107 2108
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		toputinode[cnt] = NULL;
		if (type != -1 && cnt != type)
			continue;
2109
		if (!sb_has_quota_loaded(sb, cnt))
2110
			continue;
2111 2112

		if (flags & DQUOT_SUSPENDED) {
J
Jan Kara 已提交
2113
			spin_lock(&dq_state_lock);
2114 2115
			dqopt->flags |=
				dquot_state_flag(DQUOT_SUSPENDED, cnt);
J
Jan Kara 已提交
2116
			spin_unlock(&dq_state_lock);
2117
		} else {
J
Jan Kara 已提交
2118
			spin_lock(&dq_state_lock);
2119 2120 2121 2122 2123 2124
			dqopt->flags &= ~dquot_state_flag(flags, cnt);
			/* Turning off suspended quotas? */
			if (!sb_has_quota_loaded(sb, cnt) &&
			    sb_has_quota_suspended(sb, cnt)) {
				dqopt->flags &=	~dquot_state_flag(
							DQUOT_SUSPENDED, cnt);
J
Jan Kara 已提交
2125
				spin_unlock(&dq_state_lock);
2126 2127 2128 2129
				iput(dqopt->files[cnt]);
				dqopt->files[cnt] = NULL;
				continue;
			}
J
Jan Kara 已提交
2130
			spin_unlock(&dq_state_lock);
2131
		}
2132 2133 2134

		/* We still have to keep quota loaded? */
		if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
L
Linus Torvalds 已提交
2135 2136 2137 2138 2139 2140
			continue;

		/* Note: these are blocking operations */
		drop_dquot_ref(sb, cnt);
		invalidate_dquots(sb, cnt);
		/*
J
Jan Kara 已提交
2141 2142
		 * Now all dquots should be invalidated, all writes done so we
		 * should be only users of the info. No locks needed.
L
Linus Torvalds 已提交
2143 2144 2145 2146 2147 2148 2149 2150
		 */
		if (info_dirty(&dqopt->info[cnt]))
			sb->dq_op->write_info(sb, cnt);
		if (dqopt->ops[cnt]->free_file_info)
			dqopt->ops[cnt]->free_file_info(sb, cnt);
		put_quota_format(dqopt->info[cnt].dqi_format);

		toputinode[cnt] = dqopt->files[cnt];
2151
		if (!sb_has_quota_loaded(sb, cnt))
2152
			dqopt->files[cnt] = NULL;
L
Linus Torvalds 已提交
2153 2154 2155 2156 2157
		dqopt->info[cnt].dqi_flags = 0;
		dqopt->info[cnt].dqi_igrace = 0;
		dqopt->info[cnt].dqi_bgrace = 0;
		dqopt->ops[cnt] = NULL;
	}
2158 2159 2160 2161 2162

	/* Skip syncing and setting flags if quota files are hidden */
	if (dqopt->flags & DQUOT_QUOTA_SYS_FILE)
		goto put_inodes;

L
Linus Torvalds 已提交
2163
	/* Sync the superblock so that buffers with quota data are written to
2164
	 * disk (and so userspace sees correct data afterwards). */
L
Linus Torvalds 已提交
2165 2166 2167 2168 2169 2170 2171 2172 2173
	if (sb->s_op->sync_fs)
		sb->s_op->sync_fs(sb, 1);
	sync_blockdev(sb->s_bdev);
	/* Now the quota files are just ordinary files and we can set the
	 * inode flags back. Moreover we discard the pagecache so that
	 * userspace sees the writes we did bypassing the pagecache. We
	 * must also discard the blockdev buffers so that we see the
	 * changes done by userspace on the next quotaon() */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
2174 2175
		/* This can happen when suspending quotas on remount-ro... */
		if (toputinode[cnt] && !sb_has_quota_loaded(sb, cnt)) {
J
Jan Kara 已提交
2176
			inode_lock(toputinode[cnt]);
2177
			toputinode[cnt]->i_flags &= ~S_NOQUOTA;
J
Jan Kara 已提交
2178 2179 2180
			truncate_inode_pages(&toputinode[cnt]->i_data, 0);
			inode_unlock(toputinode[cnt]);
			mark_inode_dirty_sync(toputinode[cnt]);
2181 2182 2183 2184 2185 2186
		}
	if (sb->s_bdev)
		invalidate_bdev(sb->s_bdev);
put_inodes:
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
		if (toputinode[cnt]) {
2187
			/* On remount RO, we keep the inode pointer so that we
2188 2189 2190 2191 2192 2193 2194
			 * can reenable quota on the subsequent remount RW. We
			 * have to check 'flags' variable and not use sb_has_
			 * function because another quotaon / quotaoff could
			 * change global state before we got here. We refuse
			 * to suspend quotas when there is pending delete on
			 * the quota file... */
			if (!(flags & DQUOT_SUSPENDED))
2195 2196 2197
				iput(toputinode[cnt]);
			else if (!toputinode[cnt]->i_nlink)
				ret = -EBUSY;
L
Linus Torvalds 已提交
2198
		}
2199
	return ret;
L
Linus Torvalds 已提交
2200
}
2201
EXPORT_SYMBOL(dquot_disable);
L
Linus Torvalds 已提交
2202

2203
int dquot_quota_off(struct super_block *sb, int type)
2204
{
2205 2206
	return dquot_disable(sb, type,
			     DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2207
}
2208
EXPORT_SYMBOL(dquot_quota_off);
2209

L
Linus Torvalds 已提交
2210 2211 2212 2213
/*
 *	Turn quotas on on a device
 */

2214 2215 2216 2217 2218 2219
/*
 * Helper function to turn quotas on when we already have the inode of
 * quota file and no quota information is loaded.
 */
static int vfs_load_quota_inode(struct inode *inode, int type, int format_id,
	unsigned int flags)
L
Linus Torvalds 已提交
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
{
	struct quota_format_type *fmt = find_quota_format(format_id);
	struct super_block *sb = inode->i_sb;
	struct quota_info *dqopt = sb_dqopt(sb);
	int error;

	if (!fmt)
		return -ESRCH;
	if (!S_ISREG(inode->i_mode)) {
		error = -EACCES;
		goto out_fmt;
	}
	if (IS_RDONLY(inode)) {
		error = -EROFS;
		goto out_fmt;
	}
2236 2237
	if (!sb->s_op->quota_write || !sb->s_op->quota_read ||
	    (type == PRJQUOTA && sb->dq_op->get_projid == NULL)) {
L
Linus Torvalds 已提交
2238 2239 2240
		error = -EINVAL;
		goto out_fmt;
	}
2241 2242 2243 2244 2245
	/* Filesystems outside of init_user_ns not yet supported */
	if (sb->s_user_ns != &init_user_ns) {
		error = -EINVAL;
		goto out_fmt;
	}
2246 2247 2248 2249 2250
	/* Usage always has to be set... */
	if (!(flags & DQUOT_USAGE_ENABLED)) {
		error = -EINVAL;
		goto out_fmt;
	}
J
Jan Kara 已提交
2251 2252 2253 2254
	if (sb_has_quota_loaded(sb, type)) {
		error = -EBUSY;
		goto out_fmt;
	}
L
Linus Torvalds 已提交
2255

2256
	if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2257 2258 2259 2260 2261 2262 2263
		/* As we bypass the pagecache we must now flush all the
		 * dirty data and invalidate caches so that kernel sees
		 * changes from userspace. It is not enough to just flush
		 * the quota file since if blocksize < pagesize, invalidation
		 * of the cache could fail because of other unrelated dirty
		 * data */
		sync_filesystem(sb);
2264 2265 2266 2267 2268 2269 2270
		invalidate_bdev(sb->s_bdev);
	}

	if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
		/* We don't want quota and atime on quota files (deadlocks
		 * possible) Also nobody should write to the file - we use
		 * special IO operations which ignore the immutable bit. */
A
Al Viro 已提交
2271
		inode_lock(inode);
2272
		inode->i_flags |= S_NOQUOTA;
A
Al Viro 已提交
2273
		inode_unlock(inode);
J
Jan Kara 已提交
2274 2275 2276 2277
		/*
		 * When S_NOQUOTA is set, remove dquot references as no more
		 * references can be added
		 */
2278
		__dquot_drop(inode);
2279
	}
L
Linus Torvalds 已提交
2280 2281 2282 2283

	error = -EIO;
	dqopt->files[type] = igrab(inode);
	if (!dqopt->files[type])
J
Jan Kara 已提交
2284
		goto out_file_flags;
L
Linus Torvalds 已提交
2285 2286 2287 2288 2289 2290
	error = -EINVAL;
	if (!fmt->qf_ops->check_quota_file(sb, type))
		goto out_file_init;

	dqopt->ops[type] = fmt->qf_ops;
	dqopt->info[type].dqi_format = fmt;
2291
	dqopt->info[type].dqi_fmt_id = format_id;
L
Linus Torvalds 已提交
2292
	INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
J
Jan Kara 已提交
2293
	error = dqopt->ops[type]->read_file_info(sb, type);
2294
	if (error < 0)
L
Linus Torvalds 已提交
2295
		goto out_file_init;
2296 2297
	if (dqopt->flags & DQUOT_QUOTA_SYS_FILE) {
		spin_lock(&dq_data_lock);
2298
		dqopt->info[type].dqi_flags |= DQF_SYS_FILE;
2299 2300
		spin_unlock(&dq_data_lock);
	}
J
Jan Kara 已提交
2301
	spin_lock(&dq_state_lock);
2302
	dqopt->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2303
	spin_unlock(&dq_state_lock);
L
Linus Torvalds 已提交
2304 2305 2306 2307 2308 2309 2310 2311

	add_dquot_ref(sb, type);

	return 0;

out_file_init:
	dqopt->files[type] = NULL;
	iput(inode);
J
Jan Kara 已提交
2312
out_file_flags:
2313 2314 2315
	inode_lock(inode);
	inode->i_flags &= ~S_NOQUOTA;
	inode_unlock(inode);
L
Linus Torvalds 已提交
2316 2317 2318 2319 2320 2321
out_fmt:
	put_quota_format(fmt);

	return error; 
}

2322
/* Reenable quotas on remount RW */
2323
int dquot_resume(struct super_block *sb, int type)
2324 2325 2326
{
	struct quota_info *dqopt = sb_dqopt(sb);
	struct inode *inode;
2327
	int ret = 0, cnt;
2328
	unsigned int flags;
2329

2330 2331 2332 2333
	/* s_umount should be held in exclusive mode */
	if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
		up_read(&sb->s_umount);

2334 2335 2336
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
J
Jan Kara 已提交
2337
		if (!sb_has_quota_suspended(sb, cnt))
2338
			continue;
J
Jan Kara 已提交
2339

2340 2341 2342 2343 2344 2345 2346 2347
		inode = dqopt->files[cnt];
		dqopt->files[cnt] = NULL;
		spin_lock(&dq_state_lock);
		flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
							DQUOT_LIMITS_ENABLED,
							cnt);
		dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, cnt);
		spin_unlock(&dq_state_lock);
2348

2349 2350 2351 2352 2353
		flags = dquot_generic_flag(flags, cnt);
		ret = vfs_load_quota_inode(inode, cnt,
				dqopt->info[cnt].dqi_fmt_id, flags);
		iput(inode);
	}
2354 2355 2356

	return ret;
}
2357
EXPORT_SYMBOL(dquot_resume);
2358

2359
int dquot_quota_on(struct super_block *sb, int type, int format_id,
A
Al Viro 已提交
2360
		   const struct path *path)
2361 2362 2363 2364 2365
{
	int error = security_quota_on(path->dentry);
	if (error)
		return error;
	/* Quota file not on the same filesystem? */
2366
	if (path->dentry->d_sb != sb)
2367 2368
		error = -EXDEV;
	else
2369
		error = vfs_load_quota_inode(d_inode(path->dentry), type,
2370 2371
					     format_id, DQUOT_USAGE_ENABLED |
					     DQUOT_LIMITS_ENABLED);
2372 2373
	return error;
}
2374
EXPORT_SYMBOL(dquot_quota_on);
L
Linus Torvalds 已提交
2375

2376 2377 2378 2379
/*
 * More powerful function for turning on quotas allowing setting
 * of individual quota flags
 */
2380 2381
int dquot_enable(struct inode *inode, int type, int format_id,
		 unsigned int flags)
2382 2383 2384 2385
{
	struct super_block *sb = inode->i_sb;

	/* Just unsuspend quotas? */
2386
	BUG_ON(flags & DQUOT_SUSPENDED);
2387 2388 2389
	/* s_umount should be held in exclusive mode */
	if (WARN_ON_ONCE(down_read_trylock(&sb->s_umount)))
		up_read(&sb->s_umount);
2390

2391 2392 2393 2394 2395
	if (!flags)
		return 0;
	/* Just updating flags needed? */
	if (sb_has_quota_loaded(sb, type)) {
		if (flags & DQUOT_USAGE_ENABLED &&
J
Jan Kara 已提交
2396 2397
		    sb_has_quota_usage_enabled(sb, type))
			return -EBUSY;
2398
		if (flags & DQUOT_LIMITS_ENABLED &&
J
Jan Kara 已提交
2399 2400
		    sb_has_quota_limits_enabled(sb, type))
			return -EBUSY;
J
Jan Kara 已提交
2401
		spin_lock(&dq_state_lock);
2402
		sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2403
		spin_unlock(&dq_state_lock);
J
Jan Kara 已提交
2404
		return 0;
2405 2406 2407 2408
	}

	return vfs_load_quota_inode(inode, type, format_id, flags);
}
2409
EXPORT_SYMBOL(dquot_enable);
2410

L
Linus Torvalds 已提交
2411 2412 2413 2414
/*
 * This function is used when filesystem needs to initialize quotas
 * during mount time.
 */
2415
int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
2416
		int format_id, int type)
L
Linus Torvalds 已提交
2417
{
2418
	struct dentry *dentry;
L
Linus Torvalds 已提交
2419 2420
	int error;

A
Al Viro 已提交
2421
	dentry = lookup_one_len_unlocked(qf_name, sb->s_root, strlen(qf_name));
2422 2423 2424
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

2425
	if (d_really_is_negative(dentry)) {
J
Jan Kara 已提交
2426 2427 2428 2429
		error = -ENOENT;
		goto out;
	}

L
Linus Torvalds 已提交
2430
	error = security_quota_on(dentry);
2431
	if (!error)
2432
		error = vfs_load_quota_inode(d_inode(dentry), type, format_id,
2433
				DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2434

J
Jan Kara 已提交
2435
out:
2436 2437
	dput(dentry);
	return error;
L
Linus Torvalds 已提交
2438
}
2439
EXPORT_SYMBOL(dquot_quota_on_mount);
2440

2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
static int dquot_quota_enable(struct super_block *sb, unsigned int flags)
{
	int ret;
	int type;
	struct quota_info *dqopt = sb_dqopt(sb);

	if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
		return -ENOSYS;
	/* Accounting cannot be turned on while fs is mounted */
	flags &= ~(FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT);
	if (!flags)
		return -EINVAL;
	for (type = 0; type < MAXQUOTAS; type++) {
		if (!(flags & qtype_enforce_flag(type)))
			continue;
		/* Can't enforce without accounting */
		if (!sb_has_quota_usage_enabled(sb, type))
			return -EINVAL;
		ret = dquot_enable(dqopt->files[type], type,
				   dqopt->info[type].dqi_fmt_id,
				   DQUOT_LIMITS_ENABLED);
		if (ret < 0)
			goto out_err;
	}
	return 0;
out_err:
	/* Backout enforcement enablement we already did */
	for (type--; type >= 0; type--)  {
		if (flags & qtype_enforce_flag(type))
			dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
	}
	/* Error code translation for better compatibility with XFS */
	if (ret == -EBUSY)
		ret = -EEXIST;
	return ret;
}

static int dquot_quota_disable(struct super_block *sb, unsigned int flags)
{
	int ret;
	int type;
	struct quota_info *dqopt = sb_dqopt(sb);

	if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE))
		return -ENOSYS;
	/*
	 * We don't support turning off accounting via quotactl. In principle
	 * quota infrastructure can do this but filesystems don't expect
	 * userspace to be able to do it.
	 */
	if (flags &
		  (FS_QUOTA_UDQ_ACCT | FS_QUOTA_GDQ_ACCT | FS_QUOTA_PDQ_ACCT))
		return -EOPNOTSUPP;

	/* Filter out limits not enabled */
	for (type = 0; type < MAXQUOTAS; type++)
		if (!sb_has_quota_limits_enabled(sb, type))
			flags &= ~qtype_enforce_flag(type);
	/* Nothing left? */
	if (!flags)
		return -EEXIST;
	for (type = 0; type < MAXQUOTAS; type++) {
		if (flags & qtype_enforce_flag(type)) {
			ret = dquot_disable(sb, type, DQUOT_LIMITS_ENABLED);
			if (ret < 0)
				goto out_err;
		}
	}
	return 0;
out_err:
	/* Backout enforcement disabling we already did */
	for (type--; type >= 0; type--)  {
		if (flags & qtype_enforce_flag(type))
			dquot_enable(dqopt->files[type], type,
				     dqopt->info[type].dqi_fmt_id,
				     DQUOT_LIMITS_ENABLED);
	}
	return ret;
}

L
Linus Torvalds 已提交
2521
/* Generic routine for getting common part of quota structure */
2522
static void do_get_dqblk(struct dquot *dquot, struct qc_dqblk *di)
L
Linus Torvalds 已提交
2523 2524 2525
{
	struct mem_dqblk *dm = &dquot->dq_dqb;

C
Christoph Hellwig 已提交
2526
	memset(di, 0, sizeof(*di));
L
Linus Torvalds 已提交
2527
	spin_lock(&dq_data_lock);
2528 2529
	di->d_spc_hardlimit = dm->dqb_bhardlimit;
	di->d_spc_softlimit = dm->dqb_bsoftlimit;
C
Christoph Hellwig 已提交
2530 2531
	di->d_ino_hardlimit = dm->dqb_ihardlimit;
	di->d_ino_softlimit = dm->dqb_isoftlimit;
2532 2533 2534 2535
	di->d_space = dm->dqb_curspace + dm->dqb_rsvspace;
	di->d_ino_count = dm->dqb_curinodes;
	di->d_spc_timer = dm->dqb_btime;
	di->d_ino_timer = dm->dqb_itime;
L
Linus Torvalds 已提交
2536 2537 2538
	spin_unlock(&dq_data_lock);
}

E
Eric W. Biederman 已提交
2539
int dquot_get_dqblk(struct super_block *sb, struct kqid qid,
2540
		    struct qc_dqblk *di)
L
Linus Torvalds 已提交
2541 2542 2543
{
	struct dquot *dquot;

2544
	dquot = dqget(sb, qid);
2545 2546
	if (IS_ERR(dquot))
		return PTR_ERR(dquot);
L
Linus Torvalds 已提交
2547 2548
	do_get_dqblk(dquot, di);
	dqput(dquot);
J
Jan Kara 已提交
2549

L
Linus Torvalds 已提交
2550 2551
	return 0;
}
2552
EXPORT_SYMBOL(dquot_get_dqblk);
L
Linus Torvalds 已提交
2553

2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574
int dquot_get_next_dqblk(struct super_block *sb, struct kqid *qid,
			 struct qc_dqblk *di)
{
	struct dquot *dquot;
	int err;

	if (!sb->dq_op->get_next_id)
		return -ENOSYS;
	err = sb->dq_op->get_next_id(sb, qid);
	if (err < 0)
		return err;
	dquot = dqget(sb, *qid);
	if (IS_ERR(dquot))
		return PTR_ERR(dquot);
	do_get_dqblk(dquot, di);
	dqput(dquot);

	return 0;
}
EXPORT_SYMBOL(dquot_get_next_dqblk);

2575 2576 2577 2578
#define VFS_QC_MASK \
	(QC_SPACE | QC_SPC_SOFT | QC_SPC_HARD | \
	 QC_INO_COUNT | QC_INO_SOFT | QC_INO_HARD | \
	 QC_SPC_TIMER | QC_INO_TIMER)
C
Christoph Hellwig 已提交
2579

L
Linus Torvalds 已提交
2580
/* Generic routine for setting common part of quota structure */
2581
static int do_set_dqblk(struct dquot *dquot, struct qc_dqblk *di)
L
Linus Torvalds 已提交
2582 2583 2584
{
	struct mem_dqblk *dm = &dquot->dq_dqb;
	int check_blim = 0, check_ilim = 0;
2585
	struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_id.type];
2586

2587
	if (di->d_fieldmask & ~VFS_QC_MASK)
C
Christoph Hellwig 已提交
2588 2589
		return -EINVAL;

2590
	if (((di->d_fieldmask & QC_SPC_SOFT) &&
2591
	     di->d_spc_softlimit > dqi->dqi_max_spc_limit) ||
2592
	    ((di->d_fieldmask & QC_SPC_HARD) &&
2593
	     di->d_spc_hardlimit > dqi->dqi_max_spc_limit) ||
2594
	    ((di->d_fieldmask & QC_INO_SOFT) &&
2595
	     (di->d_ino_softlimit > dqi->dqi_max_ino_limit)) ||
2596
	    ((di->d_fieldmask & QC_INO_HARD) &&
2597
	     (di->d_ino_hardlimit > dqi->dqi_max_ino_limit)))
2598
		return -ERANGE;
L
Linus Torvalds 已提交
2599 2600

	spin_lock(&dq_data_lock);
2601 2602
	if (di->d_fieldmask & QC_SPACE) {
		dm->dqb_curspace = di->d_space - dm->dqb_rsvspace;
L
Linus Torvalds 已提交
2603
		check_blim = 1;
2604
		set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2605
	}
C
Christoph Hellwig 已提交
2606

2607 2608 2609 2610 2611
	if (di->d_fieldmask & QC_SPC_SOFT)
		dm->dqb_bsoftlimit = di->d_spc_softlimit;
	if (di->d_fieldmask & QC_SPC_HARD)
		dm->dqb_bhardlimit = di->d_spc_hardlimit;
	if (di->d_fieldmask & (QC_SPC_SOFT | QC_SPC_HARD)) {
L
Linus Torvalds 已提交
2612
		check_blim = 1;
2613
		set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2614
	}
C
Christoph Hellwig 已提交
2615

2616 2617
	if (di->d_fieldmask & QC_INO_COUNT) {
		dm->dqb_curinodes = di->d_ino_count;
L
Linus Torvalds 已提交
2618
		check_ilim = 1;
2619
		set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2620
	}
C
Christoph Hellwig 已提交
2621

2622
	if (di->d_fieldmask & QC_INO_SOFT)
C
Christoph Hellwig 已提交
2623
		dm->dqb_isoftlimit = di->d_ino_softlimit;
2624
	if (di->d_fieldmask & QC_INO_HARD)
C
Christoph Hellwig 已提交
2625
		dm->dqb_ihardlimit = di->d_ino_hardlimit;
2626
	if (di->d_fieldmask & (QC_INO_SOFT | QC_INO_HARD)) {
L
Linus Torvalds 已提交
2627
		check_ilim = 1;
2628
		set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2629
	}
C
Christoph Hellwig 已提交
2630

2631 2632
	if (di->d_fieldmask & QC_SPC_TIMER) {
		dm->dqb_btime = di->d_spc_timer;
2633
		check_blim = 1;
2634
		set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
2635
	}
C
Christoph Hellwig 已提交
2636

2637 2638
	if (di->d_fieldmask & QC_INO_TIMER) {
		dm->dqb_itime = di->d_ino_timer;
2639
		check_ilim = 1;
2640
		set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
2641
	}
L
Linus Torvalds 已提交
2642 2643

	if (check_blim) {
J
Jan Kara 已提交
2644 2645
		if (!dm->dqb_bsoftlimit ||
		    dm->dqb_curspace < dm->dqb_bsoftlimit) {
L
Linus Torvalds 已提交
2646 2647
			dm->dqb_btime = 0;
			clear_bit(DQ_BLKS_B, &dquot->dq_flags);
2648
		} else if (!(di->d_fieldmask & QC_SPC_TIMER))
J
Jan Kara 已提交
2649
			/* Set grace only if user hasn't provided his own... */
A
Arnd Bergmann 已提交
2650
			dm->dqb_btime = ktime_get_real_seconds() + dqi->dqi_bgrace;
L
Linus Torvalds 已提交
2651 2652
	}
	if (check_ilim) {
J
Jan Kara 已提交
2653 2654
		if (!dm->dqb_isoftlimit ||
		    dm->dqb_curinodes < dm->dqb_isoftlimit) {
L
Linus Torvalds 已提交
2655 2656
			dm->dqb_itime = 0;
			clear_bit(DQ_INODES_B, &dquot->dq_flags);
2657
		} else if (!(di->d_fieldmask & QC_INO_TIMER))
J
Jan Kara 已提交
2658
			/* Set grace only if user hasn't provided his own... */
A
Arnd Bergmann 已提交
2659
			dm->dqb_itime = ktime_get_real_seconds() + dqi->dqi_igrace;
L
Linus Torvalds 已提交
2660
	}
J
Jan Kara 已提交
2661 2662
	if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
	    dm->dqb_isoftlimit)
L
Linus Torvalds 已提交
2663 2664 2665 2666 2667
		clear_bit(DQ_FAKE_B, &dquot->dq_flags);
	else
		set_bit(DQ_FAKE_B, &dquot->dq_flags);
	spin_unlock(&dq_data_lock);
	mark_dquot_dirty(dquot);
2668 2669

	return 0;
L
Linus Torvalds 已提交
2670 2671
}

E
Eric W. Biederman 已提交
2672
int dquot_set_dqblk(struct super_block *sb, struct kqid qid,
2673
		  struct qc_dqblk *di)
L
Linus Torvalds 已提交
2674 2675
{
	struct dquot *dquot;
2676
	int rc;
L
Linus Torvalds 已提交
2677

2678
	dquot = dqget(sb, qid);
2679 2680
	if (IS_ERR(dquot)) {
		rc = PTR_ERR(dquot);
2681
		goto out;
L
Linus Torvalds 已提交
2682
	}
2683
	rc = do_set_dqblk(dquot, di);
L
Linus Torvalds 已提交
2684
	dqput(dquot);
2685
out:
2686
	return rc;
L
Linus Torvalds 已提交
2687
}
2688
EXPORT_SYMBOL(dquot_set_dqblk);
L
Linus Torvalds 已提交
2689 2690

/* Generic routine for getting common part of quota file information */
2691
int dquot_get_state(struct super_block *sb, struct qc_state *state)
L
Linus Torvalds 已提交
2692 2693
{
	struct mem_dqinfo *mi;
2694 2695 2696
	struct qc_type_state *tstate;
	struct quota_info *dqopt = sb_dqopt(sb);
	int type;
L
Linus Torvalds 已提交
2697
  
2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717
	memset(state, 0, sizeof(*state));
	for (type = 0; type < MAXQUOTAS; type++) {
		if (!sb_has_quota_active(sb, type))
			continue;
		tstate = state->s_state + type;
		mi = sb_dqopt(sb)->info + type;
		tstate->flags = QCI_ACCT_ENABLED;
		spin_lock(&dq_data_lock);
		if (mi->dqi_flags & DQF_SYS_FILE)
			tstate->flags |= QCI_SYSFILE;
		if (mi->dqi_flags & DQF_ROOT_SQUASH)
			tstate->flags |= QCI_ROOT_SQUASH;
		if (sb_has_quota_limits_enabled(sb, type))
			tstate->flags |= QCI_LIMITS_ENFORCED;
		tstate->spc_timelimit = mi->dqi_bgrace;
		tstate->ino_timelimit = mi->dqi_igrace;
		tstate->ino = dqopt->files[type]->i_ino;
		tstate->blocks = dqopt->files[type]->i_blocks;
		tstate->nextents = 1;	/* We don't know... */
		spin_unlock(&dq_data_lock);
L
Linus Torvalds 已提交
2718 2719 2720
	}
	return 0;
}
2721
EXPORT_SYMBOL(dquot_get_state);
L
Linus Torvalds 已提交
2722 2723

/* Generic routine for setting common part of quota file information */
2724
int dquot_set_dqinfo(struct super_block *sb, int type, struct qc_info *ii)
L
Linus Torvalds 已提交
2725 2726
{
	struct mem_dqinfo *mi;
2727
	int err = 0;
L
Linus Torvalds 已提交
2728

2729 2730 2731
	if ((ii->i_fieldmask & QC_WARNS_MASK) ||
	    (ii->i_fieldmask & QC_RT_SPC_TIMER))
		return -EINVAL;
2732 2733
	if (!sb_has_quota_active(sb, type))
		return -ESRCH;
L
Linus Torvalds 已提交
2734
	mi = sb_dqopt(sb)->info + type;
2735 2736
	if (ii->i_fieldmask & QC_FLAGS) {
		if ((ii->i_flags & QCI_ROOT_SQUASH &&
2737 2738
		     mi->dqi_format->qf_fmt_id != QFMT_VFS_OLD))
			return -EINVAL;
2739
	}
L
Linus Torvalds 已提交
2740
	spin_lock(&dq_data_lock);
2741 2742 2743 2744 2745 2746 2747 2748 2749 2750
	if (ii->i_fieldmask & QC_SPC_TIMER)
		mi->dqi_bgrace = ii->i_spc_timelimit;
	if (ii->i_fieldmask & QC_INO_TIMER)
		mi->dqi_igrace = ii->i_ino_timelimit;
	if (ii->i_fieldmask & QC_FLAGS) {
		if (ii->i_flags & QCI_ROOT_SQUASH)
			mi->dqi_flags |= DQF_ROOT_SQUASH;
		else
			mi->dqi_flags &= ~DQF_ROOT_SQUASH;
	}
L
Linus Torvalds 已提交
2751 2752 2753 2754
	spin_unlock(&dq_data_lock);
	mark_info_dirty(sb, type);
	/* Force write to disk */
	sb->dq_op->write_info(sb, type);
2755
	return err;
L
Linus Torvalds 已提交
2756
}
2757
EXPORT_SYMBOL(dquot_set_dqinfo);
L
Linus Torvalds 已提交
2758

2759 2760 2761 2762
const struct quotactl_ops dquot_quotactl_sysfile_ops = {
	.quota_enable	= dquot_quota_enable,
	.quota_disable	= dquot_quota_disable,
	.quota_sync	= dquot_quota_sync,
2763
	.get_state	= dquot_get_state,
2764 2765
	.set_info	= dquot_set_dqinfo,
	.get_dqblk	= dquot_get_dqblk,
2766
	.get_nextdqblk	= dquot_get_next_dqblk,
2767 2768 2769 2770
	.set_dqblk	= dquot_set_dqblk
};
EXPORT_SYMBOL(dquot_quotactl_sysfile_ops);

2771 2772 2773 2774
static int do_proc_dqstats(struct ctl_table *table, int write,
		     void __user *buffer, size_t *lenp, loff_t *ppos)
{
	unsigned int type = (int *)table->data - dqstats.stat;
2775 2776 2777 2778

	/* Update global table */
	dqstats.stat[type] =
			percpu_counter_sum_positive(&dqstats.counter[type]);
2779 2780 2781
	return proc_dointvec(table, write, buffer, lenp, ppos);
}

2782
static struct ctl_table fs_dqstats_table[] = {
L
Linus Torvalds 已提交
2783 2784
	{
		.procname	= "lookups",
2785
		.data		= &dqstats.stat[DQST_LOOKUPS],
L
Linus Torvalds 已提交
2786 2787
		.maxlen		= sizeof(int),
		.mode		= 0444,
2788
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2789 2790 2791
	},
	{
		.procname	= "drops",
2792
		.data		= &dqstats.stat[DQST_DROPS],
L
Linus Torvalds 已提交
2793 2794
		.maxlen		= sizeof(int),
		.mode		= 0444,
2795
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2796 2797 2798
	},
	{
		.procname	= "reads",
2799
		.data		= &dqstats.stat[DQST_READS],
L
Linus Torvalds 已提交
2800 2801
		.maxlen		= sizeof(int),
		.mode		= 0444,
2802
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2803 2804 2805
	},
	{
		.procname	= "writes",
2806
		.data		= &dqstats.stat[DQST_WRITES],
L
Linus Torvalds 已提交
2807 2808
		.maxlen		= sizeof(int),
		.mode		= 0444,
2809
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2810 2811 2812
	},
	{
		.procname	= "cache_hits",
2813
		.data		= &dqstats.stat[DQST_CACHE_HITS],
L
Linus Torvalds 已提交
2814 2815
		.maxlen		= sizeof(int),
		.mode		= 0444,
2816
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2817 2818 2819
	},
	{
		.procname	= "allocated_dquots",
2820
		.data		= &dqstats.stat[DQST_ALLOC_DQUOTS],
L
Linus Torvalds 已提交
2821 2822
		.maxlen		= sizeof(int),
		.mode		= 0444,
2823
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2824 2825 2826
	},
	{
		.procname	= "free_dquots",
2827
		.data		= &dqstats.stat[DQST_FREE_DQUOTS],
L
Linus Torvalds 已提交
2828 2829
		.maxlen		= sizeof(int),
		.mode		= 0444,
2830
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2831 2832 2833
	},
	{
		.procname	= "syncs",
2834
		.data		= &dqstats.stat[DQST_SYNCS],
L
Linus Torvalds 已提交
2835 2836
		.maxlen		= sizeof(int),
		.mode		= 0444,
2837
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2838
	},
J
Jan Kara 已提交
2839
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
2840 2841 2842 2843 2844
	{
		.procname	= "warnings",
		.data		= &flag_print_warnings,
		.maxlen		= sizeof(int),
		.mode		= 0644,
2845
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2846
	},
J
Jan Kara 已提交
2847
#endif
2848
	{ },
L
Linus Torvalds 已提交
2849 2850
};

2851
static struct ctl_table fs_table[] = {
L
Linus Torvalds 已提交
2852 2853 2854 2855 2856
	{
		.procname	= "quota",
		.mode		= 0555,
		.child		= fs_dqstats_table,
	},
2857
	{ },
L
Linus Torvalds 已提交
2858 2859
};

2860
static struct ctl_table sys_table[] = {
L
Linus Torvalds 已提交
2861 2862 2863 2864 2865
	{
		.procname	= "fs",
		.mode		= 0555,
		.child		= fs_table,
	},
2866
	{ },
L
Linus Torvalds 已提交
2867 2868 2869 2870
};

static int __init dquot_init(void)
{
2871
	int i, ret;
L
Linus Torvalds 已提交
2872 2873 2874 2875
	unsigned long nr_hash, order;

	printk(KERN_NOTICE "VFS: Disk quotas %s\n", __DQUOT_VERSION__);

2876
	register_sysctl_table(sys_table);
L
Linus Torvalds 已提交
2877

2878
	dquot_cachep = kmem_cache_create("dquot",
L
Linus Torvalds 已提交
2879
			sizeof(struct dquot), sizeof(unsigned long) * 4,
2880 2881
			(SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
				SLAB_MEM_SPREAD|SLAB_PANIC),
2882
			NULL);
L
Linus Torvalds 已提交
2883 2884 2885 2886 2887 2888

	order = 0;
	dquot_hash = (struct hlist_head *)__get_free_pages(GFP_ATOMIC, order);
	if (!dquot_hash)
		panic("Cannot create dquot hash table");

2889
	for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
2890
		ret = percpu_counter_init(&dqstats.counter[i], 0, GFP_KERNEL);
2891 2892 2893
		if (ret)
			panic("Cannot create dquot stat counters");
	}
2894

L
Linus Torvalds 已提交
2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907
	/* Find power-of-two hlist_heads which can fit into allocation */
	nr_hash = (1UL << order) * PAGE_SIZE / sizeof(struct hlist_head);
	dq_hash_bits = 0;
	do {
		dq_hash_bits++;
	} while (nr_hash >> dq_hash_bits);
	dq_hash_bits--;

	nr_hash = 1UL << dq_hash_bits;
	dq_hash_mask = nr_hash - 1;
	for (i = 0; i < nr_hash; i++)
		INIT_HLIST_HEAD(dquot_hash + i);

A
Anton Blanchard 已提交
2908 2909
	pr_info("VFS: Dquot-cache hash table entries: %ld (order %ld,"
		" %ld bytes)\n", nr_hash, order, (PAGE_SIZE << order));
L
Linus Torvalds 已提交
2910

2911
	register_shrinker(&dqcache_shrinker);
L
Linus Torvalds 已提交
2912 2913 2914

	return 0;
}
2915
fs_initcall(dquot_init);