dquot.c 72.0 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 74 75 76
/*
 * 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>
#include <linux/kmod.h>
#include <linux/namei.h>
#include <linux/buffer_head.h>
77
#include <linux/capability.h>
78
#include <linux/quotaops.h>
79
#include <linux/writeback.h> /* for inode_lock, oddly enough.. */
L
Linus Torvalds 已提交
80 81 82 83

#include <asm/uaccess.h>

/*
J
Jan Kara 已提交
84
 * There are three quota SMP locks. dq_list_lock protects all lists with quotas
85
 * and quota formats.
J
Jan Kara 已提交
86 87
 * 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 已提交
88
 * i_blocks and i_bytes updates itself are guarded by i_lock acquired directly
J
Jan Kara 已提交
89 90 91
 * 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 已提交
92
 *
J
Jan Kara 已提交
93 94
 * The spinlock ordering is hence: dq_data_lock > dq_list_lock > i_lock,
 *   dq_list_lock > dq_state_lock
L
Linus Torvalds 已提交
95 96 97 98 99 100
 *
 * 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
 *
 * Any operation working on dquots via inode pointers must hold dqptr_sem.  If
 * operation is just reading pointers from inode (or not using them at all) the
101 102 103 104 105 106 107
 * read lock is enough. If pointers are altered function must hold write lock.
 * 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
 * to check this flag under dqptr_sem and then (if S_NOQUOTA is not set) they
 * have to do all pointer modifications before dropping dqptr_sem. This makes
 * 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 已提交
108
 *
I
Ingo Molnar 已提交
109
 * Each dquot has its dq_lock mutex. Locked dquots might not be referenced
L
Linus Torvalds 已提交
110 111 112 113 114 115 116 117 118
 * from inodes (dquot_alloc_space() and such don't check the dq_lock).
 * Currently dquot is locked only when it is being read to memory (or space for
 * it is being allocated) on the first dqget() and when it is being released on
 * the last dqput(). The allocation and release oparations are serialized by
 * the dq_lock and by checking the use count in dquot_release().  Write
 * operations on dquots don't hold dq_lock as they copy data under dq_data_lock
 * spinlock to internal buffers before writing.
 *
 * Lock ordering (including related VFS locks) is the following:
I
Ingo Molnar 已提交
119 120
 *   i_mutex > dqonoff_sem > journal_lock > dqptr_sem > dquot->dq_lock >
 *   dqio_mutex
J
Jan Kara 已提交
121 122 123 124 125 126
 * The lock ordering of dqptr_sem imposed by quota code is only dqonoff_sem >
 * dqptr_sem. But filesystem has to count with the fact that functions such as
 * dquot_alloc_space() acquire dqptr_sem and they usually have to be called
 * from inside a transaction to keep filesystem consistency after a crash. Also
 * filesystems usually want to do some IO on dquot from ->mark_dirty which is
 * called with dqptr_sem held.
I
Ingo Molnar 已提交
127
 * i_mutex on quota files is special (it's below dqio_mutex)
L
Linus Torvalds 已提交
128 129
 */

130 131 132
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);
133
EXPORT_SYMBOL(dq_data_lock);
L
Linus Torvalds 已提交
134

135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
void __quota_error(struct super_block *sb, const char *func,
		  const char *fmt, ...)
{
	va_list args;

	if (printk_ratelimit()) {
		va_start(args, fmt);
		printk(KERN_ERR "Quota error (device %s): %s: ",
		       sb->s_id, func);
		vprintk(fmt, args);
		printk("\n");
		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 void __dquot_initialize(struct inode *inode, int type);
250

L
Linus Torvalds 已提交
251 252 253 254 255 256 257 258 259 260 261 262 263 264
static inline unsigned int
hashfn(const struct super_block *sb, unsigned int id, int type)
{
	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 已提交
265 266
	struct hlist_head *head;
	head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type);
L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274
	hlist_add_head(&dquot->dq_hash, head);
}

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

275 276
static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
				unsigned int id, int type)
L
Linus Torvalds 已提交
277 278 279 280 281 282
{
	struct hlist_node *node;
	struct dquot *dquot;

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

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

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

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 */
309
	list_add_tail(&dquot->dq_inuse, &inuse_list);
310
	dqstats_inc(DQST_ALLOC_DQUOTS);
L
Linus Torvalds 已提交
311 312 313 314
}

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

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

J
Jan Kara 已提交
328 329 330 331 332 333 334 335 336
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 已提交
337

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

	/* 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 已提交
347
	spin_lock(&dq_list_lock);
348
	if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
L
Linus Torvalds 已提交
349 350
		list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
				info[dquot->dq_type].dqi_dirty_list);
351 352
		ret = 0;
	}
L
Linus Torvalds 已提交
353
	spin_unlock(&dq_list_lock);
354
	return ret;
L
Linus Torvalds 已提交
355
}
356
EXPORT_SYMBOL(dquot_mark_dquot_dirty);
L
Linus Torvalds 已提交
357

358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381
/* 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 已提交
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405
/* This function needs dq_list_lock */
static inline int clear_dquot_dirty(struct dquot *dquot)
{
	if (!test_and_clear_bit(DQ_MOD_B, &dquot->dq_flags))
		return 0;
	list_del_init(&dquot->dq_dirty);
	return 1;
}

void mark_info_dirty(struct super_block *sb, int type)
{
	set_bit(DQF_INFO_DIRTY_B, &sb_dqopt(sb)->info[type].dqi_flags);
}
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 已提交
406 407
	mutex_lock(&dquot->dq_lock);
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
408 409 410 411 412 413 414 415 416
	if (!test_bit(DQ_READ_B, &dquot->dq_flags))
		ret = dqopt->ops[dquot->dq_type]->read_dqblk(dquot);
	if (ret < 0)
		goto out_iolock;
	set_bit(DQ_READ_B, &dquot->dq_flags);
	/* Instantiate dquot if needed */
	if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && !dquot->dq_off) {
		ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
		/* Write the info if needed */
J
Jan Kara 已提交
417 418 419 420
		if (info_dirty(&dqopt->info[dquot->dq_type])) {
			ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
						dquot->dq_sb, dquot->dq_type);
		}
L
Linus Torvalds 已提交
421 422 423 424 425 426 427 428 429
		if (ret < 0)
			goto out_iolock;
		if (ret2 < 0) {
			ret = ret2;
			goto out_iolock;
		}
	}
	set_bit(DQ_ACTIVE_B, &dquot->dq_flags);
out_iolock:
I
Ingo Molnar 已提交
430 431
	mutex_unlock(&dqopt->dqio_mutex);
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
432 433
	return ret;
}
434
EXPORT_SYMBOL(dquot_acquire);
L
Linus Torvalds 已提交
435 436 437 438 439 440 441 442 443

/*
 *	Write dquot to disk
 */
int dquot_commit(struct dquot *dquot)
{
	int ret = 0, ret2 = 0;
	struct quota_info *dqopt = sb_dqopt(dquot->dq_sb);

I
Ingo Molnar 已提交
444
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
445 446 447 448 449 450 451 452 453 454
	spin_lock(&dq_list_lock);
	if (!clear_dquot_dirty(dquot)) {
		spin_unlock(&dq_list_lock);
		goto out_sem;
	}
	spin_unlock(&dq_list_lock);
	/* Inactive dquot can be only if there was error during read/init
	 * => we have better not writing it */
	if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
		ret = dqopt->ops[dquot->dq_type]->commit_dqblk(dquot);
J
Jan Kara 已提交
455 456 457 458
		if (info_dirty(&dqopt->info[dquot->dq_type])) {
			ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
						dquot->dq_sb, dquot->dq_type);
		}
L
Linus Torvalds 已提交
459 460 461 462
		if (ret >= 0)
			ret = ret2;
	}
out_sem:
I
Ingo Molnar 已提交
463
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
464 465
	return ret;
}
466
EXPORT_SYMBOL(dquot_commit);
L
Linus Torvalds 已提交
467 468 469 470 471 472 473 474 475

/*
 *	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 已提交
476
	mutex_lock(&dquot->dq_lock);
L
Linus Torvalds 已提交
477 478 479
	/* Check whether we are not racing with some other dqget() */
	if (atomic_read(&dquot->dq_count) > 1)
		goto out_dqlock;
I
Ingo Molnar 已提交
480
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
481 482 483
	if (dqopt->ops[dquot->dq_type]->release_dqblk) {
		ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot);
		/* Write the info */
J
Jan Kara 已提交
484 485 486 487
		if (info_dirty(&dqopt->info[dquot->dq_type])) {
			ret2 = dqopt->ops[dquot->dq_type]->write_file_info(
						dquot->dq_sb, dquot->dq_type);
		}
L
Linus Torvalds 已提交
488 489 490 491
		if (ret >= 0)
			ret = ret2;
	}
	clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
I
Ingo Molnar 已提交
492
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
493
out_dqlock:
I
Ingo Molnar 已提交
494
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
495 496
	return ret;
}
497
EXPORT_SYMBOL(dquot_release);
L
Linus Torvalds 已提交
498

499
void dquot_destroy(struct dquot *dquot)
500 501 502
{
	kmem_cache_free(dquot_cachep, dquot);
}
503
EXPORT_SYMBOL(dquot_destroy);
504 505 506 507 508 509

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

L
Linus Torvalds 已提交
510 511
/* 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
512 513
 * 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 已提交
514
 * list) or parallel quotactl call. We have to wait for such users.
515
 */
L
Linus Torvalds 已提交
516 517
static void invalidate_dquots(struct super_block *sb, int type)
{
518
	struct dquot *dquot, *tmp;
L
Linus Torvalds 已提交
519

520
restart:
L
Linus Torvalds 已提交
521
	spin_lock(&dq_list_lock);
522
	list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
L
Linus Torvalds 已提交
523 524 525 526
		if (dquot->dq_sb != sb)
			continue;
		if (dquot->dq_type != type)
			continue;
527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554
		/* Wait for dquot users */
		if (atomic_read(&dquot->dq_count)) {
			DEFINE_WAIT(wait);

			atomic_inc(&dquot->dq_count);
			prepare_to_wait(&dquot->dq_wait_unused, &wait,
					TASK_UNINTERRUPTIBLE);
			spin_unlock(&dq_list_lock);
			/* Once dqput() wakes us up, we know it's time to free
			 * 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.
			 */
			if (atomic_read(&dquot->dq_count) > 1)
				schedule();
			finish_wait(&dquot->dq_wait_unused, &wait);
			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 已提交
555 556 557
		remove_dquot_hash(dquot);
		remove_free_dquot(dquot);
		remove_inuse(dquot);
558
		do_destroy_dquot(dquot);
L
Linus Torvalds 已提交
559 560 561 562
	}
	spin_unlock(&dq_list_lock);
}

