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

#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/mount.h>
#include <linux/mm.h>
#include <linux/time.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/fcntl.h>
#include <linux/stat.h>
#include <linux/tty.h>
#include <linux/file.h>
#include <linux/slab.h>
#include <linux/sysctl.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/proc_fs.h>
#include <linux/security.h>
#include <linux/kmod.h>
#include <linux/namei.h>
#include <linux/buffer_head.h>
77
#include <linux/capability.h>
78
#include <linux/quotaops.h>
79
#include <linux/writeback.h> /* for inode_lock, oddly enough.. */
L
Linus Torvalds 已提交
80 81 82 83

#include <asm/uaccess.h>

/*
J
Jan Kara 已提交
84 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 321 322 323 324 325 326 327 328

int dquot_mark_dquot_dirty(struct dquot *dquot)
{
	spin_lock(&dq_list_lock);
	if (!test_and_set_bit(DQ_MOD_B, &dquot->dq_flags))
		list_add(&dquot->dq_dirty, &sb_dqopt(dquot->dq_sb)->
				info[dquot->dq_type].dqi_dirty_list);
	spin_unlock(&dq_list_lock);
	return 0;
}
329
EXPORT_SYMBOL(dquot_mark_dquot_dirty);
L
Linus Torvalds 已提交
330

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

/*
 *	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 已提交
417
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
418 419 420 421 422 423 424 425 426 427
	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 已提交
428 429 430 431
		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 已提交
432 433 434 435
		if (ret >= 0)
			ret = ret2;
	}
out_sem:
I
Ingo Molnar 已提交
436
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
437 438
	return ret;
}
439
EXPORT_SYMBOL(dquot_commit);
L
Linus Torvalds 已提交
440 441 442 443 444 445 446 447 448

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

472
void dquot_destroy(struct dquot *dquot)
473 474 475
{
	kmem_cache_free(dquot_cachep, dquot);
}
476
EXPORT_SYMBOL(dquot_destroy);
477 478 479 480 481 482

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

L
Linus Torvalds 已提交
483 484
/* 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
485 486
 * 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 已提交
487
 * list) or parallel quotactl call. We have to wait for such users.
488
 */
L
Linus Torvalds 已提交
489 490
static void invalidate_dquots(struct super_block *sb, int type)
{
491
	struct dquot *dquot, *tmp;
L
Linus Torvalds 已提交
492

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

536 537 538 539 540 541 542 543 544 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
/* 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;
}
570
EXPORT_SYMBOL(dquot_scan_active);
571

572
int vfs_quota_sync(struct super_block *sb, int type, int wait)
L
Linus Torvalds 已提交
573 574 575 576 577 578
{
	struct list_head *dirty;
	struct dquot *dquot;
	struct quota_info *dqopt = sb_dqopt(sb);
	int cnt;

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

617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
	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 已提交
644 645
	return 0;
}
646
EXPORT_SYMBOL(vfs_quota_sync);
L
Linus Torvalds 已提交
647 648 649 650 651 652 653 654 655 656 657 658 659

/* 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);
660
		do_destroy_dquot(dquot);
L
Linus Torvalds 已提交
661 662 663 664 665 666 667 668 669 670
		count--;
		head = free_dquots.prev;
	}
}

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

A
Al Viro 已提交
671
static int shrink_dqcache_memory(int nr, gfp_t gfp_mask)
L
Linus Torvalds 已提交
672 673 674 675 676 677 678 679 680
{
	if (nr) {
		spin_lock(&dq_list_lock);
		prune_dqcache(nr);
		spin_unlock(&dq_list_lock);
	}
	return (dqstats.free_dquots / 100) * sysctl_vfs_cache_pressure;
}

681 682 683 684 685
static struct shrinker dqcache_shrinker = {
	.shrink = shrink_dqcache_memory,
	.seeks = DEFAULT_SEEKS,
};

L
Linus Torvalds 已提交
686 687 688 689
/*
 * Put reference to dquot
 * NOTE: If you change this function please check whether dqput_blocks() works right...
 */
690
void dqput(struct dquot *dquot)
L
Linus Torvalds 已提交
691
{
692 693
	int ret;

L
Linus Torvalds 已提交
694 695
	if (!dquot)
		return;
696
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
	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);
715
		/* Releasing dquot during quotaoff phase? */
716
		if (!sb_has_quota_active(dquot->dq_sb, dquot->dq_type) &&
717 718
		    atomic_read(&dquot->dq_count) == 1)
			wake_up(&dquot->dq_wait_unused);
L
Linus Torvalds 已提交
719 720 721 722 723 724 725
		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 */
726 727 728 729 730 731 732 733 734 735 736 737 738
		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 已提交
739 740 741 742 743 744 745 746 747 748
		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);
749
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
750
	/* sanity check */
751
	BUG_ON(!list_empty(&dquot->dq_free));
L
Linus Torvalds 已提交
752 753 754 755
#endif
	put_dquot_last(dquot);
	spin_unlock(&dq_list_lock);
}
756
EXPORT_SYMBOL(dqput);
L
Linus Torvalds 已提交
757

758
struct dquot *dquot_alloc(struct super_block *sb, int type)
759 760 761
{
	return kmem_cache_zalloc(dquot_cachep, GFP_NOFS);
}
762
EXPORT_SYMBOL(dquot_alloc);
763

L
Linus Torvalds 已提交
764 765 766 767
static struct dquot *get_empty_dquot(struct super_block *sb, int type)
{
	struct dquot *dquot;

768
	dquot = sb->dq_op->alloc_dquot(sb, type);
L
Linus Torvalds 已提交
769
	if(!dquot)
J
Jan Kara 已提交
770
		return NULL;
L
Linus Torvalds 已提交
771

I
Ingo Molnar 已提交
772
	mutex_init(&dquot->dq_lock);
L
Linus Torvalds 已提交
773 774 775 776
	INIT_LIST_HEAD(&dquot->dq_free);
	INIT_LIST_HEAD(&dquot->dq_inuse);
	INIT_HLIST_NODE(&dquot->dq_hash);
	INIT_LIST_HEAD(&dquot->dq_dirty);
777
	init_waitqueue_head(&dquot->dq_wait_unused);
L
Linus Torvalds 已提交
778 779 780 781 782 783 784 785 786
	dquot->dq_sb = sb;
	dquot->dq_type = type;
	atomic_set(&dquot->dq_count, 1);

