dquot.c 70.2 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 85 86 87
 * There are three quota SMP locks. dq_list_lock protects all lists with quotas
 * and quota formats, dqstats structure containing statistics about the lists
 * 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

static char *quotatypes[] = INITQFNAMES;
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 */
140
static struct kmem_cache *dquot_cachep;
L
Linus Torvalds 已提交
141 142 143 144 145 146 147 148 149

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;
}
150
EXPORT_SYMBOL(register_quota_format);
L
Linus Torvalds 已提交
151 152 153 154 155 156

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

	spin_lock(&dq_list_lock);
J
Jan Kara 已提交
157 158 159
	for (actqf = &quota_formats; *actqf && *actqf != fmt;
	     actqf = &(*actqf)->qf_next)
		;
L
Linus Torvalds 已提交
160 161 162 163
	if (*actqf)
		*actqf = (*actqf)->qf_next;
	spin_unlock(&dq_list_lock);
}
164
EXPORT_SYMBOL(unregister_quota_format);
L
Linus Torvalds 已提交
165 166 167 168 169 170

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

	spin_lock(&dq_list_lock);
J
Jan Kara 已提交
171 172 173
	for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
	     actqf = actqf->qf_next)
		;
L
Linus Torvalds 已提交
174 175 176 177 178
	if (!actqf || !try_module_get(actqf->qf_owner)) {
		int qm;

		spin_unlock(&dq_list_lock);
		
J
Jan Kara 已提交
179 180 181 182 183
		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 已提交
184 185 186
			return NULL;

		spin_lock(&dq_list_lock);
J
Jan Kara 已提交
187 188 189
		for (actqf = quota_formats; actqf && actqf->qf_fmt_id != id;
		     actqf = actqf->qf_next)
			;
L
Linus Torvalds 已提交
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227
		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;
228
EXPORT_SYMBOL(dqstats);
L
Linus Torvalds 已提交
229

230
static qsize_t inode_get_rsv_space(struct inode *inode);
231
static void __dquot_initialize(struct inode *inode, int type);
232

L
Linus Torvalds 已提交
233 234 235 236 237 238 239 240 241 242 243 244 245 246
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 已提交
247 248
	struct hlist_head *head;
	head = dquot_hash + hashfn(dquot->dq_sb, dquot->dq_id, dquot->dq_type);
L
Linus Torvalds 已提交
249 250 251 252 253 254 255 256
	hlist_add_head(&dquot->dq_hash, head);
}

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

257 258
static struct dquot *find_dquot(unsigned int hashent, struct super_block *sb,
				unsigned int id, int type)
L
Linus Torvalds 已提交
259 260 261 262 263 264
{
	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 已提交
265 266
		if (dquot->dq_sb == sb && dquot->dq_id == id &&
		    dquot->dq_type == type)
L
Linus Torvalds 已提交
267 268
			return dquot;
	}
J
Jan Kara 已提交
269
	return NULL;
L
Linus Torvalds 已提交
270 271 272 273 274
}

/* Add a dquot to the tail of the free list */
static inline void put_dquot_last(struct dquot *dquot)
{
275
	list_add_tail(&dquot->dq_free, &free_dquots);
L
Linus Torvalds 已提交
276 277 278 279 280 281 282 283 284 285 286 287 288 289 290
	dqstats.free_dquots++;
}

static inline void remove_free_dquot(struct dquot *dquot)
{
	if (list_empty(&dquot->dq_free))
		return;
	list_del_init(&dquot->dq_free);
	dqstats.free_dquots--;
}

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 */
291
	list_add_tail(&dquot->dq_inuse, &inuse_list);
L
Linus Torvalds 已提交
292 293 294 295 296 297 298 299 300 301 302 303 304 305
	dqstats.allocated_dquots++;
}

static inline void remove_inuse(struct dquot *dquot)
{
	dqstats.allocated_dquots--;
	list_del(&dquot->dq_inuse);
}
/*
 * End of list functions needing dq_list_lock
 */

static void wait_on_dquot(struct dquot *dquot)
{
I
Ingo Molnar 已提交
306 307
	mutex_lock(&dquot->dq_lock);
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
308 309
}

J
Jan Kara 已提交
310 311 312 313 314 315 316 317 318
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 已提交
319

320
/* Mark dquot dirty in atomic manner, and return it's old dirty flag state */
L
Linus Torvalds 已提交
321 322
int dquot_mark_dquot_dirty(struct dquot *dquot)
{
323 324 325 326 327 328
	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 已提交
329
	spin_lock(&dq_list_lock);
330
	if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags)) {
L
Linus Torvalds 已提交
331 332
		list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
				info[dquot->dq_type].dqi_dirty_list);
333 334
		ret = 0;
	}
L
Linus Torvalds 已提交
335
	spin_unlock(&dq_list_lock);
336
	return ret;
L
Linus Torvalds 已提交
337
}
338
EXPORT_SYMBOL(dquot_mark_dquot_dirty);
L
Linus Torvalds 已提交
339

340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363
/* 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 已提交
364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387
/* 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 已提交
388 389
	mutex_lock(&dquot->dq_lock);
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
390 391 392 393 394 395 396 397 398
	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 已提交
399 400 401 402
		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 已提交
403 404 405 406 407 408 409 410 411
		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 已提交
412 413
	mutex_unlock(&dqopt->dqio_mutex);
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
414 415
	return ret;
}
416
EXPORT_SYMBOL(dquot_acquire);
L
Linus Torvalds 已提交
417 418 419 420 421 422 423 424 425

/*
 *	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 已提交
426
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
427 428 429 430 431 432 433 434 435 436
	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 已提交
437 438 439 440
		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 已提交
441 442 443 444
		if (ret >= 0)
			ret = ret2;
	}
out_sem:
I
Ingo Molnar 已提交
445
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
446 447
	return ret;
}
448
EXPORT_SYMBOL(dquot_commit);
L
Linus Torvalds 已提交
449 450 451 452 453 454 455 456 457

/*
 *	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 已提交
458
	mutex_lock(&dquot->dq_lock);
L
Linus Torvalds 已提交
459 460 461
	/* Check whether we are not racing with some other dqget() */
	if (atomic_read(&dquot->dq_count) > 1)
		goto out_dqlock;
I
Ingo Molnar 已提交
462
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
463 464 465
	if (dqopt->ops[dquot->dq_type]->release_dqblk) {
		ret = dqopt->ops[dquot->dq_type]->release_dqblk(dquot);
		/* Write the info */
J
Jan Kara 已提交
466 467 468 469
		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 已提交
470 471 472 473
		if (ret >= 0)
			ret = ret2;
	}
	clear_bit(DQ_ACTIVE_B, &dquot->dq_flags);
I
Ingo Molnar 已提交
474
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
475
out_dqlock:
I
Ingo Molnar 已提交
476
	mutex_unlock(&dquot->dq_lock);
L
Linus Torvalds 已提交
477 478
	return ret;
}
479
EXPORT_SYMBOL(dquot_release);
L
Linus Torvalds 已提交
480

481
void dquot_destroy(struct dquot *dquot)
482 483 484
{
	kmem_cache_free(dquot_cachep, dquot);
}
485
EXPORT_SYMBOL(dquot_destroy);
486 487 488 489 490 491

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

L
Linus Torvalds 已提交
492 493
/* 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
494 495
 * 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 已提交
496
 * list) or parallel quotactl call. We have to wait for such users.
497
 */