563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580
/* 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;

	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
	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);
581
		dqstats_inc(DQST_LOOKUPS);
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596
		dqput(old_dquot);
		old_dquot = dquot;
		ret = fn(dquot, priv);
		if (ret < 0)
			goto out;
		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);
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
	return ret;
}
597
EXPORT_SYMBOL(dquot_scan_active);
598

599
int dquot_quota_sync(struct super_block *sb, int type, int wait)
L
Linus Torvalds 已提交
600 601 602 603 604 605
{
	struct list_head *dirty;
	struct dquot *dquot;
	struct quota_info *dqopt = sb_dqopt(sb);
	int cnt;

I
Ingo Molnar 已提交
606
	mutex_lock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
607 608 609
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
610
		if (!sb_has_quota_active(sb, cnt))
L
Linus Torvalds 已提交
611 612 613 614
			continue;
		spin_lock(&dq_list_lock);
		dirty = &dqopt->info[cnt].dqi_dirty_list;
		while (!list_empty(dirty)) {
J
Jan Kara 已提交
615 616
			dquot = list_first_entry(dirty, struct dquot,
						 dq_dirty);
L
Linus Torvalds 已提交
617 618 619 620 621 622 623 624 625 626
			/* Dirty and inactive can be only bad dquot... */
			if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags)) {
				clear_dquot_dirty(dquot);
				continue;
			}
			/* Now we have active dquot from which someone is
 			 * holding reference so we can safely just increase
			 * use count */
			atomic_inc(&dquot->dq_count);
			spin_unlock(&dq_list_lock);
627
			dqstats_inc(DQST_LOOKUPS);
L
Linus Torvalds 已提交
628 629 630 631 632 633 634 635
			sb->dq_op->write_dquot(dquot);
			dqput(dquot);
			spin_lock(&dq_list_lock);
		}
		spin_unlock(&dq_list_lock);
	}

	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
636 637
		if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
		    && info_dirty(&dqopt->info[cnt]))
L
Linus Torvalds 已提交
638
			sb->dq_op->write_info(sb, cnt);
639
	dqstats_inc(DQST_SYNCS);
I
Ingo Molnar 已提交
640
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
641

642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
	if (!wait || (sb_dqopt(sb)->flags & DQUOT_QUOTA_SYS_FILE))
		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.
	 */
	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
		if (!sb_has_quota_active(sb, cnt))
			continue;
		mutex_lock_nested(&sb_dqopt(sb)->files[cnt]->i_mutex,
				  I_MUTEX_QUOTA);
		truncate_inode_pages(&sb_dqopt(sb)->files[cnt]->i_data, 0);
		mutex_unlock(&sb_dqopt(sb)->files[cnt]->i_mutex);
	}
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);

L
Linus Torvalds 已提交
669 670
	return 0;
}
671
EXPORT_SYMBOL(dquot_quota_sync);
L
Linus Torvalds 已提交
672 673 674 675 676 677 678 679 680 681 682 683 684

/* Free unused dquots from cache */
static void prune_dqcache(int count)
{
	struct list_head *head;
	struct dquot *dquot;

	head = free_dquots.prev;
	while (head != &free_dquots && count) {
		dquot = list_entry(head, struct dquot, dq_free);
		remove_dquot_hash(dquot);
		remove_free_dquot(dquot);
		remove_inuse(dquot);
685
		do_destroy_dquot(dquot);
L
Linus Torvalds 已提交
686 687 688 689 690 691 692 693 694
		count--;
		head = free_dquots.prev;
	}
}

/*
 * This is called from kswapd when we think we need some
 * more memory
 */
695
static int shrink_dqcache_memory(struct shrinker *shrink, int nr, gfp_t gfp_mask)
L
Linus Torvalds 已提交
696 697 698 699 700 701
{
	if (nr) {
		spin_lock(&dq_list_lock);
		prune_dqcache(nr);
		spin_unlock(&dq_list_lock);
	}
702 703 704
	return ((unsigned)
		percpu_counter_read_positive(&dqstats.counter[DQST_FREE_DQUOTS])
		/100) * sysctl_vfs_cache_pressure;
L
Linus Torvalds 已提交
705 706
}

707 708 709 710 711
static struct shrinker dqcache_shrinker = {
	.shrink = shrink_dqcache_memory,
	.seeks = DEFAULT_SEEKS,
};

L
Linus Torvalds 已提交
712 713 714 715
/*
 * Put reference to dquot
 * NOTE: If you change this function please check whether dqput_blocks() works right...
 */
716
void dqput(struct dquot *dquot)
L
Linus Torvalds 已提交
717
{
718 719
	int ret;

L
Linus Torvalds 已提交
720 721
	if (!dquot)
		return;
722
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
723
	if (!atomic_read(&dquot->dq_count)) {
724 725
		quota_error(dquot->dq_sb, "trying to free free dquot of %s %d",
			    quotatypes[dquot->dq_type], dquot->dq_id);
L
Linus Torvalds 已提交
726 727 728
		BUG();
	}
#endif
729
	dqstats_inc(DQST_DROPS);
L
Linus Torvalds 已提交
730 731 732 733 734
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);
735
		/* Releasing dquot during quotaoff phase? */
736
		if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) &&
737 738
		    atomic_read(&dquot->dq_count) == 1)
			wake_up(&dquot->dq_wait_unused);
L
Linus Torvalds 已提交
739 740 741 742 743 744 745
		spin_unlock(&dq_list_lock);
		return;
	}
	/* Need to release dquot? */
	if (test_bit(DQ_ACTIVE_B, &dquot->dq_flags) && dquot_dirty(dquot)) {
		spin_unlock(&dq_list_lock);
		/* Commit dquot before releasing */
746 747
		ret = dquot->dq_sb->dq_op->write_dquot(dquot);
		if (ret < 0) {
748 749 750
			quota_error(dquot->dq_sb, "Can't write quota structure"
				    " (error %d). Quota may get out of sync!",
				    ret);
751 752 753 754 755 756 757 758
			/*
			 * We clear dirty bit anyway, so that we avoid
			 * infinite loop here
			 */
			spin_lock(&dq_list_lock);
			clear_dquot_dirty(dquot);
			spin_unlock(&dq_list_lock);
		}
L
Linus Torvalds 已提交
759 760 761 762 763 764 765 766 767 768
		goto we_slept;
	}
	/* Clear flag in case dquot was inactive (something bad happened) */
	clear_dquot_dirty(dquot);
	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);
769
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
770
	/* sanity check */
771
	BUG_ON(!list_empty(&dquot->dq_free));
L
Linus Torvalds 已提交
772 773 774 775
#endif
	put_dquot_last(dquot);
	spin_unlock(&dq_list_lock);
}
776
EXPORT_SYMBOL(dqput);
L
Linus Torvalds 已提交
777

778
struct dquot *dquot_alloc(struct super_block *sb, int type)
779 780 781
{
	return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
}
782
EXPORT_SYMBOL(dquot_alloc);
783

L
Linus Torvalds 已提交
784 785 786 787
static struct dquot *get_empty_dquot(struct super_block *sb, int type)
{
	struct dquot *dquot;

788
	dquot = sb->dq_op->alloc_dquot(sb, type);
L
Linus Torvalds 已提交
789
	if(!dquot)
J
Jan Kara 已提交
790
		return NULL;
L
Linus Torvalds 已提交
791

I
Ingo Molnar 已提交
792
	mutex_init(&dquot->dq_lock);
L
Linus Torvalds 已提交
793 794 795 796
	INIT_LIST_HEAD(&dquot->dq_free);
	INIT_LIST_HEAD(&dquot->dq_inuse);
	INIT_HLIST_NODE(&dquot->dq_hash);
	INIT_LIST_HEAD(&dquot->dq_dirty);
797
	init_waitqueue_head(&dquot->dq_wait_unused);
L
Linus Torvalds 已提交
798 799 800 801 802 803 804 805 806
	dquot->dq_sb = sb;
	dquot->dq_type = type;
	atomic_set(&dquot->dq_count, 1);

	return dquot;
}

/*
 * Get reference to dquot
J
Jan Kara 已提交
807 808 809 810 811
 *
 * 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 已提交
812
 */
813
struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
L
Linus Torvalds 已提交
814 815
{
	unsigned int hashent = hashfn(sb, id, type);
J
Jan Kara 已提交
816
	struct dquot *dquot = NULL, *empty = NULL;
L
Linus Torvalds 已提交
817

818
        if (!sb_has_quota_active(sb, type))
J
Jan Kara 已提交
819
		return NULL;
L
Linus Torvalds 已提交
820 821
we_slept:
	spin_lock(&dq_list_lock);
J
Jan Kara 已提交
822 823 824 825 826 827 828 829
	spin_lock(&dq_state_lock);
	if (!sb_has_quota_active(sb, type)) {
		spin_unlock(&dq_state_lock);
		spin_unlock(&dq_list_lock);
		goto out;
	}
	spin_unlock(&dq_state_lock);

J
Jan Kara 已提交
830 831 832
	dquot = find_dquot(hashent, sb, id, type);
	if (!dquot) {
		if (!empty) {
L
Linus Torvalds 已提交
833
			spin_unlock(&dq_list_lock);
J
Jan Kara 已提交
834 835
			empty = get_empty_dquot(sb, type);
			if (!empty)
L
Linus Torvalds 已提交
836 837 838 839
				schedule();	/* Try to wait for a moment... */
			goto we_slept;
		}
		dquot = empty;
J
Jan Kara 已提交
840
		empty = NULL;
L
Linus Torvalds 已提交
841 842 843 844 845 846
		dquot->dq_id = id;
		/* 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);
847
		dqstats_inc(DQST_LOOKUPS);
L
Linus Torvalds 已提交
848 849 850 851 852
	} else {
		if (!atomic_read(&dquot->dq_count))
			remove_free_dquot(dquot);
		atomic_inc(&dquot->dq_count);
		spin_unlock(&dq_list_lock);
853 854
		dqstats_inc(DQST_CACHE_HITS);
		dqstats_inc(DQST_LOOKUPS);
L
Linus Torvalds 已提交
855
	}
J
Jan Kara 已提交
856 857
	/* 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 已提交
858
	wait_on_dquot(dquot);
J
Jan Kara 已提交
859 860 861
	/* Read the dquot / allocate space in quota file */
	if (!test_bit(DQ_ACTIVE_B, &dquot->dq_flags) &&
	    sb->dq_op->acquire_dquot(dquot) < 0) {
L
Linus Torvalds 已提交
862
		dqput(dquot);
J
Jan Kara 已提交
863
		dquot = NULL;
J
Jan Kara 已提交
864
		goto out;
L
Linus Torvalds 已提交
865
	}
866
#ifdef CONFIG_QUOTA_DEBUG
867
	BUG_ON(!dquot->dq_sb);	/* Has somebody invalidated entry under us? */
L
Linus Torvalds 已提交
868
#endif
J
Jan Kara 已提交
869 870 871
out:
	if (empty)
		do_destroy_dquot(empty);
L
Linus Torvalds 已提交
872 873 874

	return dquot;
}
875
EXPORT_SYMBOL(dqget);
L
Linus Torvalds 已提交
876 877 878 879 880 881 882 883

static int dqinit_needed(struct inode *inode, int type)
{
	int cnt;

	if (IS_NOQUOTA(inode))
		return 0;
	if (type != -1)
J
Jan Kara 已提交
884
		return !inode->i_dquot[type];
L
Linus Torvalds 已提交
885
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
J
Jan Kara 已提交
886
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
887 888 889 890
			return 1;
	return 0;
}

I
Ingo Molnar 已提交
891
/* This routine is guarded by dqonoff_mutex mutex */
L
Linus Torvalds 已提交
892 893
static void add_dquot_ref(struct super_block *sb, int type)
{
894
	struct inode *inode, *old_inode = NULL;
895
#ifdef CONFIG_QUOTA_DEBUG
896
	int reserved = 0;
897
#endif
L
Linus Torvalds 已提交
898

899 900
	spin_lock(&inode_lock);
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
901
		if (inode->i_state & (I_FREEING|I_WILL_FREE|I_NEW))
N
Nick Piggin 已提交
902
			continue;
903
#ifdef CONFIG_QUOTA_DEBUG
904 905
		if (unlikely(inode_get_rsv_space(inode) > 0))
			reserved = 1;
906
#endif
907 908 909 910 911 912 913 914
		if (!atomic_read(&inode->i_writecount))
			continue;
		if (!dqinit_needed(inode, type))
			continue;

		__iget(inode);
		spin_unlock(&inode_lock);

915
		iput(old_inode);
916
		__dquot_initialize(inode, type);
917 918 919 920 921 922 923
		/* We hold a reference to 'inode' so it couldn't have been
		 * removed from s_inodes list while we dropped the inode_lock.
		 * We cannot iput the inode now as we can be holding the last
		 * reference and we cannot iput it under inode_lock. So we
		 * keep the reference and iput it later. */
		old_inode = inode;
		spin_lock(&inode_lock);
L
Linus Torvalds 已提交
924
	}
925
	spin_unlock(&inode_lock);
926
	iput(old_inode);
927

928
#ifdef CONFIG_QUOTA_DEBUG
929
	if (reserved) {
930 931 932
		quota_error(sb, "Writes happened before quota was turned on "
			"thus quota information is probably inconsistent. "
			"Please run quotacheck(8)");
933
	}
934
#endif
L
Linus Torvalds 已提交
935 936
}