	return dquot;
}

/*
 * Get reference to dquot
J
Jan Kara 已提交
787 788 789 790 791
 *
 * 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 已提交
792
 */
793
struct dquot *dqget(struct super_block *sb, unsigned int id, int type)
L
Linus Torvalds 已提交
794 795
{
	unsigned int hashent = hashfn(sb, id, type);
J
Jan Kara 已提交
796
	struct dquot *dquot = NULL, *empty = NULL;
L
Linus Torvalds 已提交
797

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

	return dquot;
}
855
EXPORT_SYMBOL(dqget);
L
Linus Torvalds 已提交
856 857 858 859 860 861 862 863

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

	if (IS_NOQUOTA(inode))
		return 0;
	if (type != -1)
J
Jan Kara 已提交
864
		return !inode->i_dquot[type];
L
Linus Torvalds 已提交
865
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
J
Jan Kara 已提交
866
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
867 868 869 870
			return 1;
	return 0;
}

I
Ingo Molnar 已提交
871
/* This routine is guarded by dqonoff_mutex mutex */
L
Linus Torvalds 已提交
872 873
static void add_dquot_ref(struct super_block *sb, int type)
{
874
	struct inode *inode, *old_inode = NULL;
875
#ifdef CONFIG_QUOTA_DEBUG
876
	int reserved = 0;
877
#endif
L
Linus Torvalds 已提交
878

879 880
	spin_lock(&inode_lock);
	list_for_each_entry(inode, &sb->s_inodes, i_sb_list) {
881
		if (inode->i_state & (I_FREEING|I_CLEAR|I_WILL_FREE|I_NEW))
N
Nick Piggin 已提交
882
			continue;
883
#ifdef CONFIG_QUOTA_DEBUG
884 885
		if (unlikely(inode_get_rsv_space(inode) > 0))
			reserved = 1;
886
#endif
887 888 889 890 891 892 893 894
		if (!atomic_read(&inode->i_writecount))
			continue;
		if (!dqinit_needed(inode, type))
			continue;

		__iget(inode);
		spin_unlock(&inode_lock);

895
		iput(old_inode);
896
		__dquot_initialize(inode, type);
897 898 899 900 901 902 903
		/* 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 已提交
904
	}
905
	spin_unlock(&inode_lock);
906
	iput(old_inode);
907

908
#ifdef CONFIG_QUOTA_DEBUG
909 910 911 912 913
	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);
	}
914
#endif
L
Linus Torvalds 已提交
915 916
}

J
Jan Kara 已提交
917 918 919 920
/*
 * Return 0 if dqput() won't block.
 * (note that 1 doesn't necessarily mean blocking)
 */
L
Linus Torvalds 已提交
921 922 923 924 925 926 927
static inline int dqput_blocks(struct dquot *dquot)
{
	if (atomic_read(&dquot->dq_count) <= 1)
		return 1;
	return 0;
}

J
Jan Kara 已提交
928 929 930 931 932
/*
 * 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...
 */
933 934
static int remove_inode_dquot_ref(struct inode *inode, int type,
				  struct list_head *tofree_head)
L
Linus Torvalds 已提交
935 936 937
{
	struct dquot *dquot = inode->i_dquot[type];

J
Jan Kara 已提交
938 939
	inode->i_dquot[type] = NULL;
	if (dquot) {
L
Linus Torvalds 已提交
940
		if (dqput_blocks(dquot)) {
941
#ifdef CONFIG_QUOTA_DEBUG
L
Linus Torvalds 已提交
942 943 944 945
			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 已提交
946 947 948
			/* As dquot must have currently users it can't be on
			 * the free list... */
			list_add(&dquot->dq_free, tofree_head);
L
Linus Torvalds 已提交
949 950 951 952 953 954 955 956 957
			spin_unlock(&dq_list_lock);
			return 1;
		}
		else
			dqput(dquot);   /* We have guaranteed we won't block */
	}
	return 0;
}

J
Jan Kara 已提交
958 959 960 961 962
/*
 * 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 已提交
963 964 965 966 967 968 969 970 971
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 已提交
972 973
		/* Remove dquot from the list so we won't have problems... */
		list_del_init(&dquot->dq_free);
L
Linus Torvalds 已提交
974 975 976 977
		dqput(dquot);
	}
}

978 979 980 981 982 983 984
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 已提交
985 986 987 988 989 990
		/*
		 *  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).
		 */
991 992 993 994 995 996
		if (!IS_NOQUOTA(inode))
			remove_inode_dquot_ref(inode, type, tofree_head);
	}
	spin_unlock(&inode_lock);
}

L
Linus Torvalds 已提交
997 998 999 1000 1001
/* Gather all references from inodes and drop them */
static void drop_dquot_ref(struct super_block *sb, int type)
{
	LIST_HEAD(tofree_head);

1002 1003 1004 1005 1006 1007
	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 已提交
1008 1009
}

1010
static inline void dquot_incr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1011 1012 1013 1014 1015 1016 1017 1018 1019
{
	dquot->dq_dqb.dqb_curinodes += number;
}

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

1020 1021 1022 1023 1024
static inline void dquot_resv_space(struct dquot *dquot, qsize_t number)
{
	dquot->dq_dqb.dqb_rsvspace += number;
}

1025 1026 1027
/*
 * Claim reserved quota space
 */
1028
static void dquot_claim_reserved_space(struct dquot *dquot, qsize_t number)
1029
{
1030 1031 1032 1033
	if (dquot->dq_dqb.dqb_rsvspace < number) {
		WARN_ON_ONCE(1);
		number = dquot->dq_dqb.dqb_rsvspace;
	}
1034 1035 1036 1037 1038 1039 1040
	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)
{
1041 1042 1043 1044 1045 1046
	if (dquot->dq_dqb.dqb_rsvspace >= number)
		dquot->dq_dqb.dqb_rsvspace -= number;
	else {
		WARN_ON_ONCE(1);
		dquot->dq_dqb.dqb_rsvspace = 0;
	}
1047 1048
}

1049
static void dquot_decr_inodes(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1050
{
1051 1052
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curinodes >= number)
L
Linus Torvalds 已提交
1053 1054 1055 1056 1057 1058 1059 1060
		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);
}