L
Linus Torvalds 已提交
498 499
static void invalidate_dquots(struct super_block *sb, int type)
{
500
	struct dquot *dquot, *tmp;
L
Linus Torvalds 已提交
501

502
restart:
L
Linus Torvalds 已提交
503
	spin_lock(&dq_list_lock);
504
	list_for_each_entry_safe(dquot, tmp, &inuse_list, dq_inuse) {
L
Linus Torvalds 已提交
505 506 507 508
		if (dquot->dq_sb != sb)
			continue;
		if (dquot->dq_type != type)
			continue;
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536
		/* 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 已提交
537 538 539
		remove_dquot_hash(dquot);
		remove_free_dquot(dquot);
		remove_inuse(dquot);
540
		do_destroy_dquot(dquot);
L
Linus Torvalds 已提交
541 542 543 544
	}
	spin_unlock(&dq_list_lock);
}

545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578
/* 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);
		dqstats.lookups++;
		spin_unlock(&dq_list_lock);
		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;
}
579
EXPORT_SYMBOL(dquot_scan_active);
580

581
int vfs_quota_sync(struct super_block *sb, int type, int wait)
L
Linus Torvalds 已提交
582 583 584 585 586 587
{
	struct list_head *dirty;
	struct dquot *dquot;
	struct quota_info *dqopt = sb_dqopt(sb);
	int cnt;

I
Ingo Molnar 已提交
588
	mutex_lock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
589 590 591
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
592
		if (!sb_has_quota_active(sb, cnt))
L
Linus Torvalds 已提交
593 594 595 596
			continue;
		spin_lock(&dq_list_lock);
		dirty = &dqopt->info[cnt].dqi_dirty_list;
		while (!list_empty(dirty)) {
J
Jan Kara 已提交
597 598
			dquot = list_first_entry(dirty, struct dquot,
						 dq_dirty);
L
Linus Torvalds 已提交
599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
			/* 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);
			dqstats.lookups++;
			spin_unlock(&dq_list_lock);
			sb->dq_op->write_dquot(dquot);
			dqput(dquot);
			spin_lock(&dq_list_lock);
		}
		spin_unlock(&dq_list_lock);
	}

	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
618 619
		if ((cnt == type || type == -1) && sb_has_quota_active(sb, cnt)
		    && info_dirty(&dqopt->info[cnt]))
L
Linus Torvalds 已提交
620 621 622 623
			sb->dq_op->write_info(sb, cnt);
	spin_lock(&dq_list_lock);
	dqstats.syncs++;
	spin_unlock(&dq_list_lock);
I
Ingo Molnar 已提交
624
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
625

626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652
	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 已提交
653 654
	return 0;
}
655
EXPORT_SYMBOL(vfs_quota_sync);
L
Linus Torvalds 已提交
656 657 658 659 660 661 662 663 664 665 666 667 668

/* 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);
669
		do_destroy_dquot(dquot);
L
Linus Torvalds 已提交
670 671 672 673 674 675 676 677 678 679
		count--;
		head = free_dquots.prev;
	}
}

/*
 * This is called from kswapd when we think we need some
 * more memory
 */

A
Al Viro 已提交
680
static int shrink_dqcache_memory(int nr, gfp_t gfp_mask)
L
Linus Torvalds 已提交
681 682 683 684 685 686 687 688 689
{
	if (nr) {
		spin_lock(&dq_list_lock);
		prune_dqcache(nr);
		spin_unlock(&dq_list_lock);
	}
	return (dqstats.free_dquots / 100) * sysctl_vfs_cache_pressure;
}

690 691 692 693 694
static struct shrinker dqcache_shrinker = {
	.shrink = shrink_dqcache_memory,
	.seeks = DEFAULT_SEEKS,
};

L
Linus Torvalds 已提交
695 696 697 698
/*
 * Put reference to dquot
 * NOTE: If you change this function please check whether dqput_blocks() works right...
 */
699
void dqput(struct dquot *dquot)
L
Linus Torvalds 已提交
700
{
701 702
	int ret;

L
Linus Torvalds 已提交
703 704
	if (!dquot)
		return;
705
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723
	if (!atomic_read(&dquot->dq_count)) {
		printk("VFS: dqput: trying to free free dquot\n");
		printk("VFS: device %s, dquot of %s %d\n",
			dquot->dq_sb->s_id,
			quotatypes[dquot->dq_type],
			dquot->dq_id);
		BUG();
	}
#endif
	
	spin_lock(&dq_list_lock);
	dqstats.drops++;
	spin_unlock(&dq_list_lock);
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);
724
		/* Releasing dquot during quotaoff phase? */
725
		if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) &&
726 727
		    atomic_read(&dquot->dq_count) == 1)
			wake_up(&dquot->dq_wait_unused);
L
Linus Torvalds 已提交
728 729 730 731 732 733 734
		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 */
735 736 737 738 739 740 741 742 743 744 745 746 747
		ret = dquot->dq_sb->dq_op->write_dquot(dquot);
		if (ret < 0) {
			printk(KERN_ERR "VFS: cannot write quota structure on "
				"device %s (error %d). Quota may get out of "
				"sync!\n", dquot->dq_sb->s_id, ret);
			/*
			 * 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 已提交
748 749 750 751 752 753 754 755 756 757
		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);
758
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
759
	/* sanity check */
760
	BUG_ON(!list_empty(&dquot->dq_free));
L
Linus Torvalds 已提交
761 762 763 764
#endif
	put_dquot_last(dquot);
	spin_unlock(&dq_list_lock);
}
765
EXPORT_SYMBOL(dqput);
L
Linus Torvalds 已提交
766

767
struct dquot *dquot_alloc(struct super_block *sb, int type)
768 769 770
{
	return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
}
771
EXPORT_SYMBOL(dquot_alloc);
772

L
Linus Torvalds 已提交
773 774 775 776
static struct dquot *get_empty_dquot(struct super_block *sb, int type)
{
	struct dquot *dquot;

777
	dquot = sb->dq_op->alloc_dquot(sb, type);
L
Linus Torvalds 已提交
778
	if(!dquot)
J
Jan Kara 已提交
779
		return NULL;
L
Linus Torvalds 已提交
780

I
Ingo Molnar 已提交
781
	mutex_init(&dquot->dq_lock);
L
Linus Torvalds 已提交
782 783 784 785
	INIT_LIST_HEAD(&dquot->dq_free);
	INIT_LIST_HEAD(&dquot->dq_inuse);
	INIT_HLIST_NODE(&dquot->dq_hash);
	INIT_LIST_HEAD(&dquot->dq_dirty);
786
	init_waitqueue_head(&dquot->dq_wait_unused);
L
Linus Torvalds 已提交
787 788 789 790 791 792 793 794 795
	dquot->dq_sb = sb;
	dquot->dq_type = type;
	atomic_set(&dquot->dq_count, 1);

	return dquot;
}

/*
 * Get reference to dquot
J
Jan Kara 已提交
796 797 798 799 800
 *
 * 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 已提交
801
 */
802
struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
L
Linus Torvalds 已提交
803 804
{
	unsigned int hashent = hashfn(sb, id, type);
J
Jan Kara 已提交
805
	struct dquot *dquot = NULL, *empty = NULL;
L
Linus Torvalds 已提交
806

807
        if (!sb_has_quota_active(sb, type))
J
Jan Kara 已提交
808
		return NULL;
L
Linus Torvalds 已提交
809 810
we_slept:
	spin_lock(&dq_list_lock);
J
Jan Kara 已提交
811 812 813 814 815 816 817 818
	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 已提交
819 820 821
	dquot = find_dquot(hashent, sb, id, type);
	if (!dquot) {
		if (!empty) {
L
Linus Torvalds 已提交
822
			spin_unlock(&dq_list_lock);
J
Jan Kara 已提交
823 824
			empty = get_empty_dquot(sb, type);
			if (!empty)
L
Linus Torvalds 已提交
825 826 827 828
				schedule();	/* Try to wait for a moment... */
			goto we_slept;
		}
		dquot = empty;
J
Jan Kara 已提交
829
		empty = NULL;
L
Linus Torvalds 已提交
830 831 832 833 834 835 836 837 838 839 840 841 842 843 844
		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);
		dqstats.lookups++;
		spin_unlock(&dq_list_lock);
	} else {
		if (!atomic_read(&dquot->dq_count))
			remove_free_dquot(dquot);
		atomic_inc(&dquot->dq_count);
		dqstats.cache_hits++;
		dqstats.lookups++;
		spin_unlock(&dq_list_lock);
	}
J
Jan Kara 已提交
845 846
	/* 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 已提交
847
	wait_on_dquot(dquot);
J
Jan Kara 已提交
848 849 850
	/* 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 已提交
851
		dqput(dquot);
J
Jan Kara 已提交
852
		dquot = NULL;
J
Jan Kara 已提交
853
		goto out;
L
Linus Torvalds 已提交
854
	}
855
#ifdef CONFIG_QUOTA_DEBUG
856
	BUG_ON(!dquot->dq_sb);	/* Has somebody invalidated entry under us? */
L
Linus Torvalds 已提交
857
#endif
J
Jan Kara 已提交
858 859 860
out:
	if (empty)
		do_destroy_dquot(empty);
L
Linus Torvalds 已提交
861 862 863

	return dquot;
}
864
EXPORT_SYMBOL(dqget);
L
Linus Torvalds 已提交
865 866 867 868 869 870 871 872

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

	if (IS_NOQUOTA(inode))
		return 0;
	if (type != -1)
J
Jan Kara 已提交
873
		return !inode->i_dquot[type];
L
Linus Torvalds 已提交
874
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
J
Jan Kara 已提交
875
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
876 877 878 879
			return 1;
	return 0;
}

I
Ingo Molnar 已提交
880
/* This routine is guarded by dqonoff_mutex mutex */
L
Linus Torvalds 已提交
881 882
static void add_dquot_ref(struct super_block *sb, int type)
{
883
	struct inode *inode, *old_inode = NULL;
884
#ifdef CONFIG_QUOTA_DEBUG
885
	int reserved = 0;
886
#endif
L
Linus Torvalds 已提交
887

888 889
	spin_lock(&inode_lock);
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
890
		if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW))
N
Nick Piggin 已提交
891
			continue;
892
#ifdef CONFIG_QUOTA_DEBUG
893 894
		if (unlikely(inode_get_rsv_space(inode) > 0))
			reserved = 1;
895
#endif
896 897 898 899 900 901 902 903
		if (!atomic_read(&inode->i_writecount))
			continue;
		if (!dqinit_needed(inode, type))
			continue;

		__iget(inode);
		spin_unlock(&inode_lock);

904
		iput(old_inode);
905
		__dquot_initialize(inode, type);
906 907 908 909 910 911 912
		/* 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 已提交
913
	}
914
	spin_unlock(&inode_lock);
915
	iput(old_inode);
916

917
#ifdef CONFIG_QUOTA_DEBUG
918 919 920 921 922
	if (reserved) {
		printk(KERN_WARNING "VFS (%s): Writes happened before quota"
			" was turned on thus quota information is probably "
			"inconsistent. Please run quotacheck(8).\n", sb->s_id);
	}
923
#endif
L
Linus Torvalds 已提交
924 925
}

J
Jan Kara 已提交
926 927 928 929
/*
 * Return 0 if dqput() won't block.
 * (note that 1 doesn't necessarily mean blocking)
 */