J
Jan Kara 已提交
937 938 939 940
/*
 * Return 0 if dqput() won't block.
 * (note that 1 doesn't necessarily mean blocking)
 */
L
Linus Torvalds 已提交
941 942 943 944 945 946 947
static inline int dqput_blocks(struct dquot *dquot)
{
	if (atomic_read(&dquot->dq_count) <= 1)
		return 1;
	return 0;
}

J
Jan Kara 已提交
948 949 950 951 952
/*
 * Remove references to dquots from inode and add dquot to list for freeing
 * if we have the last referece to dquot
 * We can't race with anybody because we hold dqptr_sem for writing...
 */
953 954
static int remove_inode_dquot_ref(struct inode *inode, int type,
				  struct list_head *tofree_head)
L
Linus Torvalds 已提交
955 956 957
{
	struct dquot *dquot = inode->i_dquot[type];

J
Jan Kara 已提交
958 959
	inode->i_dquot[type] = NULL;
	if (dquot) {
L
Linus Torvalds 已提交
960
		if (dqput_blocks(dquot)) {
961
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
962
			if (atomic_read(&dquot->dq_count) != 1)
963 964 965
				quota_error(inode->i_sb, "Adding dquot with "
					    "dq_count %d to dispose list",
					    atomic_read(&dquot->dq_count));
L
Linus Torvalds 已提交
966 967
#endif
			spin_lock(&dq_list_lock);
J
Jan Kara 已提交
968 969 970
			/* As dquot must have currently users it can't be on
			 * the free list... */
			list_add(&dquot->dq_free, tofree_head);
L
Linus Torvalds 已提交
971 972 973 974 975 976 977 978 979
			spin_unlock(&dq_list_lock);
			return 1;
		}
		else
			dqput(dquot);   /* We have guaranteed we won't block */
	}
	return 0;
}

J
Jan Kara 已提交
980 981 982 983 984
/*
 * 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 已提交
985 986 987 988 989 990 991 992 993
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 已提交
994 995
		/* Remove dquot from the list so we won't have problems... */
		list_del_init(&dquot->dq_free);
L
Linus Torvalds 已提交
996 997 998 999
		dqput(dquot);
	}
}

1000 1001 1002 1003
static void remove_dquot_ref(struct super_block *sb, int type,
		struct list_head *tofree_head)
{
	struct inode *inode;
1004
	int reserved = 0;
1005 1006 1007

	spin_lock(&inode_lock);
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
N
Nick Piggin 已提交
1008 1009 1010 1011 1012 1013
		/*
		 *  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
		 *  (dqptr_sem).
		 */
1014 1015 1016
		if (!IS_NOQUOTA(inode)) {
			if (unlikely(inode_get_rsv_space(inode) > 0))
				reserved = 1;
1017
			remove_inode_dquot_ref(inode, type, tofree_head);
1018
		}
1019 1020
	}
	spin_unlock(&inode_lock);
1021 1022 1023 1024 1025 1026 1027
#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
1028 1029
}

L
Linus Torvalds 已提交
1030 1031 1032 1033 1034
/* Gather all references from inodes and drop them */
static void drop_dquot_ref(struct super_block *sb, int type)
{
	LIST_HEAD(tofree_head);

1035 1036 1037 1038 1039 1040
	if (sb->dq_op) {
		down_write(&sb_dqopt(sb)->dqptr_sem);
		remove_dquot_ref(sb, type, &tofree_head);
		up_write(&sb_dqopt(sb)->dqptr_sem);
		put_dquot_list(&tofree_head);
	}
L
Linus Torvalds 已提交
1041 1042
}

1043
static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1044 1045 1046 1047 1048 1049 1050 1051 1052
{
	dquot->dq_dqb.dqb_curinodes += number;
}

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

1053 1054 1055 1056 1057
static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
{
	dquot->dq_dqb.dqb_rsvspace += number;
}

1058 1059 1060
/*
 * Claim reserved quota space
 */
1061
static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
1062
{
1063 1064 1065 1066
	if (dquot->dq_dqb.dqb_rsvspace < number) {
		WARN_ON_ONCE(1);
		number = dquot->dq_dqb.dqb_rsvspace;
	}
1067 1068 1069 1070 1071 1072 1073
	dquot->dq_dqb.dqb_curspace += number;
	dquot->dq_dqb.dqb_rsvspace -= number;
}

static inline
void dquot_free_reserved_space(struct dquot *dquot, qsize_t number)
{
1074 1075 1076 1077 1078 1079
	if (dquot->dq_dqb.dqb_rsvspace >= number)
		dquot->dq_dqb.dqb_rsvspace -= number;
	else {
		WARN_ON_ONCE(1);
		dquot->dq_dqb.dqb_rsvspace = 0;
	}
1080 1081
}

1082
static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1083
{
1084 1085
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curinodes >= number)
L
Linus Torvalds 已提交
1086 1087 1088 1089 1090 1091 1092 1093
		dquot->dq_dqb.dqb_curinodes -= number;
	else
		dquot->dq_dqb.dqb_curinodes = 0;
	if (dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit)
		dquot->dq_dqb.dqb_itime = (time_t) 0;
	clear_bit(DQ_INODES_B, &dquot->dq_flags);
}

1094
static void dquot_decr_space(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1095
{
1096 1097
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curspace >= number)
L
Linus Torvalds 已提交
1098 1099 1100
		dquot->dq_dqb.dqb_curspace -= number;
	else
		dquot->dq_dqb.dqb_curspace = 0;
1101
	if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
L
Linus Torvalds 已提交
1102 1103 1104 1105
		dquot->dq_dqb.dqb_btime = (time_t) 0;
	clear_bit(DQ_BLKS_B, &dquot->dq_flags);
}

1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
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);
}

1118
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
1119 1120
static int flag_print_warnings = 1;

1121
static int need_print_warning(struct dquot *dquot)
L
Linus Torvalds 已提交
1122 1123 1124 1125 1126 1127
{
	if (!flag_print_warnings)
		return 0;

	switch (dquot->dq_type) {
		case USRQUOTA:
1128
			return current_fsuid() == dquot->dq_id;
L
Linus Torvalds 已提交
1129 1130 1131 1132 1133 1134 1135
		case GRPQUOTA:
			return in_group_p(dquot->dq_id);
	}
	return 0;
}

/* Print warning to user which exceeded quota */
1136
static void print_warning(struct dquot *dquot, const int warntype)
L
Linus Torvalds 已提交
1137 1138
{
	char *msg = NULL;
1139
	struct tty_struct *tty;
L
Linus Torvalds 已提交
1140

1141 1142 1143 1144
	if (warntype == QUOTA_NL_IHARDBELOW ||
	    warntype == QUOTA_NL_ISOFTBELOW ||
	    warntype == QUOTA_NL_BHARDBELOW ||
	    warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(dquot))
L
Linus Torvalds 已提交
1145 1146
		return;

1147 1148
	tty = get_current_tty();
	if (!tty)
1149
		return;
1150
	tty_write_message(tty, dquot->dq_sb->s_id);
1151
	if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
1152
		tty_write_message(tty, ": warning, ");
L
Linus Torvalds 已提交
1153
	else
1154 1155
		tty_write_message(tty, ": write failed, ");
	tty_write_message(tty, quotatypes[dquot->dq_type]);
L
Linus Torvalds 已提交
1156
	switch (warntype) {
1157
		case QUOTA_NL_IHARDWARN:
L
Linus Torvalds 已提交
1158 1159
			msg = " file limit reached.\r\n";
			break;
1160
		case QUOTA_NL_ISOFTLONGWARN:
L
Linus Torvalds 已提交
1161 1162
			msg = " file quota exceeded too long.\r\n";
			break;
1163
		case QUOTA_NL_ISOFTWARN:
L
Linus Torvalds 已提交
1164 1165
			msg = " file quota exceeded.\r\n";
			break;
1166
		case QUOTA_NL_BHARDWARN:
L
Linus Torvalds 已提交
1167 1168
			msg = " block limit reached.\r\n";
			break;
1169
		case QUOTA_NL_BSOFTLONGWARN:
L
Linus Torvalds 已提交
1170 1171
			msg = " block quota exceeded too long.\r\n";
			break;
1172
		case QUOTA_NL_BSOFTWARN:
L
Linus Torvalds 已提交
1173 1174 1175
			msg = " block quota exceeded.\r\n";
			break;
	}
1176
	tty_write_message(tty, msg);
1177
	tty_kref_put(tty);
L
Linus Torvalds 已提交
1178
}
1179 1180
#endif

1181 1182 1183 1184 1185
/*
 * Write warnings to the console and send warning messages over netlink.
 *
 * Note that this function can sleep.
 */
1186
static void flush_warnings(struct dquot *const *dquots, char *warntype)
L
Linus Torvalds 已提交
1187
{
1188
	struct dquot *dq;
L
Linus Torvalds 已提交
1189 1190
	int i;

1191 1192 1193 1194
	for (i = 0; i < MAXQUOTAS; i++) {
		dq = dquots[i];
		if (dq && warntype[i] != QUOTA_NL_NOWARN &&
		    !warning_issued(dq, warntype[i])) {
1195
#ifdef CONFIG_PRINT_QUOTA_WARNING
1196
			print_warning(dq, warntype[i]);
1197
#endif
1198 1199
			quota_send_warning(dq->dq_type, dq->dq_id,
					   dq->dq_sb->s_dev, warntype[i]);
1200
		}
1201
	}
L
Linus Torvalds 已提交
1202 1203
}