1061
static void dquot_decr_space(struct dquot *dquot, qsize_t number)
L
Linus Torvalds 已提交
1062
{
1063 1064
	if (sb_dqopt(dquot->dq_sb)->flags & DQUOT_NEGATIVE_USAGE ||
	    dquot->dq_dqb.dqb_curspace >= number)
L
Linus Torvalds 已提交
1065 1066 1067
		dquot->dq_dqb.dqb_curspace -= number;
	else
		dquot->dq_dqb.dqb_curspace = 0;
1068
	if (dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
L
Linus Torvalds 已提交
1069 1070 1071 1072
		dquot->dq_dqb.dqb_btime = (time_t) 0;
	clear_bit(DQ_BLKS_B, &dquot->dq_flags);
}

1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084
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);
}

1085
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
1086 1087
static int flag_print_warnings = 1;

1088
static int need_print_warning(struct dquot *dquot)
L
Linus Torvalds 已提交
1089 1090 1091 1092 1093 1094
{
	if (!flag_print_warnings)
		return 0;

	switch (dquot->dq_type) {
		case USRQUOTA:
1095
			return current_fsuid() == dquot->dq_id;
L
Linus Torvalds 已提交
1096 1097 1098 1099 1100 1101 1102
		case GRPQUOTA:
			return in_group_p(dquot->dq_id);
	}
	return 0;
}

/* Print warning to user which exceeded quota */
1103
static void print_warning(struct dquot *dquot, const int warntype)
L
Linus Torvalds 已提交
1104 1105
{
	char *msg = NULL;
1106
	struct tty_struct *tty;
L
Linus Torvalds 已提交
1107

1108 1109 1110 1111
	if (warntype == QUOTA_NL_IHARDBELOW ||
	    warntype == QUOTA_NL_ISOFTBELOW ||
	    warntype == QUOTA_NL_BHARDBELOW ||
	    warntype == QUOTA_NL_BSOFTBELOW || !need_print_warning(dquot))
L
Linus Torvalds 已提交
1112 1113
		return;

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

1148 1149 1150 1151 1152
/*
 * Write warnings to the console and send warning messages over netlink.
 *
 * Note that this function can sleep.
 */
1153
static void flush_warnings(struct dquot *const *dquots, char *warntype)
L
Linus Torvalds 已提交
1154
{
1155
	struct dquot *dq;
L
Linus Torvalds 已提交
1156 1157
	int i;

1158 1159 1160 1161
	for (i = 0; i < MAXQUOTAS; i++) {
		dq = dquots[i];
		if (dq && warntype[i] != QUOTA_NL_NOWARN &&
		    !warning_issued(dq, warntype[i])) {
1162
#ifdef CONFIG_PRINT_QUOTA_WARNING
1163
			print_warning(dq, warntype[i]);
1164
#endif
1165 1166
			quota_send_warning(dq->dq_type, dq->dq_id,
					   dq->dq_sb->s_dev, warntype[i]);
1167
		}
1168
	}
L
Linus Torvalds 已提交
1169 1170
}

1171
static int ignore_hardlimit(struct dquot *dquot)
L
Linus Torvalds 已提交
1172 1173 1174 1175
{
	struct mem_dqinfo *info = &sb_dqopt(dquot->dq_sb)->info[dquot->dq_type];

	return capable(CAP_SYS_RESOURCE) &&
J
Jan Kara 已提交
1176 1177
	       (info->dqi_format->qf_fmt_id != QFMT_VFS_OLD ||
		!(info->dqi_flags & V1_DQF_RSQUASH));
L
Linus Torvalds 已提交
1178 1179 1180
}

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

1185
	*warntype = QUOTA_NL_NOWARN;
1186 1187
	if (!sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type) ||
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1188
		return 0;
L
Linus Torvalds 已提交
1189 1190

	if (dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1191
	    newinodes > dquot->dq_dqb.dqb_ihardlimit &&
L
Linus Torvalds 已提交
1192
            !ignore_hardlimit(dquot)) {
1193
		*warntype = QUOTA_NL_IHARDWARN;
1194
		return -EDQUOT;
L
Linus Torvalds 已提交
1195 1196 1197
	}

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

	if (dquot->dq_dqb.dqb_isoftlimit &&
J
Jan Kara 已提交
1207
	    newinodes > dquot->dq_dqb.dqb_isoftlimit &&
L
Linus Torvalds 已提交
1208
	    dquot->dq_dqb.dqb_itime == 0) {
1209
		*warntype = QUOTA_NL_ISOFTWARN;
J
Jan Kara 已提交
1210 1211
		dquot->dq_dqb.dqb_itime = get_seconds() +
		    sb_dqopt(dquot->dq_sb)->info[dquot->dq_type].dqi_igrace;
L
Linus Torvalds 已提交
1212 1213
	}

1214
	return 0;
L
Linus Torvalds 已提交
1215 1216 1217 1218 1219
}

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

1223
	*warntype = QUOTA_NL_NOWARN;
J
Jan Kara 已提交
1224
	if (!sb_has_quota_limits_enabled(sb, dquot->dq_type) ||
1225
	    test_bit(DQ_FAKE_B, &dquot->dq_flags))
1226
		return 0;
L
Linus Torvalds 已提交
1227

1228 1229 1230
	tspace = dquot->dq_dqb.dqb_curspace + dquot->dq_dqb.dqb_rsvspace
		+ space;

L
Linus Torvalds 已提交
1231
	if (dquot->dq_dqb.dqb_bhardlimit &&
1232
	    tspace > dquot->dq_dqb.dqb_bhardlimit &&
L
Linus Torvalds 已提交
1233 1234
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1235
			*warntype = QUOTA_NL_BHARDWARN;
1236
		return -EDQUOT;
L
Linus Torvalds 已提交
1237 1238 1239
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1240
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
J
Jan Kara 已提交
1241 1242
	    dquot->dq_dqb.dqb_btime &&
	    get_seconds() >= dquot->dq_dqb.dqb_btime &&
L
Linus Torvalds 已提交
1243 1244
            !ignore_hardlimit(dquot)) {
		if (!prealloc)
1245
			*warntype = QUOTA_NL_BSOFTLONGWARN;
1246
		return -EDQUOT;
L
Linus Torvalds 已提交
1247 1248 1249
	}

	if (dquot->dq_dqb.dqb_bsoftlimit &&
1250
	    tspace > dquot->dq_dqb.dqb_bsoftlimit &&
L
Linus Torvalds 已提交
1251 1252
	    dquot->dq_dqb.dqb_btime == 0) {
		if (!prealloc) {
1253
			*warntype = QUOTA_NL_BSOFTWARN;
J
Jan Kara 已提交
1254 1255
			dquot->dq_dqb.dqb_btime = get_seconds() +
			    sb_dqopt(sb)->info[dquot->dq_type].dqi_bgrace;
L
Linus Torvalds 已提交
1256 1257 1258 1259 1260 1261
		}
		else
			/*
			 * We don't allow preallocation to exceed softlimit so exceeding will
			 * be always printed
			 */
1262
			return -EDQUOT;
L
Linus Torvalds 已提交
1263 1264
	}