L
Linus Torvalds 已提交
930 931 932 933 934 935 936
static inline int dqput_blocks(struct dquot *dquot)
{
	if (atomic_read(&dquot->dq_count) <= 1)
		return 1;
	return 0;
}

J
Jan Kara 已提交
937 938 939 940 941
/*
 * 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...
 */
942 943
static int remove_inode_dquot_ref(struct inode *inode, int type,
				  struct list_head *tofree_head)
L
Linus Torvalds 已提交
944 945 946
{
	struct dquot *dquot = inode->i_dquot[type];

J
Jan Kara 已提交
947 948
	inode->i_dquot[type] = NULL;
	if (dquot) {
L
Linus Torvalds 已提交
949
		if (dqput_blocks(dquot)) {
950
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
951 952 953 954
			if (atomic_read(&dquot->dq_count) != 1)
				printk(KERN_WARNING "VFS: Adding dquot with dq_count %d to dispose list.\n", atomic_read(&dquot->dq_count));
#endif
			spin_lock(&dq_list_lock);
J
Jan Kara 已提交
955 956 957
			/* As dquot must have currently users it can't be on
			 * the free list... */
			list_add(&dquot->dq_free, tofree_head);
L
Linus Torvalds 已提交
958 959 960 961 962 963 964 965 966
			spin_unlock(&dq_list_lock);
			return 1;
		}
		else
			dqput(dquot);   /* We have guaranteed we won't block */
	}
	return 0;
}

J
Jan Kara 已提交
967 968 969 970 971
/*
 * 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 已提交
972 973 974 975 976 977 978 979 980
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 已提交
981 982
		/* Remove dquot from the list so we won't have problems... */
		list_del_init(&dquot->dq_free);
L
Linus Torvalds 已提交
983 984 985 986
		dqput(dquot);
	}
}

987 988 989 990 991 992 993
static void remove_dquot_ref(struct super_block *sb, int type,
		struct list_head *tofree_head)
{
	struct inode *inode;

	spin_lock(&inode_lock);
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
N
Nick Piggin 已提交
994 995 996 997 998 999
		/*
		 *  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).
		 */
1000 1001 1002 1003 1004 1005
		if (!IS_NOQUOTA(inode))
			remove_inode_dquot_ref(inode, type, tofree_head);
	}
	spin_unlock(&inode_lock);
}

L
Linus Torvalds 已提交
1006 1007 1008 1009 1010
/* Gather all references from inodes and drop them */
static void drop_dquot_ref(struct super_block *sb, int type)
{
	LIST_HEAD(tofree_head);

1011 1012 1013 1014 1015 1016
	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 已提交
1017 1018
}

1019
static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1020 1021 1022 1023 1024 1025 1026 1027 1028
{
	dquot->dq_dqb.dqb_curinodes += number;
}

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

1029 1030 1031 1032 1033
static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
{
	dquot->dq_dqb.dqb_rsvspace += number;
}

1034 1035 1036
/*
 * Claim reserved quota space
 */
1037
static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
1038
{
1039 1040 1041 1042
	if (dquot->dq_dqb.dqb_rsvspace < number) {
		WARN_ON_ONCE(1);
		number = dquot->dq_dqb.dqb_rsvspace;
	}
1043 1044 1045 1046 1047 1048 1049
	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)
{
1050 1051 1052 1053 1054 1055
	if (dquot->dq_dqb.dqb_rsvspace >= number)
		dquot->dq_dqb.dqb_rsvspace -= number;
	else {
		WARN_ON_ONCE(1);
		dquot->dq_dqb.dqb_rsvspace = 0;
	}
1056 1057
}

1058
static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1059
{
1060 1061
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curinodes >= number)
L
Linus Torvalds 已提交
1062 1063 1064 1065 1066 1067 1068 1069
		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);
}

1070
static void dquot_decr_space(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1071
{
1072 1073
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curspace >= number)
L
Linus Torvalds 已提交
1074 1075 1076
		dquot->dq_dqb.dqb_curspace -= number;
	else
		dquot->dq_dqb.dqb_curspace = 0;
1077
	if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
L
Linus Torvalds 已提交
1078 1079 1080 1081
		dquot->dq_dqb.dqb_btime = (time_t) 0;
	clear_bit(DQ_BLKS_B, &dquot->dq_flags);
}

1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
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);
}

1094
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
1095 1096
static int flag_print_warnings = 1;

1097
static int need_print_warning(struct dquot *dquot)
L
Linus Torvalds 已提交
1098 1099 1100 1101 1102 1103
{
	if (!flag_print_warnings)
		return 0;

	switch (dquot->dq_type) {
		case USRQUOTA:
1104
			return current_fsuid() == dquot->dq_id;
L
Linus Torvalds 已提交
1105 1106 1107 1108 1109 1110 1111
		case GRPQUOTA:
			return in_group_p(dquot->dq_id);
	}
	return 0;
}

/* Print warning to user which exceeded quota */
1112
static void print_warning(struct dquot *dquot, const int warntype)
L
Linus Torvalds 已提交
1113 1114
{
	char *msg = NULL;
1115
	struct tty_struct *tty;
L
Linus Torvalds 已提交
1116

1117 1118 1119 1120
	if (warntype == QUOTA_NL_IHARDBELOW ||
	    warntype == QUOTA_NL_ISOFTBELOW ||
	    warntype == QUOTA_NL_BHARDBELOW ||
	    warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(dquot))
L
Linus Torvalds 已提交
1121 1122
		return;

1123 1124
	tty = get_current_tty();
	if (!tty)
1125
		return;
1126
	tty_write_message(tty, dquot->dq_sb->s_id);
1127
	if (warntype == QUOTA_NL_ISOFTWARN || warntype == QUOTA_NL_BSOFTWARN)
1128
		tty_write_message(tty, ": warning, ");
L
Linus Torvalds 已提交
1129
	else
1130 1131
		tty_write_message(tty, ": write failed, ");
	tty_write_message(tty, quotatypes[dquot->dq_type]);
L
Linus Torvalds 已提交
1132
	switch (warntype) {
1133
		case QUOTA_NL_IHARDWARN:
L
Linus Torvalds 已提交
1134 1135
			msg = " file limit reached.\r\n";
			break;
1136
		case QUOTA_NL_ISOFTLONGWARN:
L
Linus Torvalds 已提交
1137 1138
			msg = " file quota exceeded too long.\r\n";
			break;
1139
		case QUOTA_NL_ISOFTWARN:
L
Linus Torvalds 已提交
1140 1141
			msg = " file quota exceeded.\r\n";
			break;
1142
		case QUOTA_NL_BHARDWARN:
L
Linus Torvalds 已提交
1143 1144
			msg = " block limit reached.\r\n";
			break;
1145
		case QUOTA_NL_BSOFTLONGWARN:
L
Linus Torvalds 已提交
1146 1147
			msg = " block quota exceeded too long.\r\n";
			break;
1148
		case QUOTA_NL_BSOFTWARN:
L
Linus Torvalds 已提交
1149 1150 1151
			msg = " block quota exceeded.\r\n";
			break;
	}
1152
	tty_write_message(tty, msg);
1153
	tty_kref_put(tty);
L
Linus Torvalds 已提交
1154
}
1155 1156
#endif

1157 1158 1159 1160 1161
/*
 * Write warnings to the console and send warning messages over netlink.
 *
 * Note that this function can sleep.
 */
1162
static void flush_warnings(struct dquot *const *dquots, char *warntype)
L
Linus Torvalds 已提交
1163
{
1164
	struct dquot *dq;
L
Linus Torvalds 已提交
1165 1166
	int i;

1167 1168 1169 1170
	for (i = 0; i < MAXQUOTAS; i++) {
		dq = dquots[i];
		if (dq && warntype[i] != QUOTA_NL_NOWARN &&
		    !warning_issued(dq, warntype[i])) {
1171
#ifdef CONFIG_PRINT_QUOTA_WARNING
1172
			print_warning(dq, warntype[i]);
1173
#endif
1174 1175
			quota_send_warning(dq->dq_type, dq->dq_id,
					   dq->dq_sb->s_dev, warntype[i]);
1176
		}
1177
	}
L
Linus Torvalds 已提交
1178 1179
}

1180
static int ignore_hardlimit(struct dquot *dquot)
L
Linus Torvalds 已提交
1181 1182 1183 1184
{
	struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];

	return capable(CAP_SYS_RESOURCE) &&
J
Jan Kara 已提交
1185 1186
	       (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
		!(info->dqi_flags & V1_DQF_RSQUASH));
L
Linus Torvalds 已提交
1187 1188 1189
}

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

1194
	*warntype = QUOTA_NL_NOWARN;
1195 1196
	if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) ||
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1197
		return 0;