1204
static int ignore_hardlimit(struct dquot *dquot)
L
Linus Torvalds 已提交
1205 1206 1207 1208
{
	struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];

	return capable(CAP_SYS_RESOURCE) &&
J
Jan Kara 已提交
1209 1210
	       (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
		!(info->dqi_flags & V1_DQF_RSQUASH));
L
Linus Torvalds 已提交
1211 1212 1213
}

/* needs dq_data_lock */
1214
static int check_idq(struct dquot *dquot, qsize_t inodes, char *warntype)
L
Linus Torvalds 已提交
1215
{
J
Jan Kara 已提交
1216 1217
	qsize_t newinodes = dquot->dq_dqb.dqb_curinodes + inodes;

1218
	*warntype = QUOTA_NL_NOWARN;
1219 1220
	if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) ||
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1221
		return 0;
L
Linus Torvalds 已提交
1222 1223

	if (dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1224
	    newinodes > dquot->dq_dqb.dqb_ihardlimit &&
L
Linus Torvalds 已提交
1225
            !ignore_hardlimit(dquot)) {
1226
		*warntype = QUOTA_NL_IHARDWARN;
1227
		return -EDQUOT;
L
Linus Torvalds 已提交
1228 1229 1230
	}

	if (dquot->dq_dqb.dqb_isoftlimit &&
J
Jan Kara 已提交
1231 1232 1233
	    newinodes > dquot->dq_dqb.dqb_isoftlimit &&
	    dquot->dq_dqb.dqb_itime &&
	    get_seconds() >= dquot->dq_dqb.dqb_itime &&
L
Linus Torvalds 已提交
1234
            !ignore_hardlimit(dquot)) {
1235
		*warntype = QUOTA_NL_ISOFTLONGWARN;
1236
		return -EDQUOT;
L
Linus Torvalds 已提交
1237 1238 1239
	}

	if (dquot->dq_dqb.dqb_isoftlimit &&
J
Jan Kara 已提交
1240
	    newinodes > dquot->dq_dqb.dqb_isoftlimit &&
L
Linus Torvalds 已提交
1241
	    dquot->dq_dqb.dqb_itime == 0) {
1242
		*warntype = QUOTA_NL_ISOFTWARN;
J
Jan Kara 已提交
1243 1244
		dquot->dq_dqb.dqb_itime = get_seconds() +
		    sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace;
L
Linus Torvalds 已提交
1245 1246
	}

1247
	return 0;
L
Linus Torvalds 已提交
1248 1249 1250 1251 1252
}

/* needs dq_data_lock */
static int check_bdq(struct dquot *dquot, qsize_t space, int prealloc, char *warntype)
{
1253
	qsize_t tspace;
J
Jan Kara 已提交
1254
	struct super_block *sb = dquot->dq_sb;
1255

1256
	*warntype = QUOTA_NL_NOWARN;
J
Jan Kara 已提交
1257
	if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) ||
1258
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1259
		return 0;
L
Linus Torvalds 已提交
1260

1261 1262 1263
	tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
		+ space;

L
Linus Torvalds 已提交
1264
	if (dquot->dq_dqb.dqb_bhardlimit &&
1265
	    tspace > dquot->dq_dqb.dqb_bhardlimit &&
L
Linus Torvalds 已提交
1266 1267
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1268
			*warntype = QUOTA_NL_BHARDWARN;
1269
		return -EDQUOT;
L
Linus Torvalds 已提交
1270 1271 1272
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1273
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
J
Jan Kara 已提交
1274 1275
	    dquot->dq_dqb.dqb_btime &&
	    get_seconds() >= dquot->dq_dqb.dqb_btime &&
L
Linus Torvalds 已提交
1276 1277
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1278
			*warntype = QUOTA_NL_BSOFTLONGWARN;
1279
		return -EDQUOT;
L
Linus Torvalds 已提交
1280 1281 1282
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1283
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
L
Linus Torvalds 已提交
1284 1285
	    dquot->dq_dqb.dqb_btime == 0) {
		if (!prealloc) {
1286
			*warntype = QUOTA_NL_BSOFTWARN;
J
Jan Kara 已提交
1287 1288
			dquot->dq_dqb.dqb_btime = get_seconds() +
			    sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace;
L
Linus Torvalds 已提交
1289 1290 1291 1292 1293 1294
		}
		else
			/*
			 * We don't allow preallocation to exceed softlimit so exceeding will
			 * be always printed
			 */
1295
			return -EDQUOT;
L
Linus Torvalds 已提交
1296 1297
	}

1298
	return 0;
L
Linus Torvalds 已提交
1299 1300
}

1301
static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1302
{
J
Jan Kara 已提交
1303 1304
	qsize_t newinodes;

1305
	if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1306 1307
	    dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
	    !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type))
1308 1309
		return QUOTA_NL_NOWARN;

J
Jan Kara 已提交
1310 1311
	newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
	if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1312 1313
		return QUOTA_NL_ISOFTBELOW;
	if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1314
	    newinodes < dquot->dq_dqb.dqb_ihardlimit)
1315 1316 1317 1318 1319 1320 1321
		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) ||
1322
	    dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
1323 1324
		return QUOTA_NL_NOWARN;

1325
	if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
1326
		return QUOTA_NL_BSOFTBELOW;
1327 1328
	if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
	    dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
1329 1330 1331
		return QUOTA_NL_BHARDBELOW;
	return QUOTA_NL_NOWARN;
}
1332

1333 1334 1335 1336 1337 1338 1339 1340 1341
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 已提交
1342
/*
1343 1344 1345 1346 1347 1348 1349
 * Initialize quota pointers in inode
 *
 * We do things in a bit complicated way but by that we avoid calling
 * dqget() and thus filesystem callbacks under dqptr_sem.
 *
 * 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 已提交
1350
 */
1351
static void __dquot_initialize(struct inode *inode, int type)
L
Linus Torvalds 已提交
1352 1353
{
	unsigned int id = 0;
1354
	int cnt;
1355
	struct dquot *got[MAXQUOTAS];
J
Jan Kara 已提交
1356
	struct super_block *sb = inode->i_sb;
1357
	qsize_t rsv;
L
Linus Torvalds 已提交
1358

I
Ingo Molnar 已提交
1359 1360
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1361
	if (!dquot_active(inode))
1362
		return;
J
Jan Kara 已提交
1363 1364 1365

	/* First get references to structures we might need. */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1366
		got[cnt] = NULL;
J
Jan Kara 已提交
1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
		if (type != -1 && cnt != type)
			continue;
		switch (cnt) {
		case USRQUOTA:
			id = inode->i_uid;
			break;
		case GRPQUOTA:
			id = inode->i_gid;
			break;
		}
		got[cnt] = dqget(sb, id, cnt);
	}

	down_write(&sb_dqopt(sb)->dqptr_sem);
L
Linus Torvalds 已提交
1381 1382 1383 1384 1385
	if (IS_NOQUOTA(inode))
		goto out_err;
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
J
Jan Kara 已提交
1386 1387 1388
		/* Avoid races with quotaoff() */
		if (!sb_has_quota_active(sb, cnt))
			continue;
1389 1390 1391
		/* We could race with quotaon or dqget() could have failed */
		if (!got[cnt])
			continue;
J
Jan Kara 已提交
1392
		if (!inode->i_dquot[cnt]) {
J
Jan Kara 已提交
1393
			inode->i_dquot[cnt] = got[cnt];
J
Jan Kara 已提交
1394
			got[cnt] = NULL;
1395 1396 1397 1398 1399 1400 1401
			/*
			 * Make quota reservation system happy if someone
			 * did a write before quota was turned on
			 */
			rsv = inode_get_rsv_space(inode);
			if (unlikely(rsv))
				dquot_resv_space(inode->i_dquot[cnt], rsv);
L
Linus Torvalds 已提交
1402 1403 1404
		}
	}
out_err:
J
Jan Kara 已提交
1405 1406
	up_write(&sb_dqopt(sb)->dqptr_sem);
	/* Drop unused references */
1407
	dqput_all(got);
1408 1409 1410 1411 1412
}

void dquot_initialize(struct inode *inode)
{
	__dquot_initialize(inode, -1);
L
Linus Torvalds 已提交
1413
}
1414
EXPORT_SYMBOL(dquot_initialize);
L
Linus Torvalds 已提交
1415 1416 1417 1418

/*
 * 	Release all quotas referenced by inode
 */
1419
static void __dquot_drop(struct inode *inode)
L
Linus Torvalds 已提交
1420 1421
{
	int cnt;
J
Jan Kara 已提交
1422
	struct dquot *put[MAXQUOTAS];
L
Linus Torvalds 已提交
1423

J
Jan Kara 已提交
1424
	down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
L
Linus Torvalds 已提交
1425
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1426
		put[cnt] = inode->i_dquot[cnt];
J
Jan Kara 已提交
1427
		inode->i_dquot[cnt] = NULL;
L
Linus Torvalds 已提交
1428 1429
	}
	up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1430
	dqput_all(put);
L
Linus Torvalds 已提交
1431 1432
}

1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455
void dquot_drop(struct inode *inode)
{
	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.
	 */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (inode->i_dquot[cnt])
			break;
	}

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

1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
/*
 * 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);
}

1469
void inode_add_rsv_space(struct inode *inode, qsize_t number)
1470 1471 1472 1473 1474
{
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) += number;
	spin_unlock(&inode->i_lock);
}
1475
EXPORT_SYMBOL(inode_add_rsv_space);
1476

1477
void inode_claim_rsv_space(struct inode *inode, qsize_t number)
1478 1479 1480 1481 1482 1483
{
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) -= number;
	__inode_add_bytes(inode, number);
	spin_unlock(&inode->i_lock);
}
1484
EXPORT_SYMBOL(inode_claim_rsv_space);
1485

1486
void inode_sub_rsv_space(struct inode *inode, qsize_t number)
1487 1488 1489 1490 1491
{
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) -= number;
	spin_unlock(&inode->i_lock);
}
1492
EXPORT_SYMBOL(inode_sub_rsv_space);
1493 1494 1495 1496

static qsize_t inode_get_rsv_space(struct inode *inode)
{
	qsize_t ret;
1497 1498 1499

	if (!inode->i_sb->dq_op->get_reserved_space)
		return 0;
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522
	spin_lock(&inode->i_lock);
	ret = *inode_reserved_space(inode);
	spin_unlock(&inode->i_lock);
	return ret;
}

static void inode_incr_space(struct inode *inode, qsize_t number,
				int reserve)
{
	if (reserve)
		inode_add_rsv_space(inode, number);
	else
		inode_add_bytes(inode, number);
}

static void inode_decr_space(struct inode *inode, qsize_t number, int reserve)
{
	if (reserve)
		inode_sub_rsv_space(inode, number);
	else
		inode_sub_bytes(inode, number);
}

L
Linus Torvalds 已提交
1523
/*
1524 1525 1526 1527 1528 1529 1530
 * 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 已提交
1531 1532 1533 1534 1535
 */