1265
	return 0;
L
Linus Torvalds 已提交
1266 1267
}

1268
static int info_idq_free(struct dquot *dquot, qsize_t inodes)
1269
{
J
Jan Kara 已提交
1270 1271
	qsize_t newinodes;

1272
	if (test_bit(DQ_FAKE_B, &dquot->dq_flags) ||
1273 1274
	    dquot->dq_dqb.dqb_curinodes <= dquot->dq_dqb.dqb_isoftlimit ||
	    !sb_has_quota_limits_enabled(dquot->dq_sb, dquot->dq_type))
1275 1276
		return QUOTA_NL_NOWARN;

J
Jan Kara 已提交
1277 1278
	newinodes = dquot->dq_dqb.dqb_curinodes - inodes;
	if (newinodes <= dquot->dq_dqb.dqb_isoftlimit)
1279 1280
		return QUOTA_NL_ISOFTBELOW;
	if (dquot->dq_dqb.dqb_curinodes >= dquot->dq_dqb.dqb_ihardlimit &&
J
Jan Kara 已提交
1281
	    newinodes < dquot->dq_dqb.dqb_ihardlimit)
1282 1283 1284 1285 1286 1287 1288
		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) ||
1289
	    dquot->dq_dqb.dqb_curspace <= dquot->dq_dqb.dqb_bsoftlimit)
1290 1291
		return QUOTA_NL_NOWARN;

1292
	if (dquot->dq_dqb.dqb_curspace - space <= dquot->dq_dqb.dqb_bsoftlimit)
1293
		return QUOTA_NL_BSOFTBELOW;
1294 1295
	if (dquot->dq_dqb.dqb_curspace >= dquot->dq_dqb.dqb_bhardlimit &&
	    dquot->dq_dqb.dqb_curspace - space < dquot->dq_dqb.dqb_bhardlimit)
1296 1297 1298
		return QUOTA_NL_BHARDBELOW;
	return QUOTA_NL_NOWARN;
}
1299

L
Linus Torvalds 已提交
1300
/*
1301 1302 1303 1304 1305 1306 1307
 * 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 已提交
1308
 */
1309
static void __dquot_initialize(struct inode *inode, int type)
L
Linus Torvalds 已提交
1310 1311
{
	unsigned int id = 0;
1312
	int cnt;
1313
	struct dquot *got[MAXQUOTAS];
J
Jan Kara 已提交
1314
	struct super_block *sb = inode->i_sb;
1315
	qsize_t rsv;
L
Linus Torvalds 已提交
1316

I
Ingo Molnar 已提交
1317 1318
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1319 1320
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode))
		return;
J
Jan Kara 已提交
1321 1322 1323

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

void dquot_initialize(struct inode *inode)
{
	__dquot_initialize(inode, -1);
L
Linus Torvalds 已提交
1368
}
1369
EXPORT_SYMBOL(dquot_initialize);
L
Linus Torvalds 已提交
1370 1371 1372 1373

/*
 * 	Release all quotas referenced by inode
 */
1374
static void __dquot_drop(struct inode *inode)
L
Linus Torvalds 已提交
1375 1376
{
	int cnt;
J
Jan Kara 已提交
1377
	struct dquot *put[MAXQUOTAS];
L
Linus Torvalds 已提交
1378

J
Jan Kara 已提交
1379
	down_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
L
Linus Torvalds 已提交
1380
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1381
		put[cnt] = inode->i_dquot[cnt];
J
Jan Kara 已提交
1382
		inode->i_dquot[cnt] = NULL;
L
Linus Torvalds 已提交
1383 1384
	}
	up_write(&sb_dqopt(inode->i_sb)->dqptr_sem);
1385
	dqput_all(put);
L
Linus Torvalds 已提交
1386 1387
}

1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410
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);
1411

1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423
/*
 * 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);
}

1424
void inode_add_rsv_space(struct inode *inode, qsize_t number)
1425 1426 1427 1428 1429
{
	spin_lock(&inode->i_lock);
	*inode_reserved_space(inode) += number;
	spin_unlock(&inode->i_lock);
}
1430
EXPORT_SYMBOL(inode_add_rsv_space);
1431

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

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

static qsize_t inode_get_rsv_space(struct inode *inode)
{
	qsize_t ret;
1452 1453 1454

	if (!inode->i_sb->dq_op->get_reserved_space)
		return 0;
1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
	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 已提交
1478
/*
1479 1480 1481 1482 1483 1484 1485
 * 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 已提交
1486 1487 1488 1489 1490
 */

/*
 * This operation can block, but only after everything is updated
 */
1491
int __dquot_alloc_space(struct inode *inode, qsize_t number,
1492
		int warn, int reserve)
L
Linus Torvalds 已提交
1493
{
1494
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1495 1496
	char warntype[MAXQUOTAS];

1497 1498 1499 1500
	/*
	 * First test before acquiring mutex - solves deadlocks when we
	 * re-enter the quota code and are already holding the mutex
	 */
1501
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
1502 1503 1504 1505 1506
		inode_incr_space(inode, number, reserve);
		goto out;
	}

	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
L
Linus Torvalds 已提交
1507
	for (cnt = 0; cnt < MAXQUOTAS; cnt++)
1508
		warntype[cnt] = QUOTA_NL_NOWARN;
L
Linus Torvalds 已提交
1509 1510 1511

	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1512
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1513
			continue;
1514 1515 1516
		ret = check_bdq(inode->i_dquot[cnt], number, !warn,
				warntype+cnt);
		if (ret) {
1517 1518
			spin_unlock(&dq_data_lock);
			goto out_flush_warn;
1519
		}
L
Linus Torvalds 已提交
1520 1521
	}
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1522
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1523
			continue;
1524 1525 1526 1527
		if (reserve)
			dquot_resv_space(inode->i_dquot[cnt], number);
		else
			dquot_incr_space(inode->i_dquot[cnt], number);