L
Linus Torvalds 已提交
1198 1199

	if (dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1200
	    newinodes > dquot->dq_dqb.dqb_ihardlimit &&
L
Linus Torvalds 已提交
1201
            !ignore_hardlimit(dquot)) {
1202
		*warntype = QUOTA_NL_IHARDWARN;
1203
		return -EDQUOT;
L
Linus Torvalds 已提交
1204 1205 1206
	}

	if (dquot->dq_dqb.dqb_isoftlimit &&
J
Jan Kara 已提交
1207 1208 1209
	    newinodes > dquot->dq_dqb.dqb_isoftlimit &&
	    dquot->dq_dqb.dqb_itime &&
	    get_seconds() >= dquot->dq_dqb.dqb_itime &&
L
Linus Torvalds 已提交
1210
            !ignore_hardlimit(dquot)) {
1211
		*warntype = QUOTA_NL_ISOFTLONGWARN;
1212
		return -EDQUOT;
L
Linus Torvalds 已提交
1213 1214 1215
	}

	if (dquot->dq_dqb.dqb_isoftlimit &&
J
Jan Kara 已提交
1216
	    newinodes > dquot->dq_dqb.dqb_isoftlimit &&
L
Linus Torvalds 已提交
1217
	    dquot->dq_dqb.dqb_itime == 0) {
1218
		*warntype = QUOTA_NL_ISOFTWARN;
J
Jan Kara 已提交
1219 1220
		dquot->dq_dqb.dqb_itime = get_seconds() +
		    sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace;
L
Linus Torvalds 已提交
1221 1222
	}

1223
	return 0;
L
Linus Torvalds 已提交
1224 1225 1226 1227 1228
}

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

1232
	*warntype = QUOTA_NL_NOWARN;
J
Jan Kara 已提交
1233
	if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) ||
1234
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1235
		return 0;
L
Linus Torvalds 已提交
1236

1237 1238 1239
	tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
		+ space;

L
Linus Torvalds 已提交
1240
	if (dquot->dq_dqb.dqb_bhardlimit &&
1241
	    tspace > dquot->dq_dqb.dqb_bhardlimit &&
L
Linus Torvalds 已提交
1242 1243
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1244
			*warntype = QUOTA_NL_BHARDWARN;
1245
		return -EDQUOT;
L
Linus Torvalds 已提交
1246 1247 1248
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1249
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
J
Jan Kara 已提交
1250 1251
	    dquot->dq_dqb.dqb_btime &&
	    get_seconds() >= dquot->dq_dqb.dqb_btime &&
L
Linus Torvalds 已提交
1252 1253
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1254
			*warntype = QUOTA_NL_BSOFTLONGWARN;
1255
		return -EDQUOT;
L
Linus Torvalds 已提交
1256 1257 1258
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1259
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
L
Linus Torvalds 已提交
1260 1261
	    dquot->dq_dqb.dqb_btime == 0) {
		if (!prealloc) {
1262
			*warntype = QUOTA_NL_BSOFTWARN;
J
Jan Kara 已提交
1263 1264
			dquot->dq_dqb.dqb_btime = get_seconds() +
			    sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace;
L
Linus Torvalds 已提交
1265 1266 1267 1268 1269 1270
		}
		else
			/*
			 * We don't allow preallocation to exceed softlimit so exceeding will
			 * be always printed
			 */
1271
			return -EDQUOT;
L
Linus Torvalds 已提交
1272 1273
	}

1274
	return 0;
L
Linus Torvalds 已提交
1275 1276
}

1277
static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1278
{
J
Jan Kara 已提交
1279 1280
	qsize_t newinodes;

1281
	if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1282 1283
	    dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
	    !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type))
1284 1285
		return QUOTA_NL_NOWARN;

J
Jan Kara 已提交
1286 1287
	newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
	if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1288 1289
		return QUOTA_NL_ISOFTBELOW;
	if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1290
	    newinodes < dquot->dq_dqb.dqb_ihardlimit)
1291 1292 1293 1294 1295 1296 1297
		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) ||
1298
	    dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
1299 1300
		return QUOTA_NL_NOWARN;

1301
	if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
1302
		return QUOTA_NL_BSOFTBELOW;
1303 1304
	if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
	    dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
1305 1306 1307
		return QUOTA_NL_BHARDBELOW;
	return QUOTA_NL_NOWARN;
}
1308

L
Linus Torvalds 已提交
1309
/*
1310 1311 1312 1313 1314 1315 1316
 * 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 已提交
1317
 */
1318
static void __dquot_initialize(struct inode *inode, int type)
L
Linus Torvalds 已提交
1319 1320
{
	unsigned int id = 0;
1321
	int cnt;
1322
	struct dquot *got[MAXQUOTAS];
J
Jan Kara 已提交
1323
	struct super_block *sb = inode->i_sb;
1324
	qsize_t rsv;
L
Linus Torvalds 已提交
1325

I
Ingo Molnar 已提交
1326 1327
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1328 1329
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode))
		return;
J
Jan Kara 已提交
1330 1331 1332

	/* First get references to structures we might need. */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
1333
		got[cnt] = NULL;
J
Jan Kara 已提交
1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347
		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 已提交
1348 1349 1350 1351 1352
	if (IS_NOQUOTA(inode))
		goto out_err;
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (type != -1 && cnt != type)
			continue;
J
Jan Kara 已提交
1353 1354 1355
		/* Avoid races with quotaoff() */
		if (!sb_has_quota_active(sb, cnt))
			continue;
J
Jan Kara 已提交
1356
		if (!inode->i_dquot[cnt]) {
J
Jan Kara 已提交
1357
			inode->i_dquot[cnt] = got[cnt];
J
Jan Kara 已提交
1358
			got[cnt] = NULL;
1359 1360 1361 1362 1363 1364 1365
			/*
			 * 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 已提交
1366 1367 1368
		}
	}
out_err:
J
Jan Kara 已提交
1369 1370
	up_write(&sb_dqopt(sb)->dqptr_sem);
	/* Drop unused references */
1371
	dqput_all(got);
1372 1373 1374 1375 1376
}

void dquot_initialize(struct inode *inode)
{
	__dquot_initialize(inode, -1);
L
Linus Torvalds 已提交
1377
}
1378
EXPORT_SYMBOL(dquot_initialize);
L
Linus Torvalds 已提交
1379 1380 1381 1382

/*
 * 	Release all quotas referenced by inode
 */
1383
static void __dquot_drop(struct inode *inode)
L
Linus Torvalds 已提交
1384 1385
{
	int cnt;
J
Jan Kara 已提交
1386
	struct dquot *put[MAXQUOTAS];
L
Linus Torvalds 已提交
1387

J
Jan Kara 已提交
1388
	down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
L
Linus Torvalds 已提交
1389
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1390
		put[cnt] = inode->i_dquot[cnt];
J
Jan Kara 已提交
1391
		inode->i_dquot[cnt] = NULL;
L
Linus Torvalds 已提交
1392 1393
	}
	up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1394
	dqput_all(put);
L
Linus Torvalds 已提交
1395 1396
}

1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
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);
1420

1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
/*
 * 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);
}

1433
void inode_add_rsv_space(struct inode *inode, qsize_t number)
1434 1435 1436 1437 1438
{
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) += number;
	spin_unlock(&inode->i_lock);
}
1439
EXPORT_SYMBOL(inode_add_rsv_space);
1440

1441
void inode_claim_rsv_space(struct inode *inode, qsize_t number)
1442 1443 1444 1445 1446 1447
{
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) -= number;
	__inode_add_bytes(inode, number);
	spin_unlock(&inode->i_lock);
}
1448
EXPORT_SYMBOL(inode_claim_rsv_space);
1449

1450
void inode_sub_rsv_space(struct inode *inode, qsize_t number)
1451 1452 1453 1454 1455
{
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) -= number;
	spin_unlock(&inode->i_lock);
}
1456
EXPORT_SYMBOL(inode_sub_rsv_space);
1457 1458 1459 1460

static qsize_t inode_get_rsv_space(struct inode *inode)
{
	qsize_t ret;
1461 1462 1463

	if (!inode->i_sb->dq_op->get_reserved_space)
		return 0;
1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
	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 已提交
1487
/*
1488 1489 1490 1491 1492 1493 1494
 * 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 已提交
1495 1496 1497 1498 1499
 */

/*
 * This operation can block, but only after everything is updated
 */
1500
int __dquot_alloc_space(struct inode *inode, qsize_t number,
1501
		int warn, int reserve)
L
Linus Torvalds 已提交
1502
{
1503
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1504 1505
	char warntype[MAXQUOTAS];

1506 1507 1508 1509
	/*
	 * First test before acquiring mutex - solves deadlocks when we
	 * re-enter the quota code and are already holding the mutex
	 */
1510
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
1511 1512 1513 1514 1515
		inode_incr_space(inode, number, reserve);
		goto out;
	}

	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
L
Linus Torvalds 已提交
1516
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1517
		warntype[cnt] = QUOTA_NL_NOWARN;
L
Linus Torvalds 已提交
1518 1519 1520

	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1521
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1522
			continue;
1523 1524 1525
		ret = check_bdq(inode->i_dquot[cnt], number, !warn,
				warntype+cnt);
		if (ret) {
1526 1527
			spin_unlock(&dq_data_lock);
			goto out_flush_warn;
1528
		}
L
Linus Torvalds 已提交
1529 1530
	}
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1531
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1532
			continue;
1533 1534 1535 1536
		if (reserve)
			dquot_resv_space(inode->i_dquot[cnt], number);
		else
			dquot_incr_space(inode->i_dquot[cnt], number);