/*
 * This operation can block, but only after everything is updated
 */
1536
int __dquot_alloc_space(struct inode *inode, qsize_t number, int flags)
L
Linus Torvalds 已提交
1537
{
1538
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1539
	char warntype[MAXQUOTAS];
1540 1541
	int warn = flags & DQUOT_SPACE_WARN;
	int reserve = flags & DQUOT_SPACE_RESERVE;
1542
	int nofail = flags & DQUOT_SPACE_NOFAIL;
L
Linus Torvalds 已提交
1543

1544 1545 1546 1547
	/*
	 * First test before acquiring mutex - solves deadlocks when we
	 * re-enter the quota code and are already holding the mutex
	 */
1548
	if (!dquot_active(inode)) {
1549 1550 1551 1552 1553
		inode_incr_space(inode, number, reserve);
		goto out;
	}

	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
L
Linus Torvalds 已提交
1554
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1555
		warntype[cnt] = QUOTA_NL_NOWARN;
L
Linus Torvalds 已提交
1556 1557 1558

	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1559
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1560
			continue;
1561 1562
		ret = check_bdq(inode->i_dquot[cnt], number, !warn,
				warntype+cnt);
1563
		if (ret && !nofail) {
1564 1565
			spin_unlock(&dq_data_lock);
			goto out_flush_warn;
1566
		}
L
Linus Torvalds 已提交
1567 1568
	}
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1569
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1570
			continue;
1571 1572 1573 1574
		if (reserve)
			dquot_resv_space(inode->i_dquot[cnt], number);
		else
			dquot_incr_space(inode->i_dquot[cnt], number);
L
Linus Torvalds 已提交
1575
	}
1576
	inode_incr_space(inode, number, reserve);
L
Linus Torvalds 已提交
1577
	spin_unlock(&dq_data_lock);
1578

1579 1580
	if (reserve)
		goto out_flush_warn;
1581
	mark_all_dquot_dirty(inode->i_dquot);
1582 1583
out_flush_warn:
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1584
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1585 1586 1587
out:
	return ret;
}
1588
EXPORT_SYMBOL(__dquot_alloc_space);
L
Linus Torvalds 已提交
1589 1590 1591 1592

/*
 * This operation can block, but only after everything is updated
 */
1593
int dquot_alloc_inode(const struct inode *inode)
L
Linus Torvalds 已提交
1594
{
1595
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1596 1597
	char warntype[MAXQUOTAS];

I
Ingo Molnar 已提交
1598 1599
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1600
	if (!dquot_active(inode))
1601
		return 0;
L
Linus Torvalds 已提交
1602
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1603
		warntype[cnt] = QUOTA_NL_NOWARN;
L
Linus Torvalds 已提交
1604 1605 1606
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1607
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1608
			continue;
1609 1610
		ret = check_idq(inode->i_dquot[cnt], 1, warntype + cnt);
		if (ret)
L
Linus Torvalds 已提交
1611 1612 1613 1614
			goto warn_put_all;
	}

	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1615
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1616
			continue;
1617
		dquot_incr_inodes(inode->i_dquot[cnt], 1);
L
Linus Torvalds 已提交
1618
	}
1619

L
Linus Torvalds 已提交
1620 1621
warn_put_all:
	spin_unlock(&dq_data_lock);
1622
	if (ret == 0)
1623
		mark_all_dquot_dirty(inode->i_dquot);
1624
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1625 1626 1627
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	return ret;
}
1628
EXPORT_SYMBOL(dquot_alloc_inode);
L
Linus Torvalds 已提交
1629

1630 1631 1632 1633
/*
 * Convert in-memory reserved quotas to real consumed quotas
 */
int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1634 1635 1636
{
	int cnt;

1637
	if (!dquot_active(inode)) {
1638
		inode_claim_rsv_space(inode, number);
1639
		return 0;
1640 1641 1642 1643 1644 1645
	}

	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	/* Claim reserved quotas to allocated quotas */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1646
		if (inode->i_dquot[cnt])
1647 1648 1649 1650
			dquot_claim_reserved_space(inode->i_dquot[cnt],
							number);
	}
	/* Update inode bytes */
1651
	inode_claim_rsv_space(inode, number);
1652
	spin_unlock(&dq_data_lock);
1653
	mark_all_dquot_dirty(inode->i_dquot);
1654
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1655
	return 0;
1656
}
1657
EXPORT_SYMBOL(dquot_claim_space_nodirty);
1658

L
Linus Torvalds 已提交
1659 1660 1661
/*
 * This operation can block, but only after everything is updated
 */
1662
void __dquot_free_space(struct inode *inode, qsize_t number, int flags)
L
Linus Torvalds 已提交
1663 1664
{
	unsigned int cnt;
1665
	char warntype[MAXQUOTAS];
1666
	int reserve = flags & DQUOT_SPACE_RESERVE;
L
Linus Torvalds 已提交
1667

I
Ingo Molnar 已提交
1668 1669
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1670
	if (!dquot_active(inode)) {
1671
		inode_decr_space(inode, number, reserve);
1672
		return;
L
Linus Torvalds 已提交
1673
	}
1674

L
Linus Torvalds 已提交
1675 1676 1677
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1678
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1679
			continue;
1680
		warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number);
1681 1682 1683 1684
		if (reserve)
			dquot_free_reserved_space(inode->i_dquot[cnt], number);
		else
			dquot_decr_space(inode->i_dquot[cnt], number);
L
Linus Torvalds 已提交
1685
	}
1686
	inode_decr_space(inode, number, reserve);
L
Linus Torvalds 已提交
1687
	spin_unlock(&dq_data_lock);
1688 1689 1690

	if (reserve)
		goto out_unlock;
1691
	mark_all_dquot_dirty(inode->i_dquot);
1692
out_unlock:
1693
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1694
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1695
}
1696
EXPORT_SYMBOL(__dquot_free_space);
1697

L
Linus Torvalds 已提交
1698 1699 1700
/*
 * This operation can block, but only after everything is updated
 */
1701
void dquot_free_inode(const struct inode *inode)
L
Linus Torvalds 已提交
1702 1703
{
	unsigned int cnt;
1704
	char warntype[MAXQUOTAS];
L
Linus Torvalds 已提交
1705

I
Ingo Molnar 已提交
1706 1707
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1708
	if (!dquot_active(inode))
1709
		return;
1710

L
Linus Torvalds 已提交
1711 1712 1713
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1714
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1715
			continue;
1716 1717
		warntype[cnt] = info_idq_free(inode->i_dquot[cnt], 1);
		dquot_decr_inodes(inode->i_dquot[cnt], 1);
L
Linus Torvalds 已提交
1718 1719
	}
	spin_unlock(&dq_data_lock);
1720
	mark_all_dquot_dirty(inode->i_dquot);
1721
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1722 1723
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
}
1724
EXPORT_SYMBOL(dquot_free_inode);
L
Linus Torvalds 已提交
1725 1726 1727

/*
 * Transfer the number of inode and blocks from one diskquota to an other.
1728 1729 1730
 * 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 已提交
1731 1732 1733
 *
 * This operation can block, but only after everything is updated
 * A transaction must be started when entering this function.
1734
 *
L
Linus Torvalds 已提交
1735
 */
1736
int __dquot_transfer(struct inode *inode, struct dquot **transfer_to)
L
Linus Torvalds 已提交
1737
{
1738 1739
	qsize_t space, cur_space;
	qsize_t rsv_space = 0;
1740
	struct dquot *transfer_from[MAXQUOTAS] = {};
1741
	int cnt, ret = 0;
1742
	char is_valid[MAXQUOTAS] = {};
1743 1744
	char warntype_to[MAXQUOTAS];
	char warntype_from_inodes[MAXQUOTAS], warntype_from_space[MAXQUOTAS];
L
Linus Torvalds 已提交
1745

I
Ingo Molnar 已提交
1746 1747
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
L
Linus Torvalds 已提交
1748
	if (IS_NOQUOTA(inode))
1749
		return 0;
J
Jan Kara 已提交
1750
	/* Initialize the arrays */
1751
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1752
		warntype_to[cnt] = QUOTA_NL_NOWARN;
J
Jan Kara 已提交
1753 1754 1755
	down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
	if (IS_NOQUOTA(inode)) {	/* File without quota accounting? */
		up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1756
		return 0;
J
Jan Kara 已提交
1757
	}
L
Linus Torvalds 已提交
1758
	spin_lock(&dq_data_lock);
1759
	cur_space = inode_get_bytes(inode);
1760
	rsv_space = inode_get_rsv_space(inode);
1761
	space = cur_space + rsv_space;
L
Linus Torvalds 已提交
1762 1763
	/* Build the transfer_from list and check the limits */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1764 1765 1766
		/*
		 * Skip changes for same uid or gid or for turned off quota-type.
		 */
J
Jan Kara 已提交
1767
		if (!transfer_to[cnt])
L
Linus Torvalds 已提交
1768
			continue;
1769 1770 1771 1772
		/* Avoid races with quotaoff() */
		if (!sb_has_quota_active(inode->i_sb, cnt))
			continue;
		is_valid[cnt] = 1;
L
Linus Torvalds 已提交
1773
		transfer_from[cnt] = inode->i_dquot[cnt];
1774 1775 1776 1777 1778
		ret = check_idq(transfer_to[cnt], 1, warntype_to + cnt);
		if (ret)
			goto over_quota;
		ret = check_bdq(transfer_to[cnt], space, 0, warntype_to + cnt);
		if (ret)
J
Jan Kara 已提交
1779
			goto over_quota;
L
Linus Torvalds 已提交
1780 1781 1782 1783 1784 1785
	}

	/*
	 * Finally perform the needed transfer from transfer_from to transfer_to
	 */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1786
		if (!is_valid[cnt])
L
Linus Torvalds 已提交
1787 1788 1789
			continue;
		/* Due to IO error we might not have transfer_from[] structure */
		if (transfer_from[cnt]) {
1790 1791 1792 1793
			warntype_from_inodes[cnt] =
				info_idq_free(transfer_from[cnt], 1);
			warntype_from_space[cnt] =
				info_bdq_free(transfer_from[cnt], space);
L
Linus Torvalds 已提交
1794
			dquot_decr_inodes(transfer_from[cnt], 1);
1795 1796 1797
			dquot_decr_space(transfer_from[cnt], cur_space);
			dquot_free_reserved_space(transfer_from[cnt],
						  rsv_space);
L
Linus Torvalds 已提交
1798 1799 1800
		}

		dquot_incr_inodes(transfer_to[cnt], 1);
1801 1802
		dquot_incr_space(transfer_to[cnt], cur_space);
		dquot_resv_space(transfer_to[cnt], rsv_space);
L
Linus Torvalds 已提交
1803 1804 1805 1806

		inode->i_dquot[cnt] = transfer_to[cnt];
	}
	spin_unlock(&dq_data_lock);
J
Jan Kara 已提交
1807 1808
	up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);