L
Linus Torvalds 已提交
1528
	}
1529
	inode_incr_space(inode, number, reserve);
L
Linus Torvalds 已提交
1530
	spin_unlock(&dq_data_lock);
1531

1532 1533
	if (reserve)
		goto out_flush_warn;
1534
	mark_all_dquot_dirty(inode->i_dquot);
1535 1536
out_flush_warn:
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1537
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1538 1539 1540
out:
	return ret;
}
1541
EXPORT_SYMBOL(__dquot_alloc_space);
L
Linus Torvalds 已提交
1542 1543 1544 1545

/*
 * This operation can block, but only after everything is updated
 */
1546
int dquot_alloc_inode(const struct inode *inode)
L
Linus Torvalds 已提交
1547
{
1548
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1549 1550
	char warntype[MAXQUOTAS];

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

	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1568
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1569
			continue;
1570
		dquot_incr_inodes(inode->i_dquot[cnt], 1);
L
Linus Torvalds 已提交
1571
	}
1572

L
Linus Torvalds 已提交
1573 1574
warn_put_all:
	spin_unlock(&dq_data_lock);
1575
	if (ret == 0)
1576
		mark_all_dquot_dirty(inode->i_dquot);
1577
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1578 1579 1580
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	return ret;
}
1581
EXPORT_SYMBOL(dquot_alloc_inode);
L
Linus Torvalds 已提交
1582

1583 1584 1585 1586
/*
 * Convert in-memory reserved quotas to real consumed quotas
 */
int dquot_claim_space_nodirty(struct inode *inode, qsize_t number)
1587 1588 1589
{
	int cnt;

1590
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
1591
		inode_claim_rsv_space(inode, number);
1592
		return 0;
1593 1594 1595 1596 1597 1598
	}

	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 已提交
1599
		if (inode->i_dquot[cnt])
1600 1601 1602 1603
			dquot_claim_reserved_space(inode->i_dquot[cnt],
							number);
	}
	/* Update inode bytes */
1604
	inode_claim_rsv_space(inode, number);
1605
	spin_unlock(&dq_data_lock);
1606
	mark_all_dquot_dirty(inode->i_dquot);
1607
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1608
	return 0;
1609
}
1610
EXPORT_SYMBOL(dquot_claim_space_nodirty);
1611

L
Linus Torvalds 已提交
1612 1613 1614
/*
 * This operation can block, but only after everything is updated
 */
1615
void __dquot_free_space(struct inode *inode, qsize_t number, int reserve)
L
Linus Torvalds 已提交
1616 1617
{
	unsigned int cnt;
1618
	char warntype[MAXQUOTAS];
L
Linus Torvalds 已提交
1619

I
Ingo Molnar 已提交
1620 1621
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1622
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode)) {
1623
		inode_decr_space(inode, number, reserve);
1624
		return;
L
Linus Torvalds 已提交
1625
	}
1626

L
Linus Torvalds 已提交
1627 1628 1629
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1630
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1631
			continue;
1632
		warntype[cnt] = info_bdq_free(inode->i_dquot[cnt], number);
1633 1634 1635 1636
		if (reserve)
			dquot_free_reserved_space(inode->i_dquot[cnt], number);
		else
			dquot_decr_space(inode->i_dquot[cnt], number);
L
Linus Torvalds 已提交
1637
	}
1638
	inode_decr_space(inode, number, reserve);
L
Linus Torvalds 已提交
1639
	spin_unlock(&dq_data_lock);
1640 1641 1642

	if (reserve)
		goto out_unlock;
1643
	mark_all_dquot_dirty(inode->i_dquot);
1644
out_unlock:
1645
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1646
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
1647
}
1648
EXPORT_SYMBOL(__dquot_free_space);
1649

L
Linus Torvalds 已提交
1650 1651 1652
/*
 * This operation can block, but only after everything is updated
 */
1653
void dquot_free_inode(const struct inode *inode)
L
Linus Torvalds 已提交
1654 1655
{
	unsigned int cnt;
1656
	char warntype[MAXQUOTAS];
L
Linus Torvalds 已提交
1657

I
Ingo Molnar 已提交
1658 1659
	/* First test before acquiring mutex - solves deadlocks when we
         * re-enter the quota code and are already holding the mutex */
1660 1661
	if (!sb_any_quota_active(inode->i_sb) || IS_NOQUOTA(inode))
		return;
1662

L
Linus Torvalds 已提交
1663 1664 1665
	down_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
	spin_lock(&dq_data_lock);
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
J
Jan Kara 已提交
1666
		if (!inode->i_dquot[cnt])
L
Linus Torvalds 已提交
1667
			continue;
1668 1669
		warntype[cnt] = info_idq_free(inode->i_dquot[cnt], 1);
		dquot_decr_inodes(inode->i_dquot[cnt], 1);
L
Linus Torvalds 已提交
1670 1671
	}
	spin_unlock(&dq_data_lock);
1672
	mark_all_dquot_dirty(inode->i_dquot);
1673
	flush_warnings(inode->i_dquot, warntype);
L
Linus Torvalds 已提交
1674 1675
	up_read(&sb_dqopt(inode->i_sb)->dqptr_sem);
}
1676
EXPORT_SYMBOL(dquot_free_inode);
L
Linus Torvalds 已提交
1677 1678 1679 1680 1681 1682 1683

/*
 * 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.
 */