L
Linus Torvalds 已提交
1537
	}
1538
	inode_incr_space(inode, number, reserve);
L
Linus Torvalds 已提交
1539
	spin_unlock(&dq_data_lock);
1540

1541 1542
	if (reserve)
		goto out_flush_warn;
1543
	mark_all_dquot_dirty(inode->i_dquot);
1544 1545
out_flush_warn:
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1546
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1547 1548 1549
out:
	return ret;
}
1550
EXPORT_SYMBOL(__dquot_alloc_space);
L
Linus Torvalds 已提交
1551 1552 1553 1554

/*
 * This operation can block, but only after everything is updated
 */
1555
int dquot_alloc_inode(const struct inode *inode)
L
Linus Torvalds 已提交
1556
{
1557
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1558 1559
	char warntype[MAXQUOTAS];

I
Ingo Molnar 已提交
1560 1561
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1562 1563
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode))
		return 0;
L
Linus Torvalds 已提交
1564
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1565
		warntype[cnt] = QUOTA_NL_NOWARN;
L
Linus Torvalds 已提交
1566 1567 1568
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1569
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1570
			continue;
1571 1572
		ret = check_idq(inode->i_dquot[cnt], 1, warntype + cnt);
		if (ret)
L
Linus Torvalds 已提交
1573 1574 1575 1576
			goto warn_put_all;
	}

	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1577
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1578
			continue;
1579
		dquot_incr_inodes(inode->i_dquot[cnt], 1);
L
Linus Torvalds 已提交
1580
	}
1581

L
Linus Torvalds 已提交
1582 1583
warn_put_all:
	spin_unlock(&dq_data_lock);
1584
	if (ret == 0)
1585
		mark_all_dquot_dirty(inode->i_dquot);
1586
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1587 1588 1589
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	return ret;
}
1590
EXPORT_SYMBOL(dquot_alloc_inode);
L
Linus Torvalds 已提交
1591

1592 1593 1594 1595
/*
 * Convert in-memory reserved quotas to real consumed quotas
 */
int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1596 1597 1598
{
	int cnt;

1599
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
1600
		inode_claim_rsv_space(inode, number);
1601
		return 0;
1602 1603 1604 1605 1606 1607
	}

	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 已提交
1608
		if (inode->i_dquot[cnt])
1609 1610 1611 1612
			dquot_claim_reserved_space(inode->i_dquot[cnt],
							number);
	}
	/* Update inode bytes */
1613
	inode_claim_rsv_space(inode, number);
1614
	spin_unlock(&dq_data_lock);
1615
	mark_all_dquot_dirty(inode->i_dquot);
1616
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1617
	return 0;
1618
}
1619
EXPORT_SYMBOL(dquot_claim_space_nodirty);
1620

L
Linus Torvalds 已提交
1621 1622 1623
/*
 * This operation can block, but only after everything is updated
 */
1624
void __dquot_free_space(struct inode *inode, qsize_t number, int reserve)
L
Linus Torvalds 已提交
1625 1626
{
	unsigned int cnt;
1627
	char warntype[MAXQUOTAS];
L
Linus Torvalds 已提交
1628

I
Ingo Molnar 已提交
1629 1630
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1631
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
1632
		inode_decr_space(inode, number, reserve);
1633
		return;
L
Linus Torvalds 已提交
1634
	}
1635

L
Linus Torvalds 已提交
1636 1637 1638
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1639
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1640
			continue;
1641
		warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number);
1642 1643 1644 1645
		if (reserve)
			dquot_free_reserved_space(inode->i_dquot[cnt], number);
		else
			dquot_decr_space(inode->i_dquot[cnt], number);
L
Linus Torvalds 已提交
1646
	}
1647
	inode_decr_space(inode, number, reserve);
L
Linus Torvalds 已提交
1648
	spin_unlock(&dq_data_lock);
1649 1650 1651

	if (reserve)
		goto out_unlock;
1652
	mark_all_dquot_dirty(inode->i_dquot);
1653
out_unlock:
1654
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1655
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1656
}
1657
EXPORT_SYMBOL(__dquot_free_space);
1658

L
Linus Torvalds 已提交
1659 1660 1661
/*
 * This operation can block, but only after everything is updated
 */
1662
void dquot_free_inode(const struct inode *inode)
L
Linus Torvalds 已提交
1663 1664
{
	unsigned int cnt;
1665
	char warntype[MAXQUOTAS];
L
Linus Torvalds 已提交
1666

I
Ingo Molnar 已提交
1667 1668
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1669 1670
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode))
		return;
1671

L
Linus Torvalds 已提交
1672 1673 1674
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1675
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1676
			continue;
1677 1678
		warntype[cnt] = info_idq_free(inode->i_dquot[cnt], 1);
		dquot_decr_inodes(inode->i_dquot[cnt], 1);
L
Linus Torvalds 已提交
1679 1680
	}
	spin_unlock(&dq_data_lock);
1681
	mark_all_dquot_dirty(inode->i_dquot);
1682
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1683 1684
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
}
1685
EXPORT_SYMBOL(dquot_free_inode);
L
Linus Torvalds 已提交
1686 1687 1688 1689 1690 1691 1692

/*
 * Transfer the number of inode and blocks from one diskquota to an other.
 *
 * This operation can block, but only after everything is updated
 * A transaction must be started when entering this function.
 */
1693
static int __dquot_transfer(struct inode *inode, qid_t *chid, unsigned long mask)
L
Linus Torvalds 已提交
1694
{
1695 1696
	qsize_t space, cur_space;
	qsize_t rsv_space = 0;
L
Linus Torvalds 已提交
1697 1698
	struct dquot *transfer_from[MAXQUOTAS];
	struct dquot *transfer_to[MAXQUOTAS];
1699
	int cnt, ret = 0;
1700 1701
	char warntype_to[MAXQUOTAS];
	char warntype_from_inodes[MAXQUOTAS], warntype_from_space[MAXQUOTAS];
L
Linus Torvalds 已提交
1702

I
Ingo Molnar 已提交
1703 1704
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
L
Linus Torvalds 已提交
1705
	if (IS_NOQUOTA(inode))
1706
		return 0;
J
Jan Kara 已提交
1707
	/* Initialize the arrays */
L
Linus Torvalds 已提交
1708
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1709 1710
		transfer_from[cnt] = NULL;
		transfer_to[cnt] = NULL;
1711
		warntype_to[cnt] = QUOTA_NL_NOWARN;
L
Linus Torvalds 已提交
1712
	}
1713 1714 1715 1716
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		if (mask & (1 << cnt))
			transfer_to[cnt] = dqget(inode->i_sb, chid[cnt], cnt);
	}
J
Jan Kara 已提交
1717 1718 1719 1720 1721
	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);
		goto put_all;
	}
L
Linus Torvalds 已提交
1722
	spin_lock(&dq_data_lock);
1723
	cur_space = inode_get_bytes(inode);
1724
	rsv_space = inode_get_rsv_space(inode);
1725
	space = cur_space + rsv_space;
L
Linus Torvalds 已提交
1726 1727
	/* Build the transfer_from list and check the limits */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1728
		if (!transfer_to[cnt])
L
Linus Torvalds 已提交
1729 1730
			continue;
		transfer_from[cnt] = inode->i_dquot[cnt];
1731 1732 1733 1734 1735
		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 已提交
1736
			goto over_quota;
L
Linus Torvalds 已提交
1737 1738 1739 1740 1741 1742 1743 1744 1745
	}

	/*
	 * Finally perform the needed transfer from transfer_from to transfer_to
	 */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		/*
		 * Skip changes for same uid or gid or for turned off quota-type.
		 */
J
Jan Kara 已提交
1746
		if (!transfer_to[cnt])
L
Linus Torvalds 已提交
1747 1748 1749 1750
			continue;

		/* Due to IO error we might not have transfer_from[] structure */
		if (transfer_from[cnt]) {
1751 1752 1753 1754
			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 已提交
1755
			dquot_decr_inodes(transfer_from[cnt], 1);
1756 1757 1758
			dquot_decr_space(transfer_from[cnt], cur_space);
			dquot_free_reserved_space(transfer_from[cnt],
						  rsv_space);
L
Linus Torvalds 已提交
1759 1760 1761
		}

		dquot_incr_inodes(transfer_to[cnt], 1);
1762 1763
		dquot_incr_space(transfer_to[cnt], cur_space);
		dquot_resv_space(transfer_to[cnt], rsv_space);
L
Linus Torvalds 已提交
1764 1765 1766 1767

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

1770 1771 1772 1773 1774
	mark_all_dquot_dirty(transfer_from);
	mark_all_dquot_dirty(transfer_to);
	/* The reference we got is transferred to the inode */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
		transfer_to[cnt] = NULL;
J
Jan Kara 已提交
1775
warn_put_all:
1776 1777 1778
	flush_warnings(transfer_to, warntype_to);
	flush_warnings(transfer_from, warntype_from_inodes);
	flush_warnings(transfer_from, warntype_from_space);
J
Jan Kara 已提交
1779
put_all:
1780 1781
	dqput_all(transfer_from);
	dqput_all(transfer_to);
L
Linus Torvalds 已提交
1782
	return ret;