1809 1810
	mark_all_dquot_dirty(transfer_from);
	mark_all_dquot_dirty(transfer_to);
1811 1812 1813
	flush_warnings(transfer_to, warntype_to);
	flush_warnings(transfer_from, warntype_from_inodes);
	flush_warnings(transfer_from, warntype_from_space);
1814
	/* Pass back references to put */
1815
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1816 1817
		if (is_valid[cnt])
			transfer_to[cnt] = transfer_from[cnt];
1818
	return 0;
J
Jan Kara 已提交
1819 1820 1821
over_quota:
	spin_unlock(&dq_data_lock);
	up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1822 1823
	flush_warnings(transfer_to, warntype_to);
	return ret;
L
Linus Torvalds 已提交
1824
}
1825
EXPORT_SYMBOL(__dquot_transfer);
L
Linus Torvalds 已提交
1826

1827 1828 1829
/* Wrapper for transferring ownership of an inode for uid/gid only
 * Called from FSXXX_setattr()
 */
1830
int dquot_transfer(struct inode *inode, struct iattr *iattr)
1831
{
1832 1833 1834
	struct dquot *transfer_to[MAXQUOTAS] = {};
	struct super_block *sb = inode->i_sb;
	int ret;
1835

1836
	if (!dquot_active(inode))
1837
		return 0;
1838

1839 1840 1841
	if (iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid)
		transfer_to[USRQUOTA] = dqget(sb, iattr->ia_uid, USRQUOTA);
	if (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid)
J
Jan Kara 已提交
1842
		transfer_to[GRPQUOTA] = dqget(sb, iattr->ia_gid, GRPQUOTA);
1843 1844 1845 1846

	ret = __dquot_transfer(inode, transfer_to);
	dqput_all(transfer_to);
	return ret;
1847
}
1848
EXPORT_SYMBOL(dquot_transfer);
1849

L
Linus Torvalds 已提交
1850 1851 1852 1853 1854 1855 1856 1857
/*
 * Write info of quota file to disk
 */
int dquot_commit_info(struct super_block *sb, int type)
{
	int ret;
	struct quota_info *dqopt = sb_dqopt(sb);

I
Ingo Molnar 已提交
1858
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
1859
	ret = dqopt->ops[type]->write_file_info(sb, type);
I
Ingo Molnar 已提交
1860
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
1861 1862
	return ret;
}
1863
EXPORT_SYMBOL(dquot_commit_info);
L
Linus Torvalds 已提交
1864 1865 1866 1867

/*
 * Definitions of diskquota operations.
 */
1868
const struct dquot_operations dquot_operations = {
L
Linus Torvalds 已提交
1869 1870 1871 1872
	.write_dquot	= dquot_commit,
	.acquire_dquot	= dquot_acquire,
	.release_dquot	= dquot_release,
	.mark_dirty	= dquot_mark_dquot_dirty,
1873 1874 1875
	.write_info	= dquot_commit_info,
	.alloc_dquot	= dquot_alloc,
	.destroy_dquot	= dquot_destroy,
L
Linus Torvalds 已提交
1876
};
1877
EXPORT_SYMBOL(dquot_operations);
L
Linus Torvalds 已提交
1878

1879 1880 1881 1882 1883 1884 1885 1886 1887
/*
 * 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))
1888
		dquot_initialize(inode);
1889 1890 1891 1892
	return error;
}
EXPORT_SYMBOL(dquot_file_open);

L
Linus Torvalds 已提交
1893 1894 1895
/*
 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
 */
1896
int dquot_disable(struct super_block *sb, int type, unsigned int flags)
L
Linus Torvalds 已提交
1897
{
1898
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1899 1900 1901
	struct quota_info *dqopt = sb_dqopt(sb);
	struct inode *toputinode[MAXQUOTAS];

1902 1903 1904 1905 1906 1907 1908
	/* 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;

L
Linus Torvalds 已提交
1909
	/* We need to serialize quota_off() for device */
I
Ingo Molnar 已提交
1910
	mutex_lock(&dqopt->dqonoff_mutex);
1911 1912 1913 1914 1915 1916

	/*
	 * 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.
	 */
1917
	if (!sb_any_quota_loaded(sb)) {
1918 1919 1920
		mutex_unlock(&dqopt->dqonoff_mutex);
		return 0;
	}
L
Linus Torvalds 已提交
1921 1922 1923 1924
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		toputinode[cnt] = NULL;
		if (type != -1 && cnt != type)
			continue;
1925
		if (!sb_has_quota_loaded(sb, cnt))
1926
			continue;
1927 1928

		if (flags & DQUOT_SUSPENDED) {
J
Jan Kara 已提交
1929
			spin_lock(&dq_state_lock);
1930 1931
			dqopt->flags |=
				dquot_state_flag(DQUOT_SUSPENDED, cnt);
J
Jan Kara 已提交
1932
			spin_unlock(&dq_state_lock);
1933
		} else {
J
Jan Kara 已提交
1934
			spin_lock(&dq_state_lock);
1935 1936 1937 1938 1939 1940
			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 已提交
1941
				spin_unlock(&dq_state_lock);
1942 1943 1944 1945
				iput(dqopt->files[cnt]);
				dqopt->files[cnt] = NULL;
				continue;
			}
J
Jan Kara 已提交
1946
			spin_unlock(&dq_state_lock);
1947
		}
1948 1949 1950

		/* We still have to keep quota loaded? */
		if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
L
Linus Torvalds 已提交
1951 1952 1953 1954 1955 1956
			continue;

		/* Note: these are blocking operations */
		drop_dquot_ref(sb, cnt);
		invalidate_dquots(sb, cnt);
		/*
J
Jan Kara 已提交
1957 1958
		 * Now all dquots should be invalidated, all writes done so we
		 * should be only users of the info. No locks needed.
L
Linus Torvalds 已提交
1959 1960 1961 1962 1963 1964 1965 1966
		 */
		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];
1967
		if (!sb_has_quota_loaded(sb, cnt))
1968
			dqopt->files[cnt] = NULL;
L
Linus Torvalds 已提交
1969 1970 1971 1972 1973
		dqopt->info[cnt].dqi_flags = 0;
		dqopt->info[cnt].dqi_igrace = 0;
		dqopt->info[cnt].dqi_bgrace = 0;
		dqopt->ops[cnt] = NULL;
	}
I
Ingo Molnar 已提交
1974
	mutex_unlock(&dqopt->dqonoff_mutex);
1975 1976 1977 1978 1979

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

L
Linus Torvalds 已提交
1980
	/* Sync the superblock so that buffers with quota data are written to
1981
	 * disk (and so userspace sees correct data afterwards). */
L
Linus Torvalds 已提交
1982 1983 1984 1985 1986 1987 1988 1989 1990 1991
	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++)
		if (toputinode[cnt]) {
I
Ingo Molnar 已提交
1992
			mutex_lock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
1993 1994
			/* If quota was reenabled in the meantime, we have
			 * nothing to do */
1995
			if (!sb_has_quota_loaded(sb, cnt)) {
J
Jan Kara 已提交
1996 1997
				mutex_lock_nested(&toputinode[cnt]->i_mutex,
						  I_MUTEX_QUOTA);
L
Linus Torvalds 已提交
1998 1999
				toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
				  S_NOATIME | S_NOQUOTA);
J
Jan Kara 已提交
2000 2001
				truncate_inode_pages(&toputinode[cnt]->i_data,
						     0);
2002
				mutex_unlock(&toputinode[cnt]->i_mutex);
2003
				mark_inode_dirty_sync(toputinode[cnt]);
L
Linus Torvalds 已提交
2004
			}
I
Ingo Molnar 已提交
2005
			mutex_unlock(&dqopt->dqonoff_mutex);
2006 2007 2008 2009 2010 2011
		}
	if (sb->s_bdev)
		invalidate_bdev(sb->s_bdev);
put_inodes:
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
		if (toputinode[cnt]) {
2012
			/* On remount RO, we keep the inode pointer so that we
2013 2014 2015 2016 2017 2018 2019
			 * 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))
2020 2021 2022
				iput(toputinode[cnt]);
			else if (!toputinode[cnt]->i_nlink)
				ret = -EBUSY;
L
Linus Torvalds 已提交
2023
		}
2024
	return ret;
L
Linus Torvalds 已提交
2025
}
2026
EXPORT_SYMBOL(dquot_disable);
L
Linus Torvalds 已提交
2027

2028
int dquot_quota_off(struct super_block *sb, int type)
2029
{
2030 2031
	return dquot_disable(sb, type,
			     DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2032
}
2033
EXPORT_SYMBOL(dquot_quota_off);
2034

L
Linus Torvalds 已提交
2035 2036 2037 2038
/*
 *	Turn quotas on on a device
 */

2039 2040 2041 2042 2043 2044
/*
 * 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 已提交
2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065
{
	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;
	int oldflags = -1;

	if (!fmt)
		return -ESRCH;
	if (!S_ISREG(inode->i_mode)) {
		error = -EACCES;
		goto out_fmt;
	}
	if (IS_RDONLY(inode)) {
		error = -EROFS;
		goto out_fmt;
	}
	if (!sb->s_op->quota_write || !sb->s_op->quota_read) {
		error = -EINVAL;
		goto out_fmt;
	}
2066 2067 2068 2069 2070
	/* Usage always has to be set... */
	if (!(flags & DQUOT_USAGE_ENABLED)) {
		error = -EINVAL;
		goto out_fmt;
	}
L
Linus Torvalds 已提交
2071

2072
	if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2073 2074 2075 2076 2077 2078 2079
		/* 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);
2080 2081
		invalidate_bdev(sb->s_bdev);
	}
I
Ingo Molnar 已提交
2082
	mutex_lock(&dqopt->dqonoff_mutex);
2083
	if (sb_has_quota_loaded(sb, type)) {
L
Linus Torvalds 已提交
2084 2085 2086
		error = -EBUSY;
		goto out_lock;
	}
2087 2088 2089 2090 2091

	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. */
2092
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
J
Jan Kara 已提交
2093 2094
		oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
					     S_NOQUOTA);
2095
		inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
2096
		mutex_unlock(&inode->i_mutex);
2097 2098 2099 2100
		/*
		 * When S_NOQUOTA is set, remove dquot references as no more
		 * references can be added
		 */
2101
		__dquot_drop(inode);
2102
	}
L
Linus Torvalds 已提交
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113

	error = -EIO;
	dqopt->files[type] = igrab(inode);
	if (!dqopt->files[type])
		goto out_lock;
	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;
2114
	dqopt->info[type].dqi_fmt_id = format_id;
L
Linus Torvalds 已提交
2115
	INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
I
Ingo Molnar 已提交
2116
	mutex_lock(&dqopt->dqio_mutex);
J
Jan Kara 已提交
2117 2118
	error = dqopt->ops[type]->read_file_info(sb, type);
	if (error < 0) {
I
Ingo Molnar 已提交
2119
		mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
2120 2121
		goto out_file_init;
	}
I
Ingo Molnar 已提交
2122
	mutex_unlock(&dqopt->dqio_mutex);
J
Jan Kara 已提交
2123
	spin_lock(&dq_state_lock);