1684
static int __dquot_transfer(struct inode *inode, qid_t *chid, unsigned long mask)
L
Linus Torvalds 已提交
1685
{
1686 1687
	qsize_t space, cur_space;
	qsize_t rsv_space = 0;
L
Linus Torvalds 已提交
1688 1689
	struct dquot *transfer_from[MAXQUOTAS];
	struct dquot *transfer_to[MAXQUOTAS];
1690
	int cnt, ret = 0;
1691 1692
	char warntype_to[MAXQUOTAS];
	char warntype_from_inodes[MAXQUOTAS], warntype_from_space[MAXQUOTAS];
L
Linus Torvalds 已提交
1693

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

	/*
	 * 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 已提交
1737
		if (!transfer_to[cnt])
L
Linus Torvalds 已提交
1738 1739 1740 1741
			continue;

		/* Due to IO error we might not have transfer_from[] structure */
		if (transfer_from[cnt]) {
1742 1743 1744 1745
			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 已提交
1746
			dquot_decr_inodes(transfer_from[cnt], 1);
1747 1748 1749
			dquot_decr_space(transfer_from[cnt], cur_space);
			dquot_free_reserved_space(transfer_from[cnt],
						  rsv_space);
L
Linus Torvalds 已提交
1750 1751 1752
		}

		dquot_incr_inodes(transfer_to[cnt], 1);
1753 1754
		dquot_incr_space(transfer_to[cnt], cur_space);
		dquot_resv_space(transfer_to[cnt], rsv_space);
L
Linus Torvalds 已提交
1755 1756 1757 1758

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

1761 1762 1763 1764 1765
	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 已提交
1766
warn_put_all:
1767 1768 1769
	flush_warnings(transfer_to, warntype_to);
	flush_warnings(transfer_from, warntype_from_inodes);
	flush_warnings(transfer_from, warntype_from_space);
J
Jan Kara 已提交
1770
put_all:
1771 1772
	dqput_all(transfer_from);
	dqput_all(transfer_to);
L
Linus Torvalds 已提交
1773
	return ret;
J
Jan Kara 已提交
1774 1775 1776 1777 1778
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 已提交
1779
		transfer_from[cnt] = NULL;
J
Jan Kara 已提交
1780
	goto warn_put_all;
L
Linus Torvalds 已提交
1781 1782
}

1783 1784 1785
/* Wrapper for transferring ownership of an inode for uid/gid only
 * Called from FSXXX_setattr()
 */
1786
int dquot_transfer(struct inode *inode, struct iattr *iattr)
1787
{
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
	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;
	}
1799
	if (sb_any_quota_active(inode->i_sb) && !IS_NOQUOTA(inode)) {
1800
		dquot_initialize(inode);
1801
		return __dquot_transfer(inode, chid, mask);
1802 1803 1804
	}
	return 0;
}
1805
EXPORT_SYMBOL(dquot_transfer);
1806

L
Linus Torvalds 已提交
1807 1808 1809 1810 1811 1812 1813 1814
/*
 * 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 已提交
1815
	mutex_lock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
1816
	ret = dqopt->ops[type]->write_file_info(sb, type);
I
Ingo Molnar 已提交
1817
	mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
1818 1819
	return ret;
}
1820
EXPORT_SYMBOL(dquot_commit_info);
L
Linus Torvalds 已提交
1821 1822 1823 1824

/*
 * Definitions of diskquota operations.
 */
1825
const struct dquot_operations dquot_operations = {
L
Linus Torvalds 已提交
1826 1827 1828 1829
	.write_dquot	= dquot_commit,
	.acquire_dquot	= dquot_acquire,
	.release_dquot	= dquot_release,
	.mark_dirty	= dquot_mark_dquot_dirty,
1830 1831 1832
	.write_info	= dquot_commit_info,
	.alloc_dquot	= dquot_alloc,
	.destroy_dquot	= dquot_destroy,
L
Linus Torvalds 已提交
1833 1834
};

1835 1836 1837 1838 1839 1840 1841 1842 1843
/*
 * 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))
1844
		dquot_initialize(inode);
1845 1846 1847 1848
	return error;
}
EXPORT_SYMBOL(dquot_file_open);

L
Linus Torvalds 已提交
1849 1850 1851
/*
 * Turn quota off on a device. type == -1 ==> quotaoff for all types (umount)
 */
1852
int vfs_quota_disable(struct super_block *sb, int type, unsigned int flags)
L
Linus Torvalds 已提交
1853
{
1854
	int cnt, ret = 0;
L
Linus Torvalds 已提交
1855 1856 1857
	struct quota_info *dqopt = sb_dqopt(sb);
	struct inode *toputinode[MAXQUOTAS];

1858 1859 1860 1861 1862 1863 1864
	/* 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 已提交
1865
	/* We need to serialize quota_off() for device */
I
Ingo Molnar 已提交
1866
	mutex_lock(&dqopt->dqonoff_mutex);
1867 1868 1869 1870 1871 1872

	/*
	 * 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.
	 */
1873
	if (!sb_any_quota_loaded(sb)) {
1874 1875 1876
		mutex_unlock(&dqopt->dqonoff_mutex);
		return 0;
	}
L
Linus Torvalds 已提交
1877 1878 1879 1880
	for (cnt = 0; cnt < MAXQUOTAS; cnt++) {
		toputinode[cnt] = NULL;
		if (type != -1 && cnt != type)
			continue;
1881
		if (!sb_has_quota_loaded(sb, cnt))
1882
			continue;
1883 1884

		if (flags & DQUOT_SUSPENDED) {
J
Jan Kara 已提交
1885
			spin_lock(&dq_state_lock);
1886 1887
			dqopt->flags |=
				dquot_state_flag(DQUOT_SUSPENDED, cnt);
J
Jan Kara 已提交
1888
			spin_unlock(&dq_state_lock);
1889
		} else {
J
Jan Kara 已提交
1890
			spin_lock(&dq_state_lock);
1891 1892 1893 1894 1895 1896
			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 已提交
1897
				spin_unlock(&dq_state_lock);
1898 1899 1900 1901
				iput(dqopt->files[cnt]);
				dqopt->files[cnt] = NULL;
				continue;
			}
J
Jan Kara 已提交
1902
			spin_unlock(&dq_state_lock);
1903
		}
1904 1905 1906

		/* We still have to keep quota loaded? */
		if (sb_has_quota_loaded(sb, cnt) && !(flags & DQUOT_SUSPENDED))
L
Linus Torvalds 已提交
1907 1908 1909 1910 1911 1912
			continue;

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

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

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

1984 1985 1986 1987 1988
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));
}
1989
EXPORT_SYMBOL(vfs_quota_off);
L
Linus Torvalds 已提交
1990 1991 1992 1993
/*
 *	Turn quotas on on a device
 */

1994 1995 1996 1997 1998 1999
/*
 * 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 已提交
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020
{
	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;
	}
2021 2022 2023 2024 2025
	/* Usage always has to be set... */
	if (!(flags & DQUOT_USAGE_ENABLED)) {
		error = -EINVAL;
		goto out_fmt;
	}
L
Linus Torvalds 已提交
2026