J
Jan Kara 已提交
1783 1784 1785 1786 1787
over_quota:
	spin_unlock(&dq_data_lock);
	up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
	/* Clear dquot pointers we don't want to dqput() */
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
J
Jan Kara 已提交
1788
		transfer_from[cnt] = NULL;
J
Jan Kara 已提交
1789
	goto warn_put_all;
L
Linus Torvalds 已提交
1790 1791
}

1792 1793 1794
/* Wrapper for transferring ownership of an inode for uid/gid only
 * Called from FSXXX_setattr()
 */
1795
int dquot_transfer(struct inode *inode, struct iattr *iattr)
1796
{
1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807
	qid_t chid[MAXQUOTAS];
	unsigned long mask = 0;

	if (iattr->ia_valid & ATTR_UID && iattr->ia_uid != inode->i_uid) {
		mask |= 1 << USRQUOTA;
		chid[USRQUOTA] = iattr->ia_uid;
	}
	if (iattr->ia_valid & ATTR_GID && iattr->ia_gid != inode->i_gid) {
		mask |= 1 << GRPQUOTA;
		chid[GRPQUOTA] = iattr->ia_gid;
	}
1808
	if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode)) {
1809
		dquot_initialize(inode);
1810
		return __dquot_transfer(inode, chid, mask);
1811 1812 1813
	}
	return 0;
}
1814
EXPORT_SYMBOL(dquot_transfer);
1815

L
Linus Torvalds 已提交
1816 1817 1818 1819 1820 1821 1822 1823
/*
 * 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 已提交
1824
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
1825
	ret = dqopt->ops[type]->write_file_info(sb, type);
I
Ingo Molnar 已提交
1826
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
1827 1828
	return ret;
}
1829
EXPORT_SYMBOL(dquot_commit_info);
L
Linus Torvalds 已提交
1830 1831 1832 1833

/*
 * Definitions of diskquota operations.
 */
1834
const struct dquot_operations dquot_operations = {
L
Linus Torvalds 已提交
1835 1836 1837 1838
	.write_dquot	= dquot_commit,
	.acquire_dquot	= dquot_acquire,
	.release_dquot	= dquot_release,
	.mark_dirty	= dquot_mark_dquot_dirty,
1839 1840 1841
	.write_info	= dquot_commit_info,
	.alloc_dquot	= dquot_alloc,
	.destroy_dquot	= dquot_destroy,
L
Linus Torvalds 已提交
1842 1843
};

1844 1845 1846 1847 1848 1849 1850 1851 1852
/*
 * 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))
1853
		dquot_initialize(inode);
1854 1855 1856 1857
	return error;
}
EXPORT_SYMBOL(dquot_file_open);

L
Linus Torvalds 已提交
1858 1859 1860
/*
 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
 */
1861
int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags)
L
Linus Torvalds 已提交
1862
{
1863
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1864 1865 1866
	struct quota_info *dqopt = sb_dqopt(sb);
	struct inode *toputinode[MAXQUOTAS];

1867 1868 1869 1870 1871 1872 1873
	/* 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 已提交
1874
	/* We need to serialize quota_off() for device */
I
Ingo Molnar 已提交
1875
	mutex_lock(&dqopt->dqonoff_mutex);
1876 1877 1878 1879 1880 1881

	/*
	 * 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.
	 */
1882
	if (!sb_any_quota_loaded(sb)) {
1883 1884 1885
		mutex_unlock(&dqopt->dqonoff_mutex);
		return 0;
	}
L
Linus Torvalds 已提交
1886 1887 1888 1889
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		toputinode[cnt] = NULL;
		if (type != -1 && cnt != type)
			continue;
1890
		if (!sb_has_quota_loaded(sb, cnt))
1891
			continue;
1892 1893

		if (flags & DQUOT_SUSPENDED) {
J
Jan Kara 已提交
1894
			spin_lock(&dq_state_lock);
1895 1896
			dqopt->flags |=
				dquot_state_flag(DQUOT_SUSPENDED, cnt);
J
Jan Kara 已提交
1897
			spin_unlock(&dq_state_lock);
1898
		} else {
J
Jan Kara 已提交
1899
			spin_lock(&dq_state_lock);
1900 1901 1902 1903 1904 1905
			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 已提交
1906
				spin_unlock(&dq_state_lock);
1907 1908 1909 1910
				iput(dqopt->files[cnt]);
				dqopt->files[cnt] = NULL;
				continue;
			}
J
Jan Kara 已提交
1911
			spin_unlock(&dq_state_lock);
1912
		}
1913 1914 1915

		/* We still have to keep quota loaded? */
		if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
L
Linus Torvalds 已提交
1916 1917 1918 1919 1920 1921
			continue;

		/* Note: these are blocking operations */
		drop_dquot_ref(sb, cnt);
		invalidate_dquots(sb, cnt);
		/*
J
Jan Kara 已提交
1922 1923
		 * Now all dquots should be invalidated, all writes done so we
		 * should be only users of the info. No locks needed.
L
Linus Torvalds 已提交
1924 1925 1926 1927 1928 1929 1930 1931
		 */
		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];
1932
		if (!sb_has_quota_loaded(sb, cnt))
1933
			dqopt->files[cnt] = NULL;
L
Linus Torvalds 已提交
1934 1935 1936 1937 1938
		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 已提交
1939
	mutex_unlock(&dqopt->dqonoff_mutex);
1940 1941 1942 1943 1944

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

L
Linus Torvalds 已提交
1945
	/* Sync the superblock so that buffers with quota data are written to
1946
	 * disk (and so userspace sees correct data afterwards). */
L
Linus Torvalds 已提交
1947 1948 1949 1950 1951 1952 1953 1954 1955 1956
	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 已提交
1957
			mutex_lock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
1958 1959
			/* If quota was reenabled in the meantime, we have
			 * nothing to do */
1960
			if (!sb_has_quota_loaded(sb, cnt)) {
J
Jan Kara 已提交
1961 1962
				mutex_lock_nested(&toputinode[cnt]->i_mutex,
						  I_MUTEX_QUOTA);
L
Linus Torvalds 已提交
1963 1964
				toputinode[cnt]->i_flags &= ~(S_IMMUTABLE |
				  S_NOATIME | S_NOQUOTA);
J
Jan Kara 已提交
1965 1966
				truncate_inode_pages(&toputinode[cnt]->i_data,
						     0);
1967
				mutex_unlock(&toputinode[cnt]->i_mutex);
L
Linus Torvalds 已提交
1968 1969
				mark_inode_dirty(toputinode[cnt]);
			}
I
Ingo Molnar 已提交
1970
			mutex_unlock(&dqopt->dqonoff_mutex);
1971 1972 1973 1974 1975 1976
		}
	if (sb->s_bdev)
		invalidate_bdev(sb->s_bdev);
put_inodes:
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
		if (toputinode[cnt]) {
1977
			/* On remount RO, we keep the inode pointer so that we
1978 1979 1980 1981 1982 1983 1984
			 * 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))
1985 1986 1987
				iput(toputinode[cnt]);
			else if (!toputinode[cnt]->i_nlink)
				ret = -EBUSY;
L
Linus Torvalds 已提交
1988
		}
1989
	return ret;
L
Linus Torvalds 已提交
1990
}
1991
EXPORT_SYMBOL(vfs_quota_disable);
L
Linus Torvalds 已提交
1992

1993 1994 1995 1996 1997
int vfs_quota_off(struct super_block *sb, int type, int remount)
{
	return vfs_quota_disable(sb, type, remount ? DQUOT_SUSPENDED :
				 (DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED));
}
1998
EXPORT_SYMBOL(vfs_quota_off);
L
Linus Torvalds 已提交
1999 2000 2001 2002
/*
 *	Turn quotas on on a device
 */

2003 2004 2005 2006 2007 2008
/*
 * 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 已提交
2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029
{
	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;
	}
2030 2031 2032 2033 2034
	/* Usage always has to be set... */
	if (!(flags & DQUOT_USAGE_ENABLED)) {
		error = -EINVAL;
		goto out_fmt;
	}
L
Linus Torvalds 已提交
2035

2036
	if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2037 2038 2039 2040 2041 2042 2043
		/* 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);
2044 2045
		invalidate_bdev(sb->s_bdev);
	}
I
Ingo Molnar 已提交
2046
	mutex_lock(&dqopt->dqonoff_mutex);
2047
	if (sb_has_quota_loaded(sb, type)) {
L
Linus Torvalds 已提交
2048 2049 2050
		error = -EBUSY;
		goto out_lock;
	}
2051 2052 2053 2054 2055

	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. */
2056
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
J
Jan Kara 已提交
2057 2058
		oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
					     S_NOQUOTA);
2059
		inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
2060
		mutex_unlock(&inode->i_mutex);
2061 2062 2063 2064
		/*
		 * When S_NOQUOTA is set, remove dquot references as no more
		 * references can be added
		 */
2065
		__dquot_drop(inode);
2066
	}
L
Linus Torvalds 已提交
2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077

	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;
2078
	dqopt->info[type].dqi_fmt_id = format_id;
L
Linus Torvalds 已提交
2079
	INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
I
Ingo Molnar 已提交
2080
	mutex_lock(&dqopt->dqio_mutex);