2124
	dqopt->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2125
	spin_unlock(&dq_state_lock);
L
Linus Torvalds 已提交
2126 2127

	add_dquot_ref(sb, type);
I
Ingo Molnar 已提交
2128
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
2129 2130 2131 2132 2133 2134 2135 2136

	return 0;

out_file_init:
	dqopt->files[type] = NULL;
	iput(inode);
out_lock:
	if (oldflags != -1) {
2137
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
L
Linus Torvalds 已提交
2138 2139 2140 2141
		/* Set the flags back (in the case of accidental quotaon()
		 * on a wrong file we don't want to mess up the flags) */
		inode->i_flags &= ~(S_NOATIME | S_NOQUOTA | S_IMMUTABLE);
		inode->i_flags |= oldflags;
2142
		mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
2143
	}
2144
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
2145 2146 2147 2148 2149 2150
out_fmt:
	put_quota_format(fmt);

	return error; 
}

2151
/* Reenable quotas on remount RW */
2152
int dquot_resume(struct super_block *sb, int type)
2153 2154 2155
{
	struct quota_info *dqopt = sb_dqopt(sb);
	struct inode *inode;
2156
	int ret = 0, cnt;
2157
	unsigned int flags;
2158

2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174 2175
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;

		mutex_lock(&dqopt->dqonoff_mutex);
		if (!sb_has_quota_suspended(sb, cnt)) {
			mutex_unlock(&dqopt->dqonoff_mutex);
			continue;
		}
		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);
2176 2177
		mutex_unlock(&dqopt->dqonoff_mutex);

2178 2179 2180 2181 2182
		flags = dquot_generic_flag(flags, cnt);
		ret = vfs_load_quota_inode(inode, cnt,
				dqopt->info[cnt].dqi_fmt_id, flags);
		iput(inode);
	}
2183 2184 2185

	return ret;
}
2186
EXPORT_SYMBOL(dquot_resume);
2187

2188
int dquot_quota_on_path(struct super_block *sb, int type, int format_id,
2189 2190 2191 2192 2193 2194 2195 2196 2197
		      struct path *path)
{
	int error = security_quota_on(path->dentry);
	if (error)
		return error;
	/* Quota file not on the same filesystem? */
	if (path->mnt->mnt_sb != sb)
		error = -EXDEV;
	else
2198 2199 2200
		error = vfs_load_quota_inode(path->dentry->d_inode, type,
					     format_id, DQUOT_USAGE_ENABLED |
					     DQUOT_LIMITS_ENABLED);
2201 2202
	return error;
}
2203
EXPORT_SYMBOL(dquot_quota_on_path);
2204

2205
int dquot_quota_on(struct super_block *sb, int type, int format_id, char *name)
L
Linus Torvalds 已提交
2206
{
2207
	struct path path;
L
Linus Torvalds 已提交
2208 2209
	int error;

2210
	error = kern_path(name, LOOKUP_FOLLOW, &path);
2211
	if (!error) {
2212
		error = dquot_quota_on_path(sb, type, format_id, &path);
2213
		path_put(&path);
2214
	}
L
Linus Torvalds 已提交
2215 2216
	return error;
}
2217
EXPORT_SYMBOL(dquot_quota_on);
L
Linus Torvalds 已提交
2218

2219 2220 2221 2222
/*
 * More powerful function for turning on quotas allowing setting
 * of individual quota flags
 */
2223 2224
int dquot_enable(struct inode *inode, int type, int format_id,
		 unsigned int flags)
2225 2226 2227 2228 2229 2230
{
	int ret = 0;
	struct super_block *sb = inode->i_sb;
	struct quota_info *dqopt = sb_dqopt(sb);

	/* Just unsuspend quotas? */
2231 2232
	BUG_ON(flags & DQUOT_SUSPENDED);

2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
	if (!flags)
		return 0;
	/* Just updating flags needed? */
	if (sb_has_quota_loaded(sb, type)) {
		mutex_lock(&dqopt->dqonoff_mutex);
		/* Now do a reliable test... */
		if (!sb_has_quota_loaded(sb, type)) {
			mutex_unlock(&dqopt->dqonoff_mutex);
			goto load_quota;
		}
		if (flags & DQUOT_USAGE_ENABLED &&
		    sb_has_quota_usage_enabled(sb, type)) {
			ret = -EBUSY;
			goto out_lock;
		}
		if (flags & DQUOT_LIMITS_ENABLED &&
		    sb_has_quota_limits_enabled(sb, type)) {
			ret = -EBUSY;
			goto out_lock;
		}
J
Jan Kara 已提交
2253
		spin_lock(&dq_state_lock);
2254
		sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2255
		spin_unlock(&dq_state_lock);
2256 2257 2258 2259 2260 2261 2262 2263
out_lock:
		mutex_unlock(&dqopt->dqonoff_mutex);
		return ret;
	}

load_quota:
	return vfs_load_quota_inode(inode, type, format_id, flags);
}
2264
EXPORT_SYMBOL(dquot_enable);
2265

L
Linus Torvalds 已提交
2266 2267 2268 2269
/*
 * This function is used when filesystem needs to initialize quotas
 * during mount time.
 */
2270
int dquot_quota_on_mount(struct super_block *sb, char *qf_name,
2271
		int format_id, int type)
L
Linus Torvalds 已提交
2272
{
2273
	struct dentry *dentry;
L
Linus Torvalds 已提交
2274 2275
	int error;

2276
	mutex_lock(&sb->s_root->d_inode->i_mutex);
2277
	dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
2278
	mutex_unlock(&sb->s_root->d_inode->i_mutex);
2279 2280 2281
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

2282 2283 2284 2285 2286
	if (!dentry->d_inode) {
		error = -ENOENT;
		goto out;
	}

L
Linus Torvalds 已提交
2287
	error = security_quota_on(dentry);
2288
	if (!error)
2289 2290
		error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
				DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2291

2292
out:
2293 2294
	dput(dentry);
	return error;
L
Linus Torvalds 已提交
2295
}
2296
EXPORT_SYMBOL(dquot_quota_on_mount);
2297

2298 2299 2300 2301 2302 2303 2304 2305 2306 2307
static inline qsize_t qbtos(qsize_t blocks)
{
	return blocks << QIF_DQBLKSIZE_BITS;
}

static inline qsize_t stoqb(qsize_t space)
{
	return (space + QIF_DQBLKSIZE - 1) >> QIF_DQBLKSIZE_BITS;
}

L
Linus Torvalds 已提交
2308
/* Generic routine for getting common part of quota structure */
2309
static void do_get_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
L
Linus Torvalds 已提交
2310 2311 2312
{
	struct mem_dqblk *dm = &dquot->dq_dqb;

2313 2314 2315
	memset(di, 0, sizeof(*di));
	di->d_version = FS_DQUOT_VERSION;
	di->d_flags = dquot->dq_type == USRQUOTA ?
2316
			FS_USER_QUOTA : FS_GROUP_QUOTA;
2317 2318
	di->d_id = dquot->dq_id;

L
Linus Torvalds 已提交
2319
	spin_lock(&dq_data_lock);
2320 2321 2322 2323 2324 2325 2326 2327
	di->d_blk_hardlimit = stoqb(dm->dqb_bhardlimit);
	di->d_blk_softlimit = stoqb(dm->dqb_bsoftlimit);
	di->d_ino_hardlimit = dm->dqb_ihardlimit;
	di->d_ino_softlimit = dm->dqb_isoftlimit;
	di->d_bcount = dm->dqb_curspace + dm->dqb_rsvspace;
	di->d_icount = dm->dqb_curinodes;
	di->d_btimer = dm->dqb_btime;
	di->d_itimer = dm->dqb_itime;
L
Linus Torvalds 已提交
2328 2329 2330
	spin_unlock(&dq_data_lock);
}

2331 2332
int dquot_get_dqblk(struct super_block *sb, int type, qid_t id,
		    struct fs_disk_quota *di)
L
Linus Torvalds 已提交
2333 2334 2335
{
	struct dquot *dquot;

J
Jan Kara 已提交
2336
	dquot = dqget(sb, id, type);
J
Jan Kara 已提交
2337
	if (!dquot)
L
Linus Torvalds 已提交
2338 2339 2340
		return -ESRCH;
	do_get_dqblk(dquot, di);
	dqput(dquot);
J
Jan Kara 已提交
2341

L
Linus Torvalds 已提交
2342 2343
	return 0;
}
2344
EXPORT_SYMBOL(dquot_get_dqblk);
L
Linus Torvalds 已提交
2345

2346 2347 2348 2349 2350
#define VFS_FS_DQ_MASK \
	(FS_DQ_BCOUNT | FS_DQ_BSOFT | FS_DQ_BHARD | \
	 FS_DQ_ICOUNT | FS_DQ_ISOFT | FS_DQ_IHARD | \
	 FS_DQ_BTIMER | FS_DQ_ITIMER)

L
Linus Torvalds 已提交
2351
/* Generic routine for setting common part of quota structure */
2352
static int do_set_dqblk(struct dquot *dquot, struct fs_disk_quota *di)
L
Linus Torvalds 已提交
2353 2354 2355
{
	struct mem_dqblk *dm = &dquot->dq_dqb;
	int check_blim = 0, check_ilim = 0;
2356 2357
	struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];

2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368
	if (di->d_fieldmask & ~VFS_FS_DQ_MASK)
		return -EINVAL;

	if (((di->d_fieldmask & FS_DQ_BSOFT) &&
	     (di->d_blk_softlimit > dqi->dqi_maxblimit)) ||
	    ((di->d_fieldmask & FS_DQ_BHARD) &&
	     (di->d_blk_hardlimit > dqi->dqi_maxblimit)) ||
	    ((di->d_fieldmask & FS_DQ_ISOFT) &&
	     (di->d_ino_softlimit > dqi->dqi_maxilimit)) ||
	    ((di->d_fieldmask & FS_DQ_IHARD) &&
	     (di->d_ino_hardlimit > dqi->dqi_maxilimit)))
2369
		return -ERANGE;
L
Linus Torvalds 已提交
2370 2371

	spin_lock(&dq_data_lock);
2372 2373
	if (di->d_fieldmask & FS_DQ_BCOUNT) {
		dm->dqb_curspace = di->d_bcount - dm->dqb_rsvspace;
L
Linus Torvalds 已提交
2374
		check_blim = 1;
2375
		set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2376
	}
2377 2378 2379 2380 2381 2382

	if (di->d_fieldmask & FS_DQ_BSOFT)
		dm->dqb_bsoftlimit = qbtos(di->d_blk_softlimit);
	if (di->d_fieldmask & FS_DQ_BHARD)
		dm->dqb_bhardlimit = qbtos(di->d_blk_hardlimit);
	if (di->d_fieldmask & (FS_DQ_BSOFT | FS_DQ_BHARD)) {
L
Linus Torvalds 已提交
2383
		check_blim = 1;
2384
		set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2385
	}
2386 2387 2388

	if (di->d_fieldmask & FS_DQ_ICOUNT) {
		dm->dqb_curinodes = di->d_icount;
L
Linus Torvalds 已提交
2389
		check_ilim = 1;
2390
		set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2391
	}