2027
	if (!(dqopt->flags & DQUOT_QUOTA_SYS_FILE)) {
2028 2029 2030 2031 2032 2033 2034
		/* 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);
2035 2036
		invalidate_bdev(sb->s_bdev);
	}
I
Ingo Molnar 已提交
2037
	mutex_lock(&dqopt->dqonoff_mutex);
2038
	if (sb_has_quota_loaded(sb, type)) {
L
Linus Torvalds 已提交
2039 2040 2041
		error = -EBUSY;
		goto out_lock;
	}
2042 2043 2044 2045 2046

	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. */
2047
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
J
Jan Kara 已提交
2048 2049
		oldflags = inode->i_flags & (S_NOATIME | S_IMMUTABLE |
					     S_NOQUOTA);
2050
		inode->i_flags |= S_NOQUOTA | S_NOATIME | S_IMMUTABLE;
2051
		mutex_unlock(&inode->i_mutex);
2052 2053 2054 2055
		/*
		 * When S_NOQUOTA is set, remove dquot references as no more
		 * references can be added
		 */
2056
		__dquot_drop(inode);
2057
	}
L
Linus Torvalds 已提交
2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068

	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;
2069
	dqopt->info[type].dqi_fmt_id = format_id;
L
Linus Torvalds 已提交
2070
	INIT_LIST_HEAD(&dqopt->info[type].dqi_dirty_list);
I
Ingo Molnar 已提交
2071
	mutex_lock(&dqopt->dqio_mutex);
J
Jan Kara 已提交
2072 2073
	error = dqopt->ops[type]->read_file_info(sb, type);
	if (error < 0) {
I
Ingo Molnar 已提交
2074
		mutex_unlock(&dqopt->dqio_mutex);
L
Linus Torvalds 已提交
2075 2076
		goto out_file_init;
	}
I
Ingo Molnar 已提交
2077
	mutex_unlock(&dqopt->dqio_mutex);
J
Jan Kara 已提交
2078
	spin_lock(&dq_state_lock);
2079
	dqopt->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2080
	spin_unlock(&dq_state_lock);
L
Linus Torvalds 已提交
2081 2082

	add_dquot_ref(sb, type);
I
Ingo Molnar 已提交
2083
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
2084 2085 2086 2087 2088 2089 2090 2091

	return 0;

out_file_init:
	dqopt->files[type] = NULL;
	iput(inode);