J
Jan Kara 已提交
2081 2082
	error = dqopt->ops[type]->read_file_info(sb, type);
	if (error < 0) {
I
Ingo Molnar 已提交
2083
		mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
2084 2085
		goto out_file_init;
	}
I
Ingo Molnar 已提交
2086
	mutex_unlock(&dqopt->dqio_mutex);
J
Jan Kara 已提交
2087
	spin_lock(&dq_state_lock);
2088
	dqopt->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2089
	spin_unlock(&dq_state_lock);
L
Linus Torvalds 已提交
2090 2091

	add_dquot_ref(sb, type);
I
Ingo Molnar 已提交
2092
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
2093 2094 2095 2096 2097 2098 2099 2100

	return 0;

out_file_init:
	dqopt->files[type] = NULL;
	iput(inode);
out_lock:
	if (oldflags != -1) {
2101
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
L
Linus Torvalds 已提交
2102 2103 2104 2105
		/* 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;
2106
		mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
2107
	}
2108
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
2109 2110 2111 2112 2113 2114
out_fmt:
	put_quota_format(fmt);

	return error; 
}

2115 2116 2117 2118 2119 2120
/* Reenable quotas on remount RW */
static int vfs_quota_on_remount(struct super_block *sb, int type)
{
	struct quota_info *dqopt = sb_dqopt(sb);
	struct inode *inode;
	int ret;
2121
	unsigned int flags;
2122 2123 2124 2125 2126 2127 2128 2129

	mutex_lock(&dqopt->dqonoff_mutex);
	if (!sb_has_quota_suspended(sb, type)) {
		mutex_unlock(&dqopt->dqonoff_mutex);
		return 0;
	}
	inode = dqopt->files[type];
	dqopt->files[type] = NULL;
J
Jan Kara 已提交
2130
	spin_lock(&dq_state_lock);
2131 2132 2133
	flags = dqopt->flags & dquot_state_flag(DQUOT_USAGE_ENABLED |
						DQUOT_LIMITS_ENABLED, type);
	dqopt->flags &= ~dquot_state_flag(DQUOT_STATE_FLAGS, type);
J
Jan Kara 已提交
2134
	spin_unlock(&dq_state_lock);
2135 2136
	mutex_unlock(&dqopt->dqonoff_mutex);

2137 2138 2139
	flags = dquot_generic_flag(flags, type);
	ret = vfs_load_quota_inode(inode, type, dqopt->info[type].dqi_fmt_id,
				   flags);
2140 2141 2142 2143 2144
	iput(inode);

	return ret;
}

2145 2146 2147 2148 2149 2150 2151 2152 2153 2154
int vfs_quota_on_path(struct super_block *sb, int type, int format_id,
		      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
2155 2156 2157
		error = vfs_load_quota_inode(path->dentry->d_inode, type,
					     format_id, DQUOT_USAGE_ENABLED |
					     DQUOT_LIMITS_ENABLED);
2158 2159
	return error;
}
2160
EXPORT_SYMBOL(vfs_quota_on_path);
2161

2162
int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name,
2163
		 int remount)
L
Linus Torvalds 已提交
2164
{
2165
	struct path path;
L
Linus Torvalds 已提交
2166 2167
	int error;

2168 2169 2170
	if (remount)
		return vfs_quota_on_remount(sb, type);

2171
	error = kern_path(name, LOOKUP_FOLLOW, &path);
2172
	if (!error) {
2173 2174
		error = vfs_quota_on_path(sb, type, format_id, &path);
		path_put(&path);
2175
	}
L
Linus Torvalds 已提交
2176 2177
	return error;
}
2178
EXPORT_SYMBOL(vfs_quota_on);
L
Linus Torvalds 已提交
2179

2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
/*
 * More powerful function for turning on quotas allowing setting
 * of individual quota flags
 */
int vfs_quota_enable(struct inode *inode, int type, int format_id,
		unsigned int flags)
{
	int ret = 0;
	struct super_block *sb = inode->i_sb;
	struct quota_info *dqopt = sb_dqopt(sb);

	/* Just unsuspend quotas? */
	if (flags & DQUOT_SUSPENDED)
		return vfs_quota_on_remount(sb, type);
	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 已提交
2214
		spin_lock(&dq_state_lock);
2215
		sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2216
		spin_unlock(&dq_state_lock);
2217 2218 2219 2220 2221 2222 2223 2224
out_lock:
		mutex_unlock(&dqopt->dqonoff_mutex);
		return ret;
	}

load_quota:
	return vfs_load_quota_inode(inode, type, format_id, flags);
}
2225
EXPORT_SYMBOL(vfs_quota_enable);
2226

L
Linus Torvalds 已提交
2227 2228 2229 2230
/*
 * This function is used when filesystem needs to initialize quotas
 * during mount time.
 */
2231 2232
int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
		int format_id, int type)
L
Linus Torvalds 已提交
2233
{
2234
	struct dentry *dentry;
L
Linus Torvalds 已提交
2235 2236
	int error;

2237
	mutex_lock(&sb->s_root->d_inode->i_mutex);
2238
	dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
2239
	mutex_unlock(&sb->s_root->d_inode->i_mutex);
2240 2241 2242
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

2243 2244 2245 2246 2247
	if (!dentry->d_inode) {
		error = -ENOENT;
		goto out;
	}

L
Linus Torvalds 已提交
2248
	error = security_quota_on(dentry);
2249
	if (!error)
2250 2251
		error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
				DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2252

2253
out:
2254 2255
	dput(dentry);
	return error;
L
Linus Torvalds 已提交
2256
}
2257
EXPORT_SYMBOL(vfs_quota_on_mount);
L
Linus Torvalds 已提交
2258

2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273
/* Wrapper to turn on quotas when remounting rw */
int vfs_dq_quota_on_remount(struct super_block *sb)
{
	int cnt;
	int ret = 0, err;

	if (!sb->s_qcop || !sb->s_qcop->quota_on)
		return -ENOSYS;
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		err = sb->s_qcop->quota_on(sb, cnt, 0, NULL, 1);
		if (err < 0 && !ret)
			ret = err;
	}
	return ret;
}
2274
EXPORT_SYMBOL(vfs_dq_quota_on_remount);
2275

2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
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 已提交
2286 2287 2288 2289 2290 2291
/* Generic routine for getting common part of quota structure */
static void do_get_dqblk(struct dquot *dquot, struct if_dqblk *di)
{
	struct mem_dqblk *dm = &dquot->dq_dqb;

	spin_lock(&dq_data_lock);
2292 2293
	di->dqb_bhardlimit = stoqb(dm->dqb_bhardlimit);
	di->dqb_bsoftlimit = stoqb(dm->dqb_bsoftlimit);
2294
	di->dqb_curspace = dm->dqb_curspace + dm->dqb_rsvspace;
L
Linus Torvalds 已提交
2295 2296 2297 2298 2299 2300 2301 2302 2303
	di->dqb_ihardlimit = dm->dqb_ihardlimit;
	di->dqb_isoftlimit = dm->dqb_isoftlimit;
	di->dqb_curinodes = dm->dqb_curinodes;
	di->dqb_btime = dm->dqb_btime;
	di->dqb_itime = dm->dqb_itime;
	di->dqb_valid = QIF_ALL;
	spin_unlock(&dq_data_lock);
}

J
Jan Kara 已提交
2304 2305
int vfs_get_dqblk(struct super_block *sb, int type, qid_t id,
		  struct if_dqblk *di)
L
Linus Torvalds 已提交
2306 2307 2308
{
	struct dquot *dquot;

J
Jan Kara 已提交
2309
	dquot = dqget(sb, id, type);
J
Jan Kara 已提交
2310
	if (!dquot)
L
Linus Torvalds 已提交
2311 2312 2313
		return -ESRCH;
	do_get_dqblk(dquot, di);
	dqput(dquot);
J
Jan Kara 已提交
2314

L
Linus Torvalds 已提交
2315 2316
	return 0;
}
2317
EXPORT_SYMBOL(vfs_get_dqblk);
L
Linus Torvalds 已提交
2318 2319

/* Generic routine for setting common part of quota structure */
2320
static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di)
L
Linus Torvalds 已提交
2321 2322 2323
{
	struct mem_dqblk *dm = &dquot->dq_dqb;
	int check_blim = 0, check_ilim = 0;
2324 2325 2326 2327 2328 2329 2330 2331 2332
	struct mem_dqinfo *dqi = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];

	if ((di->dqb_valid & QIF_BLIMITS &&
	     (di->dqb_bhardlimit > dqi->dqi_maxblimit ||
	      di->dqb_bsoftlimit > dqi->dqi_maxblimit)) ||
	    (di->dqb_valid & QIF_ILIMITS &&
	     (di->dqb_ihardlimit > dqi->dqi_maxilimit ||
	      di->dqb_isoftlimit > dqi->dqi_maxilimit)))
		return -ERANGE;