2392 2393 2394 2395 2396 2397

	if (di->d_fieldmask & FS_DQ_ISOFT)
		dm->dqb_isoftlimit = di->d_ino_softlimit;
	if (di->d_fieldmask & FS_DQ_IHARD)
		dm->dqb_ihardlimit = di->d_ino_hardlimit;
	if (di->d_fieldmask & (FS_DQ_ISOFT | FS_DQ_IHARD)) {
L
Linus Torvalds 已提交
2398
		check_ilim = 1;
2399
		set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2400
	}
2401 2402 2403

	if (di->d_fieldmask & FS_DQ_BTIMER) {
		dm->dqb_btime = di->d_btimer;
2404
		check_blim = 1;
2405
		set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
2406
	}
2407 2408 2409

	if (di->d_fieldmask & FS_DQ_ITIMER) {
		dm->dqb_itime = di->d_itimer;
2410
		check_ilim = 1;
2411
		set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
2412
	}
L
Linus Torvalds 已提交
2413 2414

	if (check_blim) {
J
Jan Kara 已提交
2415 2416
		if (!dm->dqb_bsoftlimit ||
		    dm->dqb_curspace < dm->dqb_bsoftlimit) {
L
Linus Torvalds 已提交
2417 2418
			dm->dqb_btime = 0;
			clear_bit(DQ_BLKS_B, &dquot->dq_flags);
2419
		} else if (!(di->d_fieldmask & FS_DQ_BTIMER))
J
Jan Kara 已提交
2420
			/* Set grace only if user hasn't provided his own... */
2421
			dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
L
Linus Torvalds 已提交
2422 2423
	}
	if (check_ilim) {
J
Jan Kara 已提交
2424 2425
		if (!dm->dqb_isoftlimit ||
		    dm->dqb_curinodes < dm->dqb_isoftlimit) {
L
Linus Torvalds 已提交
2426 2427
			dm->dqb_itime = 0;
			clear_bit(DQ_INODES_B, &dquot->dq_flags);
2428
		} else if (!(di->d_fieldmask & FS_DQ_ITIMER))
J
Jan Kara 已提交
2429
			/* Set grace only if user hasn't provided his own... */
2430
			dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
L
Linus Torvalds 已提交
2431
	}
J
Jan Kara 已提交
2432 2433
	if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
	    dm->dqb_isoftlimit)
L
Linus Torvalds 已提交
2434 2435 2436 2437 2438
		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);
2439 2440

	return 0;
L
Linus Torvalds 已提交
2441 2442
}

2443
int dquot_set_dqblk(struct super_block *sb, int type, qid_t id,
2444
		  struct fs_disk_quota *di)
L
Linus Torvalds 已提交
2445 2446
{
	struct dquot *dquot;
2447
	int rc;
L
Linus Torvalds 已提交
2448

2449 2450 2451 2452
	dquot = dqget(sb, id, type);
	if (!dquot) {
		rc = -ESRCH;
		goto out;
L
Linus Torvalds 已提交
2453
	}
2454
	rc = do_set_dqblk(dquot, di);
L
Linus Torvalds 已提交
2455
	dqput(dquot);
2456
out:
2457
	return rc;
L
Linus Torvalds 已提交
2458
}
2459
EXPORT_SYMBOL(dquot_set_dqblk);
L
Linus Torvalds 已提交
2460 2461

/* Generic routine for getting common part of quota file information */
2462
int dquot_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
L
Linus Torvalds 已提交
2463 2464 2465
{
	struct mem_dqinfo *mi;
  
I
Ingo Molnar 已提交
2466
	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2467
	if (!sb_has_quota_active(sb, type)) {
I
Ingo Molnar 已提交
2468
		mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
L
Linus Torvalds 已提交
2469 2470 2471 2472 2473 2474 2475 2476 2477
		return -ESRCH;
	}
	mi = sb_dqopt(sb)->info + type;
	spin_lock(&dq_data_lock);
	ii->dqi_bgrace = mi->dqi_bgrace;
	ii->dqi_igrace = mi->dqi_igrace;
	ii->dqi_flags = mi->dqi_flags & DQF_MASK;
	ii->dqi_valid = IIF_ALL;
	spin_unlock(&dq_data_lock);
I
Ingo Molnar 已提交
2478
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
L
Linus Torvalds 已提交
2479 2480
	return 0;
}
2481
EXPORT_SYMBOL(dquot_get_dqinfo);
L
Linus Torvalds 已提交
2482 2483

/* Generic routine for setting common part of quota file information */
2484
int dquot_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
L
Linus Torvalds 已提交
2485 2486
{
	struct mem_dqinfo *mi;
2487
	int err = 0;
L
Linus Torvalds 已提交
2488

I
Ingo Molnar 已提交
2489
	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2490 2491 2492
	if (!sb_has_quota_active(sb, type)) {
		err = -ESRCH;
		goto out;
L
Linus Torvalds 已提交
2493 2494 2495 2496 2497 2498 2499 2500
	}
	mi = sb_dqopt(sb)->info + type;
	spin_lock(&dq_data_lock);
	if (ii->dqi_valid & IIF_BGRACE)
		mi->dqi_bgrace = ii->dqi_bgrace;
	if (ii->dqi_valid & IIF_IGRACE)
		mi->dqi_igrace = ii->dqi_igrace;
	if (ii->dqi_valid & IIF_FLAGS)
J
Jan Kara 已提交
2501 2502
		mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) |
				(ii->dqi_flags & DQF_MASK);
L
Linus Torvalds 已提交
2503 2504 2505 2506
	spin_unlock(&dq_data_lock);
	mark_info_dirty(sb, type);
	/* Force write to disk */
	sb->dq_op->write_info(sb, type);
2507
out:
I
Ingo Molnar 已提交
2508
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2509
	return err;
L
Linus Torvalds 已提交
2510
}
2511
EXPORT_SYMBOL(dquot_set_dqinfo);
L
Linus Torvalds 已提交
2512

2513 2514 2515 2516 2517 2518 2519 2520
const struct quotactl_ops dquot_quotactl_ops = {
	.quota_on	= dquot_quota_on,
	.quota_off	= dquot_quota_off,
	.quota_sync	= dquot_quota_sync,
	.get_info	= dquot_get_dqinfo,
	.set_info	= dquot_set_dqinfo,
	.get_dqblk	= dquot_get_dqblk,
	.set_dqblk	= dquot_set_dqblk
L
Linus Torvalds 已提交
2521
};
2522
EXPORT_SYMBOL(dquot_quotactl_ops);
2523 2524 2525 2526 2527

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;
2528 2529 2530 2531

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

L
Linus Torvalds 已提交
2535 2536 2537
static ctl_table fs_dqstats_table[] = {
	{
		.procname	= "lookups",
2538
		.data		= &dqstats.stat[DQST_LOOKUPS],
L
Linus Torvalds 已提交
2539 2540
		.maxlen		= sizeof(int),
		.mode		= 0444,
2541
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2542 2543 2544
	},
	{
		.procname	= "drops",
2545
		.data		= &dqstats.stat[DQST_DROPS],
L
Linus Torvalds 已提交
2546 2547
		.maxlen		= sizeof(int),
		.mode		= 0444,
2548
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2549 2550 2551
	},
	{
		.procname	= "reads",
2552
		.data		= &dqstats.stat[DQST_READS],
L
Linus Torvalds 已提交
2553 2554
		.maxlen		= sizeof(int),
		.mode		= 0444,
2555
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2556 2557 2558
	},
	{
		.procname	= "writes",
2559
		.data		= &dqstats.stat[DQST_WRITES],
L
Linus Torvalds 已提交
2560 2561
		.maxlen		= sizeof(int),
		.mode		= 0444,
2562
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2563 2564 2565
	},
	{
		.procname	= "cache_hits",
2566
		.data		= &dqstats.stat[DQST_CACHE_HITS],
L
Linus Torvalds 已提交
2567 2568
		.maxlen		= sizeof(int),
		.mode		= 0444,
2569
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2570 2571 2572
	},
	{
		.procname	= "allocated_dquots",
2573
		.data		= &dqstats.stat[DQST_ALLOC_DQUOTS],
L
Linus Torvalds 已提交
2574 2575
		.maxlen		= sizeof(int),
		.mode		= 0444,
2576
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2577 2578 2579
	},
	{
		.procname	= "free_dquots",
2580
		.data		= &dqstats.stat[DQST_FREE_DQUOTS],
L
Linus Torvalds 已提交
2581 2582
		.maxlen		= sizeof(int),
		.mode		= 0444,
2583
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2584 2585 2586
	},
	{
		.procname	= "syncs",
2587
		.data		= &dqstats.stat[DQST_SYNCS],
L
Linus Torvalds 已提交
2588 2589
		.maxlen		= sizeof(int),
		.mode		= 0444,
2590
		.proc_handler	= do_proc_dqstats,
L
Linus Torvalds 已提交
2591
	},
2592
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
2593 2594 2595 2596 2597
	{
		.procname	= "warnings",
		.data		= &flag_print_warnings,
		.maxlen		= sizeof(int),
		.mode		= 0644,
2598
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2599
	},
2600
#endif
2601
	{ },
L
Linus Torvalds 已提交
2602 2603 2604 2605 2606 2607 2608 2609
};

static ctl_table fs_table[] = {
	{
		.procname	= "quota",
		.mode		= 0555,
		.child		= fs_dqstats_table,
	},
2610
	{ },
L
Linus Torvalds 已提交
2611 2612 2613 2614 2615 2616 2617 2618
};

static ctl_table sys_table[] = {
	{
		.procname	= "fs",
		.mode		= 0555,
		.child		= fs_table,
	},
2619
	{ },
L
Linus Torvalds 已提交
2620 2621 2622 2623
};

static int __init dquot_init(void)
{
2624
	int i, ret;
L
Linus Torvalds 已提交
2625 2626 2627 2628
	unsigned long nr_hash, order;

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

2629
	register_sysctl_table(sys_table);
L
Linus Torvalds 已提交
2630

2631
	dquot_cachep = kmem_cache_create("dquot",
L
Linus Torvalds 已提交
2632
			sizeof(struct dquot), sizeof(unsigned long) * 4,
2633 2634
			(SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
				SLAB_MEM_SPREAD|SLAB_PANIC),
2635
			NULL);
L
Linus Torvalds 已提交
2636 2637 2638 2639 2640 2641

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

2642 2643 2644 2645 2646
	for (i = 0; i < _DQST_DQSTAT_LAST; i++) {
		ret = percpu_counter_init(&dqstats.counter[i], 0);
		if (ret)
			panic("Cannot create dquot stat counters");
	}
2647

L
Linus Torvalds 已提交
2648 2649 2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663
	/* 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);

	printk("Dquot-cache hash table entries: %ld (order %ld, %ld bytes)\n",
			nr_hash, order, (PAGE_SIZE << order));

2664
	register_shrinker(&dqcache_shrinker);
L
Linus Torvalds 已提交
2665 2666 2667 2668

	return 0;
}
module_init(dquot_init);
新手
引导
客服 返回
顶部