out_lock:
	if (oldflags != -1) {
2092
		mutex_lock_nested(&inode->i_mutex, I_MUTEX_QUOTA);
L
Linus Torvalds 已提交
2093 2094 2095 2096
		/* 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;
2097
		mutex_unlock(&inode->i_mutex);
L
Linus Torvalds 已提交
2098
	}
2099
	mutex_unlock(&dqopt->dqonoff_mutex);
L
Linus Torvalds 已提交
2100 2101 2102 2103 2104 2105
out_fmt:
	put_quota_format(fmt);

	return error; 
}

2106 2107 2108 2109 2110 2111
/* 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;
2112
	unsigned int flags;
2113 2114 2115 2116 2117 2118 2119 2120

	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 已提交
2121
	spin_lock(&dq_state_lock);
2122 2123 2124
	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 已提交
2125
	spin_unlock(&dq_state_lock);
2126 2127
	mutex_unlock(&dqopt->dqonoff_mutex);

2128 2129 2130
	flags = dquot_generic_flag(flags, type);
	ret = vfs_load_quota_inode(inode, type, dqopt->info[type].dqi_fmt_id,
				   flags);
2131 2132 2133 2134 2135
	iput(inode);

	return ret;
}

2136 2137 2138 2139 2140 2141 2142 2143 2144 2145
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
2146 2147 2148
		error = vfs_load_quota_inode(path->dentry->d_inode, type,
					     format_id, DQUOT_USAGE_ENABLED |
					     DQUOT_LIMITS_ENABLED);
2149 2150
	return error;
}
2151
EXPORT_SYMBOL(vfs_quota_on_path);
2152

2153
int vfs_quota_on(struct super_block *sb, int type, int format_id, char *name,
2154
		 int remount)
L
Linus Torvalds 已提交
2155
{
2156
	struct path path;
L
Linus Torvalds 已提交
2157 2158
	int error;

2159 2160 2161
	if (remount)
		return vfs_quota_on_remount(sb, type);

2162
	error = kern_path(name, LOOKUP_FOLLOW, &path);
2163
	if (!error) {
2164 2165
		error = vfs_quota_on_path(sb, type, format_id, &path);
		path_put(&path);
2166
	}
L
Linus Torvalds 已提交
2167 2168
	return error;
}
2169
EXPORT_SYMBOL(vfs_quota_on);
L
Linus Torvalds 已提交
2170

2171 2172 2173 2174 2175 2176 2177 2178 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
/*
 * 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 已提交
2205
		spin_lock(&dq_state_lock);
2206
		sb_dqopt(sb)->flags |= dquot_state_flag(flags, type);
J
Jan Kara 已提交
2207
		spin_unlock(&dq_state_lock);
2208 2209 2210 2211 2212 2213 2214 2215
out_lock:
		mutex_unlock(&dqopt->dqonoff_mutex);
		return ret;
	}

load_quota:
	return vfs_load_quota_inode(inode, type, format_id, flags);
}
2216
EXPORT_SYMBOL(vfs_quota_enable);
2217

L
Linus Torvalds 已提交
2218 2219 2220 2221
/*
 * This function is used when filesystem needs to initialize quotas
 * during mount time.
 */
2222 2223
int vfs_quota_on_mount(struct super_block *sb, char *qf_name,
		int format_id, int type)
L
Linus Torvalds 已提交
2224
{
2225
	struct dentry *dentry;
L
Linus Torvalds 已提交
2226 2227
	int error;

2228
	mutex_lock(&sb->s_root->d_inode->i_mutex);
2229
	dentry = lookup_one_len(qf_name, sb->s_root, strlen(qf_name));
2230
	mutex_unlock(&sb->s_root->d_inode->i_mutex);
2231 2232 2233
	if (IS_ERR(dentry))
		return PTR_ERR(dentry);

2234 2235 2236 2237 2238
	if (!dentry->d_inode) {
		error = -ENOENT;
		goto out;
	}

L
Linus Torvalds 已提交
2239
	error = security_quota_on(dentry);
2240
	if (!error)
2241 2242
		error = vfs_load_quota_inode(dentry->d_inode, type, format_id,
				DQUOT_USAGE_ENABLED | DQUOT_LIMITS_ENABLED);
2243

2244
out:
2245 2246
	dput(dentry);
	return error;
L
Linus Torvalds 已提交
2247
}
2248
EXPORT_SYMBOL(vfs_quota_on_mount);
L
Linus Torvalds 已提交
2249

2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264
/* 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;
}
2265
EXPORT_SYMBOL(vfs_dq_quota_on_remount);
2266

2267 2268 2269 2270 2271 2272 2273 2274 2275 2276
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 已提交
2277 2278 2279 2280 2281 2282
/* 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);
2283 2284
	di->dqb_bhardlimit = stoqb(dm->dqb_bhardlimit);
	di->dqb_bsoftlimit = stoqb(dm->dqb_bsoftlimit);
2285
	di->dqb_curspace = dm->dqb_curspace + dm->dqb_rsvspace;
L
Linus Torvalds 已提交
2286 2287 2288 2289 2290 2291 2292 2293 2294
	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 已提交
2295 2296
int vfs_get_dqblk(struct super_block *sb, int type, qid_t id,
		  struct if_dqblk *di)
L
Linus Torvalds 已提交
2297 2298 2299
{
	struct dquot *dquot;

J
Jan Kara 已提交
2300
	dquot = dqget(sb, id, type);
J
Jan Kara 已提交
2301
	if (!dquot)
L
Linus Torvalds 已提交
2302 2303 2304
		return -ESRCH;
	do_get_dqblk(dquot, di);
	dqput(dquot);
J
Jan Kara 已提交
2305

L
Linus Torvalds 已提交
2306 2307
	return 0;
}
2308
EXPORT_SYMBOL(vfs_get_dqblk);
L
Linus Torvalds 已提交
2309 2310

/* Generic routine for setting common part of quota structure */
2311
static int do_set_dqblk(struct dquot *dquot, struct if_dqblk *di)
L
Linus Torvalds 已提交
2312 2313 2314
{
	struct mem_dqblk *dm = &dquot->dq_dqb;
	int check_blim = 0, check_ilim = 0;
2315 2316 2317 2318 2319 2320 2321 2322 2323
	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 已提交
2324 2325 2326

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

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

	return 0;
L
Linus Torvalds 已提交
2386 2387
}

J
Jan Kara 已提交
2388 2389
int vfs_set_dqblk(struct super_block *sb, int type, qid_t id,
		  struct if_dqblk *di)
L
Linus Torvalds 已提交
2390 2391
{
	struct dquot *dquot;
2392
	int rc;
L
Linus Torvalds 已提交
2393

2394 2395 2396 2397
	dquot = dqget(sb, id, type);
	if (!dquot) {
		rc = -ESRCH;
		goto out;
L
Linus Torvalds 已提交
2398
	}
2399
	rc = do_set_dqblk(dquot, di);
L
Linus Torvalds 已提交
2400
	dqput(dquot);
2401
out:
2402
	return rc;
L
Linus Torvalds 已提交
2403
}
2404
EXPORT_SYMBOL(vfs_set_dqblk);
L
Linus Torvalds 已提交
2405 2406 2407 2408 2409 2410

/* 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 已提交
2411
	mutex_lock(&sb_dqopt(sb)->dqonoff_mutex);
2412
	if (!sb_has_quota_active(sb, type)) {
I
Ingo Molnar 已提交
2413
		mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
L
Linus Torvalds 已提交
2414 2415 2416 2417 2418 2419 2420 2421 2422
		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 已提交
2423
	mutex_unlock(&sb_dqopt(sb)->dqonoff_mutex);
L
Linus Torvalds 已提交
2424 2425
	return 0;
}
2426
EXPORT_SYMBOL(vfs_get_dqinfo);
L
Linus Torvalds 已提交
2427 2428 2429 2430 2431

/* 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;
2432
	int err = 0;
L
Linus Torvalds 已提交
2433

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

2458
const struct quotactl_ops vfs_quotactl_ops = {
L
Linus Torvalds 已提交
2459 2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473
	.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,
2474
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2475 2476 2477 2478 2479 2480
	},
	{
		.procname	= "drops",
		.data		= &dqstats.drops,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2481
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2482 2483 2484 2485 2486 2487
	},
	{
		.procname	= "reads",
		.data		= &dqstats.reads,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2488
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2489 2490 2491 2492 2493 2494
	},
	{
		.procname	= "writes",
		.data		= &dqstats.writes,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2495
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2496 2497 2498 2499 2500 2501
	},
	{
		.procname	= "cache_hits",
		.data		= &dqstats.cache_hits,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2502
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2503 2504 2505 2506 2507 2508
	},
	{
		.procname	= "allocated_dquots",
		.data		= &dqstats.allocated_dquots,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2509
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2510 2511 2512 2513 2514 2515
	},
	{
		.procname	= "free_dquots",
		.data		= &dqstats.free_dquots,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2516
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2517 2518 2519 2520 2521 2522
	},
	{
		.procname	= "syncs",
		.data		= &dqstats.syncs,
		.maxlen		= sizeof(int),
		.mode		= 0444,
2523
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2524
	},
2525
#ifdef CONFIG_PRINT_QUOTA_WARNING
L
Linus Torvalds 已提交
2526 2527 2528 2529 2530
	{
		.procname	= "warnings",
		.data		= &flag_print_warnings,
		.maxlen		= sizeof(int),
		.mode		= 0644,
2531
		.proc_handler	= proc_dointvec,
L
Linus Torvalds 已提交
2532
	},
2533
#endif
2534
	{ },
L
Linus Torvalds 已提交
2535 2536 2537 2538 2539 2540 2541 2542
};

static ctl_table fs_table[] = {
	{
		.procname	= "quota",
		.mode		= 0555,
		.child		= fs_dqstats_table,
	},
2543
	{ },
L
Linus Torvalds 已提交
2544 2545 2546 2547 2548 2549 2550 2551
};

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

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

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

2562
	register_sysctl_table(sys_table);
L
Linus Torvalds 已提交
2563

2564
	dquot_cachep = kmem_cache_create("dquot",
L
Linus Torvalds 已提交
2565
			sizeof(struct dquot), sizeof(unsigned long) * 4,
2566 2567
			(SLAB_HWCACHE_ALIGN|SLAB_RECLAIM_ACCOUNT|
				SLAB_MEM_SPREAD|SLAB_PANIC),
2568
			NULL);
L
Linus Torvalds 已提交
2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590

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

2591
	register_shrinker(&dqcache_shrinker);
L
Linus Torvalds 已提交
2592 2593 2594 2595

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