L
Linus Torvalds 已提交
2333 2334 2335

	spin_lock(&dq_data_lock);
	if (di->dqb_valid & QIF_SPACE) {
2336
		dm->dqb_curspace = di->dqb_curspace - dm->dqb_rsvspace;
L
Linus Torvalds 已提交
2337
		check_blim = 1;
2338
		set_bit(DQ_LASTSET_B + QIF_SPACE_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2339 2340
	}
	if (di->dqb_valid & QIF_BLIMITS) {
2341 2342
		dm->dqb_bsoftlimit = qbtos(di->dqb_bsoftlimit);
		dm->dqb_bhardlimit = qbtos(di->dqb_bhardlimit);
L
Linus Torvalds 已提交
2343
		check_blim = 1;
2344
		set_bit(DQ_LASTSET_B + QIF_BLIMITS_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2345 2346 2347 2348
	}
	if (di->dqb_valid & QIF_INODES) {
		dm->dqb_curinodes = di->dqb_curinodes;
		check_ilim = 1;
2349
		set_bit(DQ_LASTSET_B + QIF_INODES_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2350 2351 2352 2353 2354
	}
	if (di->dqb_valid & QIF_ILIMITS) {
		dm->dqb_isoftlimit = di->dqb_isoftlimit;
		dm->dqb_ihardlimit = di->dqb_ihardlimit;
		check_ilim = 1;
2355
		set_bit(DQ_LASTSET_B + QIF_ILIMITS_B, &dquot->dq_flags);
L
Linus Torvalds 已提交
2356
	}
2357
	if (di->dqb_valid & QIF_BTIME) {
L
Linus Torvalds 已提交
2358
		dm->dqb_btime = di->dqb_btime;
2359
		check_blim = 1;
2360
		set_bit(DQ_LASTSET_B + QIF_BTIME_B, &dquot->dq_flags);
2361 2362
	}
	if (di->dqb_valid & QIF_ITIME) {
L
Linus Torvalds 已提交
2363
		dm->dqb_itime = di->dqb_itime;
2364
		check_ilim = 1;
2365
		set_bit(DQ_LASTSET_B + QIF_ITIME_B, &dquot->dq_flags);
2366
	}
L
Linus Torvalds 已提交
2367 2368

	if (check_blim) {
J
Jan Kara 已提交
2369 2370
		if (!dm->dqb_bsoftlimit ||
		    dm->dqb_curspace < dm->dqb_bsoftlimit) {
L
Linus Torvalds 已提交
2371 2372
			dm->dqb_btime = 0;
			clear_bit(DQ_BLKS_B, &dquot->dq_flags);
J
Jan Kara 已提交
2373 2374
		} else if (!(di->dqb_valid & QIF_BTIME))
			/* Set grace only if user hasn't provided his own... */
2375
			dm->dqb_btime = get_seconds() + dqi->dqi_bgrace;
L
Linus Torvalds 已提交
2376 2377
	}
	if (check_ilim) {
J
Jan Kara 已提交
2378 2379
		if (!dm->dqb_isoftlimit ||
		    dm->dqb_curinodes < dm->dqb_isoftlimit) {
L
Linus Torvalds 已提交
2380 2381
			dm->dqb_itime = 0;
			clear_bit(DQ_INODES_B, &dquot->dq_flags);
J
Jan Kara 已提交
2382 2383
		} else if (!(di->dqb_valid & QIF_ITIME))
			/* Set grace only if user hasn't provided his own... */
2384
			dm->dqb_itime = get_seconds() + dqi->dqi_igrace;
L
Linus Torvalds 已提交
2385
	}
J
Jan Kara 已提交
2386 2387
	if (dm->dqb_bhardlimit || dm->dqb_bsoftlimit || dm->dqb_ihardlimit ||
	    dm->dqb_isoftlimit)
L
Linus Torvalds 已提交
2388 2389 2390 2391 2392
		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);
2393 2394

	return 0;
L
Linus Torvalds 已提交
2395 2396
}

J
Jan Kara 已提交
2397 2398
int vfs_set_dqblk(struct super_block *sb, int type, qid_t id,
		  struct if_dqblk *di)
L
Linus Torvalds 已提交
2399 2400
{
	struct dquot *dquot;
2401
	int rc;
L
Linus Torvalds 已提交
2402

2403 2404 2405 2406
	dquot = dqget(sb, id, type);
	if (!dquot) {
		rc = -ESRCH;
		goto out;
L
Linus Torvalds 已提交
2407
	}
2408
	rc = do_set_dqblk(dquot, di);
L
Linus Torvalds 已提交
2409
	dqput(dquot);
2410
out:
2411
	return rc;
L
Linus Torvalds 已提交
2412
}
2413
EXPORT_SYMBOL(vfs_set_dqblk);
L
Linus Torvalds 已提交
2414 2415 2416 2417 2418 2419

/* Generic routine for getting common part of quota file information */
int vfs_get_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
{
	struct mem_dqinfo *mi;
  
I
Ingo Molnar 已提交
2420
	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2421
	if (!sb_has_quota_active(sb, type)) {
I
Ingo Molnar 已提交
2422
		mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
L
Linus Torvalds 已提交
2423 2424 2425 2426 2427 2428 2429 2430 2431
		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 已提交
2432
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
L
Linus Torvalds 已提交
2433 2434
	return 0;
}
2435
EXPORT_SYMBOL(vfs_get_dqinfo);
L
Linus Torvalds 已提交
2436 2437 2438 2439 2440

/* Generic routine for setting common part of quota file information */
int vfs_set_dqinfo(struct super_block *sb, int type, struct if_dqinfo *ii)
{
	struct mem_dqinfo *mi;
2441
	int err = 0;
L
Linus Torvalds 已提交
2442

I
Ingo Molnar 已提交
2443
	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2444 2445 2446
	if (!sb_has_quota_active(sb, type)) {
		err = -ESRCH;
		goto out;
L
Linus Torvalds 已提交
2447 2448 2449 2450 2451 2452 2453 2454
	}
	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 已提交
2455 2456
		mi->dqi_flags = (mi->dqi_flags & ~DQF_MASK) |
				(ii->dqi_flags & DQF_MASK);
L
Linus Torvalds 已提交
2457 2458 2459 2460
	spin_unlock(&dq_data_lock);
	mark_info_dirty(sb, type);
	/* Force write to disk */
	sb->dq_op->write_info(sb, type);
2461
out:
I
Ingo Molnar 已提交
2462
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
2463
	return err;
L
Linus Torvalds 已提交
2464
}
2465
EXPORT_SYMBOL(vfs_set_dqinfo);
L
Linus Torvalds 已提交
2466

2467
const struct quotactl_ops vfs_quotactl_ops = {
L
Linus Torvalds 已提交
2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482
	.quota_on	= vfs_quota_on,
	.quota_off	= vfs_quota_off,
	.quota_sync	= vfs_quota_sync,
	.get_info	= vfs_get_dqinfo,
	.set_info	= vfs_set_dqinfo,
	.get_dqblk	= vfs_get_dqblk,
	.set_dqblk	= vfs_set_dqblk
};

static ctl_table fs_dqstats_table[] = {
	{
		.procname	= "lookups",
		.data		= &dqstats.lookups,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2483
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2484 2485 2486 2487 2488 2489
	},
	{
		.procname	= "drops",
		.data		= &dqstats.drops,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2490
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2491 2492 2493 2494 2495 2496
	},
	{
		.procname	= "reads",
		.data		= &dqstats.reads,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2497
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2498 2499 2500 2501 2502 2503
	},
	{
		.procname	= "writes",
		.data		= &dqstats.writes,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2504
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2505 2506 2507 2508 2509 2510
	},
	{
		.procname	= "cache_hits",
		.data		= &dqstats.cache_hits,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2511
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2512 2513 2514 2515 2516 2517
	},
	{
		.procname	= "allocated_dquots",
		.data		= &dqstats.allocated_dquots,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2518
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2519 2520 2521 2522 2523 2524
	},
	{
		.procname	= "free_dquots",
		.data		= &dqstats.free_dquots,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2525
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2526 2527 2528 2529 2530 2531
	},
	{
		.procname	= "syncs",
		.data		= &dqstats.syncs,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2532
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2533
	},
2534
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
2535 2536 2537 2538 2539
	{
		.procname	= "warnings",
		.data		= &flag_print_warnings,
		.maxlen		= sizeof(int),
		.mode		= 0644,
2540
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2541
	},
2542
#endif
2543
	{ },
L
Linus Torvalds 已提交
2544 2545 2546 2547 2548 2549 2550 2551
};

static ctl_table fs_table[] = {
	{
		.procname	= "quota",
		.mode		= 0555,
		.child		= fs_dqstats_table,
	},
2552
	{ },
L
Linus Torvalds 已提交
2553 2554 2555 2556 2557 2558 2559 2560
};

static ctl_table sys_table[] = {
	{
		.procname	= "fs",
		.mode		= 0555,
		.child		= fs_table,
	},
2561
	{ },
L
Linus Torvalds 已提交
2562 2563 2564 2565 2566 2567 2568 2569 2570
};

static int __init dquot_init(void)
{
	int i;
	unsigned long nr_hash, order;

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

2571
	register_sysctl_table(sys_table);
L
Linus Torvalds 已提交
2572

2573
	dquot_cachep = kmem_cache_create("dquot",
L
Linus Torvalds 已提交
2574
			sizeof(struct dquot), sizeof(unsigned long) * 4,
2575 2576
			(SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
				SLAB_MEM_SPREAD|SLAB_PANIC),
2577
			NULL);
L
Linus Torvalds 已提交
2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599

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

	/* 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));

2600
	register_shrinker(&dqcache_shrinker);
L
Linus Torvalds 已提交
2601 2602 2603 2604

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