xfs_qm.c 46.2 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0
L
Linus Torvalds 已提交
2
/*
3 4
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
L
Linus Torvalds 已提交
5 6 7
 */
#include "xfs.h"
#include "xfs_fs.h"
8
#include "xfs_shared.h"
9
#include "xfs_format.h"
10 11
#include "xfs_log_format.h"
#include "xfs_trans_resv.h"
12
#include "xfs_bit.h"
L
Linus Torvalds 已提交
13 14 15
#include "xfs_sb.h"
#include "xfs_mount.h"
#include "xfs_inode.h"
16
#include "xfs_iwalk.h"
17
#include "xfs_quota.h"
18
#include "xfs_bmap.h"
19
#include "xfs_bmap_util.h"
20
#include "xfs_trans.h"
L
Linus Torvalds 已提交
21 22
#include "xfs_trans_space.h"
#include "xfs_qm.h"
23
#include "xfs_trace.h"
D
Dave Chinner 已提交
24
#include "xfs_icache.h"
25
#include "xfs_error.h"
L
Linus Torvalds 已提交
26 27 28 29 30 31 32

/*
 * The global quota manager. There is only one of these for the entire
 * system, _not_ one per file system. XQM keeps track of the overall
 * quota functionality, including maintaining the freelist and hash
 * tables of dquots.
 */
33 34
STATIC int	xfs_qm_init_quotainos(struct xfs_mount *mp);
STATIC int	xfs_qm_init_quotainfo(struct xfs_mount *mp);
L
Linus Torvalds 已提交
35

36
STATIC void	xfs_qm_destroy_quotainos(struct xfs_quotainfo *qi);
37
STATIC void	xfs_qm_dqfree_one(struct xfs_dquot *dqp);
38 39 40 41 42 43 44 45 46 47 48 49 50
/*
 * We use the batch lookup interface to iterate over the dquots as it
 * currently is the only interface into the radix tree code that allows
 * fuzzy lookups instead of exact matches.  Holding the lock over multiple
 * operations is fine as all callers are used either during mount/umount
 * or quotaoff.
 */
#define XFS_DQ_LOOKUP_BATCH	32

STATIC int
xfs_qm_dquot_walk(
	struct xfs_mount	*mp,
	int			type,
51 52
	int			(*execute)(struct xfs_dquot *dqp, void *data),
	void			*data)
53 54
{
	struct xfs_quotainfo	*qi = mp->m_quotainfo;
55
	struct radix_tree_root	*tree = xfs_dquot_tree(qi, type);
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83
	uint32_t		next_index;
	int			last_error = 0;
	int			skipped;
	int			nr_found;

restart:
	skipped = 0;
	next_index = 0;
	nr_found = 0;

	while (1) {
		struct xfs_dquot *batch[XFS_DQ_LOOKUP_BATCH];
		int		error = 0;
		int		i;

		mutex_lock(&qi->qi_tree_lock);
		nr_found = radix_tree_gang_lookup(tree, (void **)batch,
					next_index, XFS_DQ_LOOKUP_BATCH);
		if (!nr_found) {
			mutex_unlock(&qi->qi_tree_lock);
			break;
		}

		for (i = 0; i < nr_found; i++) {
			struct xfs_dquot *dqp = batch[i];

			next_index = be32_to_cpu(dqp->q_core.d_id) + 1;

84
			error = execute(batch[i], data);
85
			if (error == -EAGAIN) {
86 87 88
				skipped++;
				continue;
			}
89
			if (error && last_error != -EFSCORRUPTED)
90 91 92 93 94 95
				last_error = error;
		}

		mutex_unlock(&qi->qi_tree_lock);

		/* bail out if the filesystem is corrupted.  */
96
		if (last_error == -EFSCORRUPTED) {
97 98 99
			skipped = 0;
			break;
		}
100 101 102
		/* we're done if id overflows back to zero */
		if (!next_index)
			break;
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118
	}

	if (skipped) {
		delay(1);
		goto restart;
	}

	return last_error;
}


/*
 * Purge a dquot from all tracking data structures and free it.
 */
STATIC int
xfs_qm_dqpurge(
119 120
	struct xfs_dquot	*dqp,
	void			*data)
121 122 123 124 125 126 127
{
	struct xfs_mount	*mp = dqp->q_mount;
	struct xfs_quotainfo	*qi = mp->m_quotainfo;

	xfs_dqlock(dqp);
	if ((dqp->dq_flags & XFS_DQ_FREEING) || dqp->q_nrefs != 0) {
		xfs_dqunlock(dqp);
128
		return -EAGAIN;
129 130 131 132
	}

	dqp->dq_flags |= XFS_DQ_FREEING;

133
	xfs_dqflock(dqp);
134 135 136 137 138 139 140

	/*
	 * If we are turning this type of quotas off, we don't care
	 * about the dirty metadata sitting in this dquot. OTOH, if
	 * we're unmounting, we do care, so we flush it and wait.
	 */
	if (XFS_DQ_IS_DIRTY(dqp)) {
141 142
		struct xfs_buf	*bp = NULL;
		int		error;
143 144 145 146 147

		/*
		 * We don't care about getting disk errors here. We need
		 * to purge this dquot anyway, so we go ahead regardless.
		 */
148
		error = xfs_qm_dqflush(dqp, &bp);
149
		if (!error) {
150 151 152
			error = xfs_bwrite(bp);
			xfs_buf_relse(bp);
		}
153 154 155 156 157
		xfs_dqflock(dqp);
	}

	ASSERT(atomic_read(&dqp->q_pincount) == 0);
	ASSERT(XFS_FORCED_SHUTDOWN(mp) ||
158
		!test_bit(XFS_LI_IN_AIL, &dqp->q_logitem.qli_item.li_flags));
159 160 161 162

	xfs_dqfunlock(dqp);
	xfs_dqunlock(dqp);

163
	radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
164 165 166 167 168 169 170 171
			  be32_to_cpu(dqp->q_core.d_id));
	qi->qi_dquots--;

	/*
	 * We move dquots to the freelist as soon as their reference count
	 * hits zero, so it really should be on the freelist here.
	 */
	ASSERT(!list_empty(&dqp->q_lru));
172
	list_lru_del(&qi->qi_lru, &dqp->q_lru);
173
	XFS_STATS_DEC(mp, xs_qm_dquot_unused);
174 175

	xfs_qm_dqdestroy(dqp);
176 177 178
	return 0;
}

179 180 181 182 183 184 185 186
/*
 * Purge the dquot cache.
 */
void
xfs_qm_dqpurge_all(
	struct xfs_mount	*mp,
	uint			flags)
{
D
Dave Chinner 已提交
187 188
	if (flags & XFS_QMOPT_UQUOTA)
		xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_dqpurge, NULL);
189
	if (flags & XFS_QMOPT_GQUOTA)
190
		xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_dqpurge, NULL);
191
	if (flags & XFS_QMOPT_PQUOTA)
192
		xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_dqpurge, NULL);
193 194
}

L
Linus Torvalds 已提交
195 196 197 198
/*
 * Just destroy the quotainfo structure.
 */
void
C
Christoph Hellwig 已提交
199 200
xfs_qm_unmount(
	struct xfs_mount	*mp)
L
Linus Torvalds 已提交
201
{
C
Christoph Hellwig 已提交
202
	if (mp->m_quotainfo) {
203
		xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
L
Linus Torvalds 已提交
204
		xfs_qm_destroy_quotainfo(mp);
C
Christoph Hellwig 已提交
205
	}
L
Linus Torvalds 已提交
206 207 208 209 210
}

/*
 * Called from the vfsops layer.
 */
211
void
L
Linus Torvalds 已提交
212 213 214 215 216 217 218 219 220 221 222 223 224 225 226
xfs_qm_unmount_quotas(
	xfs_mount_t	*mp)
{
	/*
	 * Release the dquots that root inode, et al might be holding,
	 * before we flush quotas and blow away the quotainfo structure.
	 */
	ASSERT(mp->m_rootip);
	xfs_qm_dqdetach(mp->m_rootip);
	if (mp->m_rbmip)
		xfs_qm_dqdetach(mp->m_rbmip);
	if (mp->m_rsumip)
		xfs_qm_dqdetach(mp->m_rsumip);

	/*
227
	 * Release the quota inodes.
L
Linus Torvalds 已提交
228 229
	 */
	if (mp->m_quotainfo) {
230
		if (mp->m_quotainfo->qi_uquotaip) {
231
			xfs_irele(mp->m_quotainfo->qi_uquotaip);
232
			mp->m_quotainfo->qi_uquotaip = NULL;
L
Linus Torvalds 已提交
233
		}
234
		if (mp->m_quotainfo->qi_gquotaip) {
235
			xfs_irele(mp->m_quotainfo->qi_gquotaip);
236
			mp->m_quotainfo->qi_gquotaip = NULL;
L
Linus Torvalds 已提交
237
		}
238
		if (mp->m_quotainfo->qi_pquotaip) {
239
			xfs_irele(mp->m_quotainfo->qi_pquotaip);
240 241
			mp->m_quotainfo->qi_pquotaip = NULL;
		}
L
Linus Torvalds 已提交
242 243 244 245 246
	}
}

STATIC int
xfs_qm_dqattach_one(
247 248 249 250 251
	struct xfs_inode	*ip,
	xfs_dqid_t		id,
	uint			type,
	bool			doalloc,
	struct xfs_dquot	**IO_idqpp)
L
Linus Torvalds 已提交
252
{
253 254
	struct xfs_dquot	*dqp;
	int			error;
L
Linus Torvalds 已提交
255

C
Christoph Hellwig 已提交
256
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
L
Linus Torvalds 已提交
257
	error = 0;
258

L
Linus Torvalds 已提交
259
	/*
D
Dave Chinner 已提交
260 261 262
	 * See if we already have it in the inode itself. IO_idqpp is &i_udquot
	 * or &i_gdquot. This made the code look weird, but made the logic a lot
	 * simpler.
L
Linus Torvalds 已提交
263
	 */
264 265
	dqp = *IO_idqpp;
	if (dqp) {
266
		trace_xfs_dqattach_found(dqp);
267
		return 0;
L
Linus Torvalds 已提交
268 269 270
	}

	/*
D
Dave Chinner 已提交
271 272 273 274
	 * Find the dquot from somewhere. This bumps the reference count of
	 * dquot and returns it locked.  This can return ENOENT if dquot didn't
	 * exist on disk and we didn't ask it to allocate; ESRCH if quotas got
	 * turned off suddenly.
L
Linus Torvalds 已提交
275
	 */
276
	error = xfs_qm_dqget_inode(ip, type, doalloc, &dqp);
277 278
	if (error)
		return error;
L
Linus Torvalds 已提交
279

280
	trace_xfs_dqattach_get(dqp);
281

L
Linus Torvalds 已提交
282 283 284 285 286
	/*
	 * dqget may have dropped and re-acquired the ilock, but it guarantees
	 * that the dquot returned is the one that should go in the inode.
	 */
	*IO_idqpp = dqp;
287 288
	xfs_dqunlock(dqp);
	return 0;
L
Linus Torvalds 已提交
289 290
}

291 292 293 294 295 296 297 298 299 300 301 302
static bool
xfs_qm_need_dqattach(
	struct xfs_inode	*ip)
{
	struct xfs_mount	*mp = ip->i_mount;

	if (!XFS_IS_QUOTA_RUNNING(mp))
		return false;
	if (!XFS_IS_QUOTA_ON(mp))
		return false;
	if (!XFS_NOT_DQATTACHED(mp, ip))
		return false;
303
	if (xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
304 305 306
		return false;
	return true;
}
L
Linus Torvalds 已提交
307 308

/*
309 310
 * Given a locked inode, attach dquot(s) to it, taking U/G/P-QUOTAON
 * into account.
311
 * If @doalloc is true, the dquot(s) will be allocated if needed.
L
Linus Torvalds 已提交
312 313 314 315
 * Inode may get unlocked and relocked in here, and the caller must deal with
 * the consequences.
 */
int
C
Christoph Hellwig 已提交
316
xfs_qm_dqattach_locked(
L
Linus Torvalds 已提交
317
	xfs_inode_t	*ip,
318
	bool		doalloc)
L
Linus Torvalds 已提交
319 320 321 322
{
	xfs_mount_t	*mp = ip->i_mount;
	int		error = 0;

323
	if (!xfs_qm_need_dqattach(ip))
324
		return 0;
L
Linus Torvalds 已提交
325

C
Christoph Hellwig 已提交
326
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
L
Linus Torvalds 已提交
327

D
Dave Chinner 已提交
328
	if (XFS_IS_UQUOTA_ON(mp) && !ip->i_udquot) {
L
Linus Torvalds 已提交
329
		error = xfs_qm_dqattach_one(ip, ip->i_d.di_uid, XFS_DQ_USER,
330
				doalloc, &ip->i_udquot);
L
Linus Torvalds 已提交
331 332
		if (error)
			goto done;
D
Dave Chinner 已提交
333
		ASSERT(ip->i_udquot);
L
Linus Torvalds 已提交
334
	}
C
Christoph Hellwig 已提交
335

D
Dave Chinner 已提交
336
	if (XFS_IS_GQUOTA_ON(mp) && !ip->i_gdquot) {
337
		error = xfs_qm_dqattach_one(ip, ip->i_d.di_gid, XFS_DQ_GROUP,
338
				doalloc, &ip->i_gdquot);
L
Linus Torvalds 已提交
339 340
		if (error)
			goto done;
D
Dave Chinner 已提交
341
		ASSERT(ip->i_gdquot);
L
Linus Torvalds 已提交
342 343
	}

D
Dave Chinner 已提交
344
	if (XFS_IS_PQUOTA_ON(mp) && !ip->i_pdquot) {
345
		error = xfs_qm_dqattach_one(ip, ip->i_d.di_projid, XFS_DQ_PROJ,
346
				doalloc, &ip->i_pdquot);
347 348
		if (error)
			goto done;
D
Dave Chinner 已提交
349
		ASSERT(ip->i_pdquot);
350 351
	}

D
Dave Chinner 已提交
352
done:
L
Linus Torvalds 已提交
353
	/*
D
Dave Chinner 已提交
354 355
	 * Don't worry about the dquots that we may have attached before any
	 * error - they'll get detached later if it has not already been done.
L
Linus Torvalds 已提交
356
	 */
C
Christoph Hellwig 已提交
357 358 359
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
	return error;
}
L
Linus Torvalds 已提交
360

C
Christoph Hellwig 已提交
361 362
int
xfs_qm_dqattach(
363
	struct xfs_inode	*ip)
C
Christoph Hellwig 已提交
364 365 366
{
	int			error;

367 368 369
	if (!xfs_qm_need_dqattach(ip))
		return 0;

C
Christoph Hellwig 已提交
370
	xfs_ilock(ip, XFS_ILOCK_EXCL);
371
	error = xfs_qm_dqattach_locked(ip, false);
C
Christoph Hellwig 已提交
372
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
L
Linus Torvalds 已提交
373

374
	return error;
L
Linus Torvalds 已提交
375 376 377 378 379 380 381 382 383 384 385
}

/*
 * Release dquots (and their references) if any.
 * The inode should be locked EXCL except when this's called by
 * xfs_ireclaim.
 */
void
xfs_qm_dqdetach(
	xfs_inode_t	*ip)
{
386
	if (!(ip->i_udquot || ip->i_gdquot || ip->i_pdquot))
L
Linus Torvalds 已提交
387 388
		return;

389 390
	trace_xfs_dquot_dqdetach(ip);

391
	ASSERT(!xfs_is_quota_inode(&ip->i_mount->m_sb, ip->i_ino));
L
Linus Torvalds 已提交
392 393 394 395 396 397 398 399
	if (ip->i_udquot) {
		xfs_qm_dqrele(ip->i_udquot);
		ip->i_udquot = NULL;
	}
	if (ip->i_gdquot) {
		xfs_qm_dqrele(ip->i_gdquot);
		ip->i_gdquot = NULL;
	}
400 401 402 403
	if (ip->i_pdquot) {
		xfs_qm_dqrele(ip->i_pdquot);
		ip->i_pdquot = NULL;
	}
L
Linus Torvalds 已提交
404 405
}

406 407 408 409 410 411 412 413
struct xfs_qm_isolate {
	struct list_head	buffers;
	struct list_head	dispose;
};

static enum lru_status
xfs_qm_dquot_isolate(
	struct list_head	*item,
414
	struct list_lru_one	*lru,
415 416
	spinlock_t		*lru_lock,
	void			*arg)
417
		__releases(lru_lock) __acquires(lru_lock)
418 419 420 421 422 423 424 425 426 427 428 429 430 431
{
	struct xfs_dquot	*dqp = container_of(item,
						struct xfs_dquot, q_lru);
	struct xfs_qm_isolate	*isol = arg;

	if (!xfs_dqlock_nowait(dqp))
		goto out_miss_busy;

	/*
	 * This dquot has acquired a reference in the meantime remove it from
	 * the freelist and try again.
	 */
	if (dqp->q_nrefs) {
		xfs_dqunlock(dqp);
432
		XFS_STATS_INC(dqp->q_mount, xs_qm_dqwants);
433 434

		trace_xfs_dqreclaim_want(dqp);
435
		list_lru_isolate(lru, &dqp->q_lru);
436
		XFS_STATS_DEC(dqp->q_mount, xs_qm_dquot_unused);
437
		return LRU_REMOVED;
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
	}

	/*
	 * If the dquot is dirty, flush it. If it's already being flushed, just
	 * skip it so there is time for the IO to complete before we try to
	 * reclaim it again on the next LRU pass.
	 */
	if (!xfs_dqflock_nowait(dqp)) {
		xfs_dqunlock(dqp);
		goto out_miss_busy;
	}

	if (XFS_DQ_IS_DIRTY(dqp)) {
		struct xfs_buf	*bp = NULL;
		int		error;

		trace_xfs_dqreclaim_dirty(dqp);

		/* we have to drop the LRU lock to flush the dquot */
		spin_unlock(lru_lock);

		error = xfs_qm_dqflush(dqp, &bp);
460
		if (error)
461 462 463 464 465 466 467 468 469 470 471 472 473 474 475
			goto out_unlock_dirty;

		xfs_buf_delwri_queue(bp, &isol->buffers);
		xfs_buf_relse(bp);
		goto out_unlock_dirty;
	}
	xfs_dqfunlock(dqp);

	/*
	 * Prevent lookups now that we are past the point of no return.
	 */
	dqp->dq_flags |= XFS_DQ_FREEING;
	xfs_dqunlock(dqp);

	ASSERT(dqp->q_nrefs == 0);
476
	list_lru_isolate_move(lru, &dqp->q_lru, &isol->dispose);
477
	XFS_STATS_DEC(dqp->q_mount, xs_qm_dquot_unused);
478
	trace_xfs_dqreclaim_done(dqp);
479
	XFS_STATS_INC(dqp->q_mount, xs_qm_dqreclaims);
480
	return LRU_REMOVED;
481 482 483

out_miss_busy:
	trace_xfs_dqreclaim_busy(dqp);
484
	XFS_STATS_INC(dqp->q_mount, xs_qm_dqreclaim_misses);
485
	return LRU_SKIP;
486 487 488

out_unlock_dirty:
	trace_xfs_dqreclaim_busy(dqp);
489
	XFS_STATS_INC(dqp->q_mount, xs_qm_dqreclaim_misses);
490 491 492
	xfs_dqunlock(dqp);
	spin_lock(lru_lock);
	return LRU_RETRY;
493 494
}

495
static unsigned long
496 497 498 499 500 501 502
xfs_qm_shrink_scan(
	struct shrinker		*shrink,
	struct shrink_control	*sc)
{
	struct xfs_quotainfo	*qi = container_of(shrink,
					struct xfs_quotainfo, qi_shrinker);
	struct xfs_qm_isolate	isol;
503
	unsigned long		freed;
504 505
	int			error;

506
	if ((sc->gfp_mask & (__GFP_FS|__GFP_DIRECT_RECLAIM)) != (__GFP_FS|__GFP_DIRECT_RECLAIM))
507 508 509 510 511
		return 0;

	INIT_LIST_HEAD(&isol.buffers);
	INIT_LIST_HEAD(&isol.dispose);

512 513
	freed = list_lru_shrink_walk(&qi->qi_lru, sc,
				     xfs_qm_dquot_isolate, &isol);
514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529

	error = xfs_buf_delwri_submit(&isol.buffers);
	if (error)
		xfs_warn(NULL, "%s: dquot reclaim failed", __func__);

	while (!list_empty(&isol.dispose)) {
		struct xfs_dquot	*dqp;

		dqp = list_first_entry(&isol.dispose, struct xfs_dquot, q_lru);
		list_del_init(&dqp->q_lru);
		xfs_qm_dqfree_one(dqp);
	}

	return freed;
}

530
static unsigned long
531 532 533 534 535 536 537
xfs_qm_shrink_count(
	struct shrinker		*shrink,
	struct shrink_control	*sc)
{
	struct xfs_quotainfo	*qi = container_of(shrink,
					struct xfs_quotainfo, qi_shrinker);

538
	return list_lru_shrink_count(&qi->qi_lru, sc);
539 540
}

541 542
STATIC void
xfs_qm_set_defquota(
543 544 545
	struct xfs_mount	*mp,
	uint			type,
	struct xfs_quotainfo	*qinf)
546
{
547 548
	struct xfs_dquot	*dqp;
	struct xfs_def_quota	*defq;
549
	struct xfs_disk_dquot	*ddqp;
550 551
	int			error;

552
	error = xfs_qm_dqget_uncached(mp, 0, type, &dqp);
553 554
	if (error)
		return;
555

556 557
	ddqp = &dqp->q_core;
	defq = xfs_get_defquota(dqp, qinf);
558

559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630
	/*
	 * Timers and warnings have been already set, let's just set the
	 * default limits for this quota type
	 */
	defq->bhardlimit = be64_to_cpu(ddqp->d_blk_hardlimit);
	defq->bsoftlimit = be64_to_cpu(ddqp->d_blk_softlimit);
	defq->ihardlimit = be64_to_cpu(ddqp->d_ino_hardlimit);
	defq->isoftlimit = be64_to_cpu(ddqp->d_ino_softlimit);
	defq->rtbhardlimit = be64_to_cpu(ddqp->d_rtb_hardlimit);
	defq->rtbsoftlimit = be64_to_cpu(ddqp->d_rtb_softlimit);
	xfs_qm_dqdestroy(dqp);
}

/* Initialize quota time limits from the root dquot. */
static void
xfs_qm_init_timelimits(
	struct xfs_mount	*mp,
	struct xfs_quotainfo	*qinf)
{
	struct xfs_disk_dquot	*ddqp;
	struct xfs_dquot	*dqp;
	uint			type;
	int			error;

	qinf->qi_btimelimit = XFS_QM_BTIMELIMIT;
	qinf->qi_itimelimit = XFS_QM_ITIMELIMIT;
	qinf->qi_rtbtimelimit = XFS_QM_RTBTIMELIMIT;
	qinf->qi_bwarnlimit = XFS_QM_BWARNLIMIT;
	qinf->qi_iwarnlimit = XFS_QM_IWARNLIMIT;
	qinf->qi_rtbwarnlimit = XFS_QM_RTBWARNLIMIT;

	/*
	 * We try to get the limits from the superuser's limits fields.
	 * This is quite hacky, but it is standard quota practice.
	 *
	 * Since we may not have done a quotacheck by this point, just read
	 * the dquot without attaching it to any hashtables or lists.
	 *
	 * Timers and warnings are globally set by the first timer found in
	 * user/group/proj quota types, otherwise a default value is used.
	 * This should be split into different fields per quota type.
	 */
	if (XFS_IS_UQUOTA_RUNNING(mp))
		type = XFS_DQ_USER;
	else if (XFS_IS_GQUOTA_RUNNING(mp))
		type = XFS_DQ_GROUP;
	else
		type = XFS_DQ_PROJ;
	error = xfs_qm_dqget_uncached(mp, 0, type, &dqp);
	if (error)
		return;

	ddqp = &dqp->q_core;
	/*
	 * The warnings and timers set the grace period given to
	 * a user or group before he or she can not perform any
	 * more writing. If it is zero, a default is used.
	 */
	if (ddqp->d_btimer)
		qinf->qi_btimelimit = be32_to_cpu(ddqp->d_btimer);
	if (ddqp->d_itimer)
		qinf->qi_itimelimit = be32_to_cpu(ddqp->d_itimer);
	if (ddqp->d_rtbtimer)
		qinf->qi_rtbtimelimit = be32_to_cpu(ddqp->d_rtbtimer);
	if (ddqp->d_bwarns)
		qinf->qi_bwarnlimit = be16_to_cpu(ddqp->d_bwarns);
	if (ddqp->d_iwarns)
		qinf->qi_iwarnlimit = be16_to_cpu(ddqp->d_iwarns);
	if (ddqp->d_rtbwarns)
		qinf->qi_rtbwarnlimit = be16_to_cpu(ddqp->d_rtbwarns);

	xfs_qm_dqdestroy(dqp);
631 632
}

L
Linus Torvalds 已提交
633 634 635 636
/*
 * This initializes all the quota information that's kept in the
 * mount structure
 */
637
STATIC int
L
Linus Torvalds 已提交
638
xfs_qm_init_quotainfo(
639
	struct xfs_mount	*mp)
L
Linus Torvalds 已提交
640
{
641 642
	struct xfs_quotainfo	*qinf;
	int			error;
L
Linus Torvalds 已提交
643 644 645

	ASSERT(XFS_IS_QUOTA_RUNNING(mp));

646
	qinf = mp->m_quotainfo = kmem_zalloc(sizeof(struct xfs_quotainfo), 0);
L
Linus Torvalds 已提交
647

648
	error = list_lru_init(&qinf->qi_lru);
649 650
	if (error)
		goto out_free_qinf;
651

L
Linus Torvalds 已提交
652 653 654 655
	/*
	 * See if quotainodes are setup, and if not, allocate them,
	 * and change the superblock accordingly.
	 */
656 657 658
	error = xfs_qm_init_quotainos(mp);
	if (error)
		goto out_free_lru;
L
Linus Torvalds 已提交
659

660 661
	INIT_RADIX_TREE(&qinf->qi_uquota_tree, GFP_NOFS);
	INIT_RADIX_TREE(&qinf->qi_gquota_tree, GFP_NOFS);
662
	INIT_RADIX_TREE(&qinf->qi_pquota_tree, GFP_NOFS);
663 664
	mutex_init(&qinf->qi_tree_lock);

L
Linus Torvalds 已提交
665
	/* mutex used to serialize quotaoffs */
666
	mutex_init(&qinf->qi_quotaofflock);
L
Linus Torvalds 已提交
667 668 669

	/* Precalc some constants */
	qinf->qi_dqchunklen = XFS_FSB_TO_BB(mp, XFS_DQUOT_CLUSTER_SIZE_FSB);
670
	qinf->qi_dqperchunk = xfs_calc_dquots_per_chunk(qinf->qi_dqchunklen);
L
Linus Torvalds 已提交
671 672 673

	mp->m_qflags |= (mp->m_sb.sb_qflags & XFS_ALL_QUOTA_CHKD);

674
	xfs_qm_init_timelimits(mp, qinf);
L
Linus Torvalds 已提交
675

676 677 678 679 680 681 682
	if (XFS_IS_UQUOTA_RUNNING(mp))
		xfs_qm_set_defquota(mp, XFS_DQ_USER, qinf);
	if (XFS_IS_GQUOTA_RUNNING(mp))
		xfs_qm_set_defquota(mp, XFS_DQ_GROUP, qinf);
	if (XFS_IS_PQUOTA_RUNNING(mp))
		xfs_qm_set_defquota(mp, XFS_DQ_PROJ, qinf);

683 684
	qinf->qi_shrinker.count_objects = xfs_qm_shrink_count;
	qinf->qi_shrinker.scan_objects = xfs_qm_shrink_scan;
685
	qinf->qi_shrinker.seeks = DEFAULT_SEEKS;
686
	qinf->qi_shrinker.flags = SHRINKER_NUMA_AWARE;
687 688 689 690 691

	error = register_shrinker(&qinf->qi_shrinker);
	if (error)
		goto out_free_inos;

692
	return 0;
693

694 695 696 697
out_free_inos:
	mutex_destroy(&qinf->qi_quotaofflock);
	mutex_destroy(&qinf->qi_tree_lock);
	xfs_qm_destroy_quotainos(qinf);
698 699 700 701 702 703
out_free_lru:
	list_lru_destroy(&qinf->qi_lru);
out_free_qinf:
	kmem_free(qinf);
	mp->m_quotainfo = NULL;
	return error;
L
Linus Torvalds 已提交
704 705 706 707 708 709 710 711 712
}

/*
 * Gets called when unmounting a filesystem or when all quotas get
 * turned off.
 * This purges the quota inodes, destroys locks and frees itself.
 */
void
xfs_qm_destroy_quotainfo(
713
	struct xfs_mount	*mp)
L
Linus Torvalds 已提交
714
{
715
	struct xfs_quotainfo	*qi;
L
Linus Torvalds 已提交
716 717 718 719

	qi = mp->m_quotainfo;
	ASSERT(qi != NULL);

720
	unregister_shrinker(&qi->qi_shrinker);
721
	list_lru_destroy(&qi->qi_lru);
722
	xfs_qm_destroy_quotainos(qi);
723
	mutex_destroy(&qi->qi_tree_lock);
L
Linus Torvalds 已提交
724
	mutex_destroy(&qi->qi_quotaofflock);
725
	kmem_free(qi);
L
Linus Torvalds 已提交
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740
	mp->m_quotainfo = NULL;
}

/*
 * Create an inode and return with a reference already taken, but unlocked
 * This is how we create quota inodes
 */
STATIC int
xfs_qm_qino_alloc(
	xfs_mount_t	*mp,
	xfs_inode_t	**ip,
	uint		flags)
{
	xfs_trans_t	*tp;
	int		error;
741
	bool		need_alloc = true;
L
Linus Torvalds 已提交
742

743 744 745 746 747 748 749 750 751 752 753 754 755 756 757
	*ip = NULL;
	/*
	 * With superblock that doesn't have separate pquotino, we
	 * share an inode between gquota and pquota. If the on-disk
	 * superblock has GQUOTA and the filesystem is now mounted
	 * with PQUOTA, just use sb_gquotino for sb_pquotino and
	 * vice-versa.
	 */
	if (!xfs_sb_version_has_pquotino(&mp->m_sb) &&
			(flags & (XFS_QMOPT_PQUOTA|XFS_QMOPT_GQUOTA))) {
		xfs_ino_t ino = NULLFSINO;

		if ((flags & XFS_QMOPT_PQUOTA) &&
			     (mp->m_sb.sb_gquotino != NULLFSINO)) {
			ino = mp->m_sb.sb_gquotino;
758 759
			if (XFS_IS_CORRUPT(mp,
					   mp->m_sb.sb_pquotino != NULLFSINO))
760
				return -EFSCORRUPTED;
761 762 763
		} else if ((flags & XFS_QMOPT_GQUOTA) &&
			     (mp->m_sb.sb_pquotino != NULLFSINO)) {
			ino = mp->m_sb.sb_pquotino;
764 765
			if (XFS_IS_CORRUPT(mp,
					   mp->m_sb.sb_gquotino != NULLFSINO))
766
				return -EFSCORRUPTED;
767 768 769 770 771 772 773
		}
		if (ino != NULLFSINO) {
			error = xfs_iget(mp, NULL, ino, 0, 0, ip);
			if (error)
				return error;
			mp->m_sb.sb_gquotino = NULLFSINO;
			mp->m_sb.sb_pquotino = NULLFSINO;
774
			need_alloc = false;
775 776 777
		}
	}

778 779 780
	error = xfs_trans_alloc(mp, &M_RES(mp)->tr_create,
			XFS_QM_QINOCREATE_SPACE_RES(mp), 0, 0, &tp);
	if (error)
781
		return error;
L
Linus Torvalds 已提交
782

783
	if (need_alloc) {
784
		error = xfs_dir_ialloc(&tp, NULL, S_IFREG, 1, 0, 0, ip);
785
		if (error) {
786
			xfs_trans_cancel(tp);
787 788
			return error;
		}
L
Linus Torvalds 已提交
789 790 791 792 793 794 795
	}

	/*
	 * Make the changes in the superblock, and log those too.
	 * sbfields arg may contain fields other than *QUOTINO;
	 * VERSIONNUM for example.
	 */
E
Eric Sandeen 已提交
796
	spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
797
	if (flags & XFS_QMOPT_SBVERSION) {
798
		ASSERT(!xfs_sb_version_hasquota(&mp->m_sb));
L
Linus Torvalds 已提交
799

800
		xfs_sb_version_addquota(&mp->m_sb);
L
Linus Torvalds 已提交
801 802
		mp->m_sb.sb_uquotino = NULLFSINO;
		mp->m_sb.sb_gquotino = NULLFSINO;
803
		mp->m_sb.sb_pquotino = NULLFSINO;
L
Linus Torvalds 已提交
804

805 806
		/* qflags will get updated fully _after_ quotacheck */
		mp->m_sb.sb_qflags = mp->m_qflags & XFS_ALL_QUOTA_ACCT;
L
Linus Torvalds 已提交
807 808 809
	}
	if (flags & XFS_QMOPT_UQUOTA)
		mp->m_sb.sb_uquotino = (*ip)->i_ino;
810
	else if (flags & XFS_QMOPT_GQUOTA)
L
Linus Torvalds 已提交
811
		mp->m_sb.sb_gquotino = (*ip)->i_ino;
812 813
	else
		mp->m_sb.sb_pquotino = (*ip)->i_ino;
E
Eric Sandeen 已提交
814
	spin_unlock(&mp->m_sb_lock);
815
	xfs_log_sb(tp);
L
Linus Torvalds 已提交
816

817
	error = xfs_trans_commit(tp);
818 819
	if (error) {
		ASSERT(XFS_FORCED_SHUTDOWN(mp));
820
		xfs_alert(mp, "%s failed (error %d)!", __func__, error);
L
Linus Torvalds 已提交
821
	}
822 823 824
	if (need_alloc)
		xfs_finish_inode_setup(*ip);
	return error;
L
Linus Torvalds 已提交
825 826 827
}


828
STATIC void
L
Linus Torvalds 已提交
829 830 831 832 833 834
xfs_qm_reset_dqcounts(
	xfs_mount_t	*mp,
	xfs_buf_t	*bp,
	xfs_dqid_t	id,
	uint		type)
{
D
Dave Chinner 已提交
835
	struct xfs_dqblk	*dqb;
L
Linus Torvalds 已提交
836
	int			j;
837
	xfs_failaddr_t		fa;
L
Linus Torvalds 已提交
838

839 840
	trace_xfs_reset_dqcounts(bp, _RET_IP_);

L
Linus Torvalds 已提交
841 842 843 844 845
	/*
	 * Reset all counters and timers. They'll be
	 * started afresh by xfs_qm_quotacheck.
	 */
#ifdef DEBUG
846 847
	j = (int)XFS_FSB_TO_B(mp, XFS_DQUOT_CLUSTER_SIZE_FSB) /
		sizeof(xfs_dqblk_t);
848
	ASSERT(mp->m_quotainfo->qi_dqperchunk == j);
L
Linus Torvalds 已提交
849
#endif
D
Dave Chinner 已提交
850
	dqb = bp->b_addr;
851
	for (j = 0; j < mp->m_quotainfo->qi_dqperchunk; j++) {
D
Dave Chinner 已提交
852 853 854 855
		struct xfs_disk_dquot	*ddq;

		ddq = (struct xfs_disk_dquot *)&dqb[j];

L
Linus Torvalds 已提交
856 857 858
		/*
		 * Do a sanity check, and if needed, repair the dqblk. Don't
		 * output any warnings because it's perfectly possible to
859 860
		 * find uninitialised dquot blks. See comment in
		 * xfs_dquot_verify.
L
Linus Torvalds 已提交
861
		 */
862
		fa = xfs_dqblk_verify(mp, &dqb[j], id + j, type);
863
		if (fa)
864
			xfs_dqblk_repair(mp, &dqb[j], id + j, type);
865

866 867 868 869 870
		/*
		 * Reset type in case we are reusing group quota file for
		 * project quotas or vice versa
		 */
		ddq->d_flags = type;
871 872 873 874 875 876 877 878 879
		ddq->d_bcount = 0;
		ddq->d_icount = 0;
		ddq->d_rtbcount = 0;
		ddq->d_btimer = 0;
		ddq->d_itimer = 0;
		ddq->d_rtbtimer = 0;
		ddq->d_bwarns = 0;
		ddq->d_iwarns = 0;
		ddq->d_rtbwarns = 0;
D
Dave Chinner 已提交
880 881 882 883 884 885

		if (xfs_sb_version_hascrc(&mp->m_sb)) {
			xfs_update_cksum((char *)&dqb[j],
					 sizeof(struct xfs_dqblk),
					 XFS_DQUOT_CRC_OFF);
		}
L
Linus Torvalds 已提交
886 887 888 889
	}
}

STATIC int
890
xfs_qm_reset_dqcounts_all(
891 892 893 894 895 896
	struct xfs_mount	*mp,
	xfs_dqid_t		firstid,
	xfs_fsblock_t		bno,
	xfs_filblks_t		blkcnt,
	uint			flags,
	struct list_head	*buffer_list)
L
Linus Torvalds 已提交
897
{
898 899 900
	struct xfs_buf		*bp;
	int			error;
	int			type;
L
Linus Torvalds 已提交
901 902

	ASSERT(blkcnt > 0);
903 904
	type = flags & XFS_QMOPT_UQUOTA ? XFS_DQ_USER :
		(flags & XFS_QMOPT_PQUOTA ? XFS_DQ_PROJ : XFS_DQ_GROUP);
L
Linus Torvalds 已提交
905 906 907 908 909 910 911 912 913 914 915 916 917 918
	error = 0;

	/*
	 * Blkcnt arg can be a very big number, and might even be
	 * larger than the log itself. So, we have to break it up into
	 * manageable-sized transactions.
	 * Note that we don't start a permanent transaction here; we might
	 * not be able to get a log reservation for the whole thing up front,
	 * and we don't really care to either, because we just discard
	 * everything if we were to crash in the middle of this loop.
	 */
	while (blkcnt--) {
		error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
			      XFS_FSB_TO_DADDR(mp, bno),
919
			      mp->m_quotainfo->qi_dqchunklen, 0, &bp,
920
			      &xfs_dquot_buf_ops);
L
Linus Torvalds 已提交
921

922
		/*
D
Dave Chinner 已提交
923 924 925 926 927
		 * CRC and validation errors will return a EFSCORRUPTED here. If
		 * this occurs, re-read without CRC validation so that we can
		 * repair the damage via xfs_qm_reset_dqcounts(). This process
		 * will leave a trace in the log indicating corruption has
		 * been detected.
928
		 */
929
		if (error == -EFSCORRUPTED) {
D
Dave Chinner 已提交
930 931 932 933 934 935 936 937 938
			error = xfs_trans_read_buf(mp, NULL, mp->m_ddev_targp,
				      XFS_FSB_TO_DADDR(mp, bno),
				      mp->m_quotainfo->qi_dqchunklen, 0, &bp,
				      NULL);
		}

		if (error)
			break;

939 940 941 942 943 944
		/*
		 * A corrupt buffer might not have a verifier attached, so
		 * make sure we have the correct one attached before writeback
		 * occurs.
		 */
		bp->b_ops = &xfs_dquot_buf_ops;
945
		xfs_qm_reset_dqcounts(mp, bp, firstid, type);
946
		xfs_buf_delwri_queue(bp, buffer_list);
947
		xfs_buf_relse(bp);
D
Dave Chinner 已提交
948 949

		/* goto the next block. */
L
Linus Torvalds 已提交
950
		bno++;
951
		firstid += mp->m_quotainfo->qi_dqperchunk;
L
Linus Torvalds 已提交
952
	}
953

954
	return error;
L
Linus Torvalds 已提交
955 956 957
}

/*
958 959
 * Iterate over all allocated dquot blocks in this quota inode, zeroing all
 * counters for every chunk of dquots that we find.
L
Linus Torvalds 已提交
960 961
 */
STATIC int
962
xfs_qm_reset_dqcounts_buf(
963 964 965 966
	struct xfs_mount	*mp,
	struct xfs_inode	*qip,
	uint			flags,
	struct list_head	*buffer_list)
L
Linus Torvalds 已提交
967
{
968
	struct xfs_bmbt_irec	*map;
L
Linus Torvalds 已提交
969 970 971 972 973 974 975 976 977 978
	int			i, nmaps;	/* number of map entries */
	int			error;		/* return value */
	xfs_fileoff_t		lblkno;
	xfs_filblks_t		maxlblkcnt;
	xfs_dqid_t		firstid;
	xfs_fsblock_t		rablkno;
	xfs_filblks_t		rablkcnt;

	error = 0;
	/*
979
	 * This looks racy, but we can't keep an inode lock across a
L
Linus Torvalds 已提交
980 981 982 983
	 * trans_reserve. But, this gets called during quotacheck, and that
	 * happens only at mount time which is single threaded.
	 */
	if (qip->i_d.di_nblocks == 0)
984
		return 0;
L
Linus Torvalds 已提交
985

986
	map = kmem_alloc(XFS_DQITER_MAP_SIZE * sizeof(*map), 0);
L
Linus Torvalds 已提交
987 988

	lblkno = 0;
989
	maxlblkcnt = XFS_B_TO_FSB(mp, mp->m_super->s_maxbytes);
L
Linus Torvalds 已提交
990
	do {
991 992
		uint		lock_mode;

L
Linus Torvalds 已提交
993 994 995 996 997 998
		nmaps = XFS_DQITER_MAP_SIZE;
		/*
		 * We aren't changing the inode itself. Just changing
		 * some of its data. No new blocks are added here, and
		 * the inode is never added to the transaction.
		 */
999
		lock_mode = xfs_ilock_data_map_shared(qip);
1000 1001
		error = xfs_bmapi_read(qip, lblkno, maxlblkcnt - lblkno,
				       map, &nmaps, 0);
1002
		xfs_iunlock(qip, lock_mode);
L
Linus Torvalds 已提交
1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017
		if (error)
			break;

		ASSERT(nmaps <= XFS_DQITER_MAP_SIZE);
		for (i = 0; i < nmaps; i++) {
			ASSERT(map[i].br_startblock != DELAYSTARTBLOCK);
			ASSERT(map[i].br_blockcount);


			lblkno += map[i].br_blockcount;

			if (map[i].br_startblock == HOLESTARTBLOCK)
				continue;

			firstid = (xfs_dqid_t) map[i].br_startoff *
1018
				mp->m_quotainfo->qi_dqperchunk;
L
Linus Torvalds 已提交
1019 1020 1021 1022 1023 1024 1025 1026
			/*
			 * Do a read-ahead on the next extent.
			 */
			if ((i+1 < nmaps) &&
			    (map[i+1].br_startblock != HOLESTARTBLOCK)) {
				rablkcnt =  map[i+1].br_blockcount;
				rablkno = map[i+1].br_startblock;
				while (rablkcnt--) {
1027
					xfs_buf_readahead(mp->m_ddev_targp,
L
Linus Torvalds 已提交
1028
					       XFS_FSB_TO_DADDR(mp, rablkno),
1029
					       mp->m_quotainfo->qi_dqchunklen,
1030
					       &xfs_dquot_buf_ops);
L
Linus Torvalds 已提交
1031 1032 1033 1034 1035 1036 1037
					rablkno++;
				}
			}
			/*
			 * Iterate thru all the blks in the extent and
			 * reset the counters of all the dquots inside them.
			 */
1038
			error = xfs_qm_reset_dqcounts_all(mp, firstid,
1039 1040 1041 1042 1043
						   map[i].br_startblock,
						   map[i].br_blockcount,
						   flags, buffer_list);
			if (error)
				goto out;
L
Linus Torvalds 已提交
1044 1045 1046
		}
	} while (nmaps > 0);

1047
out:
1048
	kmem_free(map);
1049
	return error;
L
Linus Torvalds 已提交
1050 1051 1052 1053
}

/*
 * Called by dqusage_adjust in doing a quotacheck.
1054 1055 1056 1057 1058
 *
 * Given the inode, and a dquot id this updates both the incore dqout as well
 * as the buffer copy. This is so that once the quotacheck is done, we can
 * just log all the buffers, as opposed to logging numerous updates to
 * individual dquots.
L
Linus Torvalds 已提交
1059
 */
1060
STATIC int
L
Linus Torvalds 已提交
1061
xfs_qm_quotacheck_dqadjust(
1062 1063
	struct xfs_inode	*ip,
	uint			type,
L
Linus Torvalds 已提交
1064 1065 1066
	xfs_qcnt_t		nblks,
	xfs_qcnt_t		rtblks)
{
1067 1068
	struct xfs_mount	*mp = ip->i_mount;
	struct xfs_dquot	*dqp;
1069
	xfs_dqid_t		id;
1070 1071
	int			error;

1072
	id = xfs_qm_id_for_quotatype(ip, type);
1073
	error = xfs_qm_dqget(mp, id, type, true, &dqp);
1074 1075 1076 1077
	if (error) {
		/*
		 * Shouldn't be able to turn off quotas here.
		 */
1078 1079
		ASSERT(error != -ESRCH);
		ASSERT(error != -ENOENT);
1080 1081
		return error;
	}
1082 1083 1084

	trace_xfs_dqadjust(dqp);

L
Linus Torvalds 已提交
1085 1086 1087 1088
	/*
	 * Adjust the inode count and the block count to reflect this inode's
	 * resource usage.
	 */
1089
	be64_add_cpu(&dqp->q_core.d_icount, 1);
L
Linus Torvalds 已提交
1090 1091
	dqp->q_res_icount++;
	if (nblks) {
1092
		be64_add_cpu(&dqp->q_core.d_bcount, nblks);
L
Linus Torvalds 已提交
1093 1094 1095
		dqp->q_res_bcount += nblks;
	}
	if (rtblks) {
1096
		be64_add_cpu(&dqp->q_core.d_rtbcount, rtblks);
L
Linus Torvalds 已提交
1097 1098 1099 1100 1101
		dqp->q_res_rtbcount += rtblks;
	}

	/*
	 * Set default limits, adjust timers (since we changed usages)
1102 1103
	 *
	 * There are no timers for the default values set in the root dquot.
L
Linus Torvalds 已提交
1104
	 */
1105
	if (dqp->q_core.d_id) {
1106
		xfs_qm_adjust_dqlimits(mp, dqp);
1107
		xfs_qm_adjust_dqtimers(mp, &dqp->q_core);
L
Linus Torvalds 已提交
1108 1109 1110
	}

	dqp->dq_flags |= XFS_DQ_DIRTY;
1111 1112
	xfs_qm_dqput(dqp);
	return 0;
L
Linus Torvalds 已提交
1113 1114 1115 1116 1117 1118 1119 1120 1121
}

/*
 * callback routine supplied to bulkstat(). Given an inumber, find its
 * dquots and update them to account for resources taken by that inode.
 */
/* ARGSUSED */
STATIC int
xfs_qm_dqusage_adjust(
1122 1123 1124 1125
	struct xfs_mount	*mp,
	struct xfs_trans	*tp,
	xfs_ino_t		ino,
	void			*data)
L
Linus Torvalds 已提交
1126
{
1127 1128 1129 1130
	struct xfs_inode	*ip;
	xfs_qcnt_t		nblks;
	xfs_filblks_t		rtblks = 0;	/* total rt blks */
	int			error;
L
Linus Torvalds 已提交
1131 1132 1133 1134 1135 1136 1137

	ASSERT(XFS_IS_QUOTA_RUNNING(mp));

	/*
	 * rootino must have its resources accounted for, not so with the quota
	 * inodes.
	 */
1138 1139
	if (xfs_is_quota_inode(&mp->m_sb, ino))
		return 0;
L
Linus Torvalds 已提交
1140 1141

	/*
1142 1143
	 * We don't _need_ to take the ilock EXCL here because quotacheck runs
	 * at mount time and therefore nobody will be racing chown/chproj.
L
Linus Torvalds 已提交
1144
	 */
1145 1146 1147 1148
	error = xfs_iget(mp, tp, ino, XFS_IGET_DONTCACHE, 0, &ip);
	if (error == -EINVAL || error == -ENOENT)
		return 0;
	if (error)
1149
		return error;
L
Linus Torvalds 已提交
1150

1151
	ASSERT(ip->i_delayed_blks == 0);
L
Linus Torvalds 已提交
1152

1153
	if (XFS_IS_REALTIME_INODE(ip)) {
1154 1155 1156
		struct xfs_ifork	*ifp = XFS_IFORK_PTR(ip, XFS_DATA_FORK);

		if (!(ifp->if_flags & XFS_IFEXTENTS)) {
1157
			error = xfs_iread_extents(tp, ip, XFS_DATA_FORK);
1158 1159 1160 1161 1162
			if (error)
				goto error0;
		}

		xfs_bmap_count_leaves(ifp, &rtblks);
L
Linus Torvalds 已提交
1163 1164
	}

1165
	nblks = (xfs_qcnt_t)ip->i_d.di_nblocks - rtblks;
L
Linus Torvalds 已提交
1166 1167 1168 1169 1170 1171 1172 1173 1174 1175

	/*
	 * Add the (disk blocks and inode) resources occupied by this
	 * inode to its dquots. We do this adjustment in the incore dquot,
	 * and also copy the changes to its buffer.
	 * We don't care about putting these changes in a transaction
	 * envelope because if we crash in the middle of a 'quotacheck'
	 * we have to start from the beginning anyway.
	 * Once we're done, we'll log all the dquot bufs.
	 *
1176
	 * The *QUOTA_ON checks below may look pretty racy, but quotachecks
L
Linus Torvalds 已提交
1177 1178 1179
	 * and quotaoffs don't race. (Quotachecks happen at mount time only).
	 */
	if (XFS_IS_UQUOTA_ON(mp)) {
1180 1181
		error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_USER, nblks,
				rtblks);
1182 1183
		if (error)
			goto error0;
L
Linus Torvalds 已提交
1184
	}
1185 1186

	if (XFS_IS_GQUOTA_ON(mp)) {
1187 1188
		error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_GROUP, nblks,
				rtblks);
1189 1190
		if (error)
			goto error0;
L
Linus Torvalds 已提交
1191 1192
	}

1193
	if (XFS_IS_PQUOTA_ON(mp)) {
1194 1195
		error = xfs_qm_quotacheck_dqadjust(ip, XFS_DQ_PROJ, nblks,
				rtblks);
1196 1197 1198 1199 1200
		if (error)
			goto error0;
	}

error0:
1201
	xfs_irele(ip);
1202
	return error;
L
Linus Torvalds 已提交
1203 1204
}

1205 1206
STATIC int
xfs_qm_flush_one(
1207 1208
	struct xfs_dquot	*dqp,
	void			*data)
1209
{
1210
	struct xfs_mount	*mp = dqp->q_mount;
1211
	struct list_head	*buffer_list = data;
1212
	struct xfs_buf		*bp = NULL;
1213 1214 1215 1216 1217 1218 1219 1220
	int			error = 0;

	xfs_dqlock(dqp);
	if (dqp->dq_flags & XFS_DQ_FREEING)
		goto out_unlock;
	if (!XFS_DQ_IS_DIRTY(dqp))
		goto out_unlock;

1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	/*
	 * The only way the dquot is already flush locked by the time quotacheck
	 * gets here is if reclaim flushed it before the dqadjust walk dirtied
	 * it for the final time. Quotacheck collects all dquot bufs in the
	 * local delwri queue before dquots are dirtied, so reclaim can't have
	 * possibly queued it for I/O. The only way out is to push the buffer to
	 * cycle the flush lock.
	 */
	if (!xfs_dqflock_nowait(dqp)) {
		/* buf is pinned in-core by delwri list */
1231 1232
		bp = xfs_buf_incore(mp->m_ddev_targp, dqp->q_blkno,
				mp->m_quotainfo->qi_dqchunklen, 0);
1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245
		if (!bp) {
			error = -EINVAL;
			goto out_unlock;
		}
		xfs_buf_unlock(bp);

		xfs_buf_delwri_pushbuf(bp, buffer_list);
		xfs_buf_rele(bp);

		error = -EAGAIN;
		goto out_unlock;
	}

1246 1247 1248
	error = xfs_qm_dqflush(dqp, &bp);
	if (error)
		goto out_unlock;
1249

1250
	xfs_buf_delwri_queue(bp, buffer_list);
1251
	xfs_buf_relse(bp);
1252 1253 1254 1255 1256
out_unlock:
	xfs_dqunlock(dqp);
	return error;
}

L
Linus Torvalds 已提交
1257 1258 1259 1260
/*
 * Walk thru all the filesystem inodes and construct a consistent view
 * of the disk quota world. If the quotacheck fails, disable quotas.
 */
1261
STATIC int
L
Linus Torvalds 已提交
1262 1263 1264
xfs_qm_quotacheck(
	xfs_mount_t	*mp)
{
1265
	int			error, error2;
1266 1267 1268 1269
	uint			flags;
	LIST_HEAD		(buffer_list);
	struct xfs_inode	*uip = mp->m_quotainfo->qi_uquotaip;
	struct xfs_inode	*gip = mp->m_quotainfo->qi_gquotaip;
1270
	struct xfs_inode	*pip = mp->m_quotainfo->qi_pquotaip;
L
Linus Torvalds 已提交
1271 1272 1273

	flags = 0;

1274
	ASSERT(uip || gip || pip);
L
Linus Torvalds 已提交
1275 1276
	ASSERT(XFS_IS_QUOTA_RUNNING(mp));

1277
	xfs_notice(mp, "Quotacheck needed: Please wait.");
L
Linus Torvalds 已提交
1278 1279

	/*
1280
	 * First we go thru all the dquots on disk, USR and GRP/PRJ, and reset
L
Linus Torvalds 已提交
1281 1282 1283
	 * their counters to zero. We need a clean slate.
	 * We don't log our changes till later.
	 */
1284
	if (uip) {
1285
		error = xfs_qm_reset_dqcounts_buf(mp, uip, XFS_QMOPT_UQUOTA,
1286
					 &buffer_list);
1287
		if (error)
L
Linus Torvalds 已提交
1288 1289 1290 1291
			goto error_return;
		flags |= XFS_UQUOTA_CHKD;
	}

1292
	if (gip) {
1293
		error = xfs_qm_reset_dqcounts_buf(mp, gip, XFS_QMOPT_GQUOTA,
1294
					 &buffer_list);
1295
		if (error)
L
Linus Torvalds 已提交
1296
			goto error_return;
1297 1298 1299 1300
		flags |= XFS_GQUOTA_CHKD;
	}

	if (pip) {
1301
		error = xfs_qm_reset_dqcounts_buf(mp, pip, XFS_QMOPT_PQUOTA,
1302 1303 1304 1305
					 &buffer_list);
		if (error)
			goto error_return;
		flags |= XFS_PQUOTA_CHKD;
L
Linus Torvalds 已提交
1306 1307
	}

1308 1309
	error = xfs_iwalk_threaded(mp, 0, 0, xfs_qm_dqusage_adjust, 0, true,
			NULL);
1310 1311
	if (error)
		goto error_return;
L
Linus Torvalds 已提交
1312

1313
	/*
1314 1315
	 * We've made all the changes that we need to make incore.  Flush them
	 * down to disk buffers if everything was updated successfully.
1316
	 */
1317 1318 1319 1320
	if (XFS_IS_UQUOTA_ON(mp)) {
		error = xfs_qm_dquot_walk(mp, XFS_DQ_USER, xfs_qm_flush_one,
					  &buffer_list);
	}
1321
	if (XFS_IS_GQUOTA_ON(mp)) {
1322 1323
		error2 = xfs_qm_dquot_walk(mp, XFS_DQ_GROUP, xfs_qm_flush_one,
					   &buffer_list);
1324 1325 1326 1327
		if (!error)
			error = error2;
	}
	if (XFS_IS_PQUOTA_ON(mp)) {
1328 1329
		error2 = xfs_qm_dquot_walk(mp, XFS_DQ_PROJ, xfs_qm_flush_one,
					   &buffer_list);
1330 1331 1332
		if (!error)
			error = error2;
	}
1333

1334 1335 1336 1337
	error2 = xfs_buf_delwri_submit(&buffer_list);
	if (!error)
		error = error2;

L
Linus Torvalds 已提交
1338 1339 1340 1341 1342 1343 1344 1345
	/*
	 * We can get this error if we couldn't do a dquot allocation inside
	 * xfs_qm_dqusage_adjust (via bulkstat). We don't care about the
	 * dirty dquots that might be cached, we just want to get rid of them
	 * and turn quotaoff. The dquots won't be attached to any of the inodes
	 * at this point (because we intentionally didn't in dqget_noattach).
	 */
	if (error) {
1346
		xfs_qm_dqpurge_all(mp, XFS_QMOPT_QUOTALL);
L
Linus Torvalds 已提交
1347 1348 1349 1350 1351 1352 1353 1354
		goto error_return;
	}

	/*
	 * If one type of quotas is off, then it will lose its
	 * quotachecked status, since we won't be doing accounting for
	 * that type anymore.
	 */
1355
	mp->m_qflags &= ~XFS_ALL_QUOTA_CHKD;
L
Linus Torvalds 已提交
1356 1357 1358
	mp->m_qflags |= flags;

 error_return:
1359
	xfs_buf_delwri_cancel(&buffer_list);
1360

L
Linus Torvalds 已提交
1361
	if (error) {
1362 1363 1364
		xfs_warn(mp,
	"Quotacheck: Unsuccessful (Error %d): Disabling quotas.",
			error);
L
Linus Torvalds 已提交
1365 1366 1367 1368 1369
		/*
		 * We must turn off quotas.
		 */
		ASSERT(mp->m_quotainfo != NULL);
		xfs_qm_destroy_quotainfo(mp);
1370
		if (xfs_mount_reset_sbqflags(mp)) {
1371 1372
			xfs_warn(mp,
				"Quotacheck: Failed to reset quota flags.");
1373
		}
1374 1375
	} else
		xfs_notice(mp, "Quotacheck: Done.");
1376
	return error;
L
Linus Torvalds 已提交
1377 1378
}

1379 1380 1381 1382 1383 1384 1385 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 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452
/*
 * This is called from xfs_mountfs to start quotas and initialize all
 * necessary data structures like quotainfo.  This is also responsible for
 * running a quotacheck as necessary.  We are guaranteed that the superblock
 * is consistently read in at this point.
 *
 * If we fail here, the mount will continue with quota turned off. We don't
 * need to inidicate success or failure at all.
 */
void
xfs_qm_mount_quotas(
	struct xfs_mount	*mp)
{
	int			error = 0;
	uint			sbf;

	/*
	 * If quotas on realtime volumes is not supported, we disable
	 * quotas immediately.
	 */
	if (mp->m_sb.sb_rextents) {
		xfs_notice(mp, "Cannot turn on quotas for realtime filesystem");
		mp->m_qflags = 0;
		goto write_changes;
	}

	ASSERT(XFS_IS_QUOTA_RUNNING(mp));

	/*
	 * Allocate the quotainfo structure inside the mount struct, and
	 * create quotainode(s), and change/rev superblock if necessary.
	 */
	error = xfs_qm_init_quotainfo(mp);
	if (error) {
		/*
		 * We must turn off quotas.
		 */
		ASSERT(mp->m_quotainfo == NULL);
		mp->m_qflags = 0;
		goto write_changes;
	}
	/*
	 * If any of the quotas are not consistent, do a quotacheck.
	 */
	if (XFS_QM_NEED_QUOTACHECK(mp)) {
		error = xfs_qm_quotacheck(mp);
		if (error) {
			/* Quotacheck failed and disabled quotas. */
			return;
		}
	}
	/*
	 * If one type of quotas is off, then it will lose its
	 * quotachecked status, since we won't be doing accounting for
	 * that type anymore.
	 */
	if (!XFS_IS_UQUOTA_ON(mp))
		mp->m_qflags &= ~XFS_UQUOTA_CHKD;
	if (!XFS_IS_GQUOTA_ON(mp))
		mp->m_qflags &= ~XFS_GQUOTA_CHKD;
	if (!XFS_IS_PQUOTA_ON(mp))
		mp->m_qflags &= ~XFS_PQUOTA_CHKD;

 write_changes:
	/*
	 * We actually don't have to acquire the m_sb_lock at all.
	 * This can only be called from mount, and that's single threaded. XXX
	 */
	spin_lock(&mp->m_sb_lock);
	sbf = mp->m_sb.sb_qflags;
	mp->m_sb.sb_qflags = mp->m_qflags & XFS_MOUNT_QUOTA_ALL;
	spin_unlock(&mp->m_sb_lock);

	if (sbf != (mp->m_qflags & XFS_MOUNT_QUOTA_ALL)) {
1453
		if (xfs_sync_sb(mp, false)) {
1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471
			/*
			 * We could only have been turning quotas off.
			 * We aren't in very good shape actually because
			 * the incore structures are convinced that quotas are
			 * off, but the on disk superblock doesn't know that !
			 */
			ASSERT(!(XFS_IS_QUOTA_RUNNING(mp)));
			xfs_alert(mp, "%s: Superblock update failed!",
				__func__);
		}
	}

	if (error) {
		xfs_warn(mp, "Failed to initialize disk quotas.");
		return;
	}
}

L
Linus Torvalds 已提交
1472 1473 1474 1475 1476 1477 1478 1479
/*
 * This is called after the superblock has been read in and we're ready to
 * iget the quota inodes.
 */
STATIC int
xfs_qm_init_quotainos(
	xfs_mount_t	*mp)
{
1480 1481
	struct xfs_inode	*uip = NULL;
	struct xfs_inode	*gip = NULL;
1482
	struct xfs_inode	*pip = NULL;
1483 1484
	int			error;
	uint			flags = 0;
L
Linus Torvalds 已提交
1485 1486 1487 1488 1489 1490

	ASSERT(mp->m_quotainfo);

	/*
	 * Get the uquota and gquota inodes
	 */
1491
	if (xfs_sb_version_hasquota(&mp->m_sb)) {
L
Linus Torvalds 已提交
1492 1493 1494
		if (XFS_IS_UQUOTA_ON(mp) &&
		    mp->m_sb.sb_uquotino != NULLFSINO) {
			ASSERT(mp->m_sb.sb_uquotino > 0);
1495 1496 1497
			error = xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
					     0, 0, &uip);
			if (error)
E
Eric Sandeen 已提交
1498
				return error;
L
Linus Torvalds 已提交
1499
		}
1500
		if (XFS_IS_GQUOTA_ON(mp) &&
L
Linus Torvalds 已提交
1501 1502
		    mp->m_sb.sb_gquotino != NULLFSINO) {
			ASSERT(mp->m_sb.sb_gquotino > 0);
1503 1504 1505 1506
			error = xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
					     0, 0, &gip);
			if (error)
				goto error_rele;
L
Linus Torvalds 已提交
1507
		}
1508
		if (XFS_IS_PQUOTA_ON(mp) &&
1509 1510 1511
		    mp->m_sb.sb_pquotino != NULLFSINO) {
			ASSERT(mp->m_sb.sb_pquotino > 0);
			error = xfs_iget(mp, NULL, mp->m_sb.sb_pquotino,
1512 1513 1514 1515
					     0, 0, &pip);
			if (error)
				goto error_rele;
		}
L
Linus Torvalds 已提交
1516 1517 1518 1519 1520
	} else {
		flags |= XFS_QMOPT_SBVERSION;
	}

	/*
1521
	 * Create the three inodes, if they don't exist already. The changes
L
Linus Torvalds 已提交
1522 1523 1524 1525 1526
	 * made above will get added to a transaction and logged in one of
	 * the qino_alloc calls below.  If the device is readonly,
	 * temporarily switch to read-write to do this.
	 */
	if (XFS_IS_UQUOTA_ON(mp) && uip == NULL) {
1527 1528 1529 1530
		error = xfs_qm_qino_alloc(mp, &uip,
					      flags | XFS_QMOPT_UQUOTA);
		if (error)
			goto error_rele;
L
Linus Torvalds 已提交
1531 1532 1533

		flags &= ~XFS_QMOPT_SBVERSION;
	}
1534
	if (XFS_IS_GQUOTA_ON(mp) && gip == NULL) {
1535
		error = xfs_qm_qino_alloc(mp, &gip,
1536 1537 1538 1539 1540 1541 1542 1543 1544
					  flags | XFS_QMOPT_GQUOTA);
		if (error)
			goto error_rele;

		flags &= ~XFS_QMOPT_SBVERSION;
	}
	if (XFS_IS_PQUOTA_ON(mp) && pip == NULL) {
		error = xfs_qm_qino_alloc(mp, &pip,
					  flags | XFS_QMOPT_PQUOTA);
1545 1546
		if (error)
			goto error_rele;
L
Linus Torvalds 已提交
1547 1548
	}

1549 1550
	mp->m_quotainfo->qi_uquotaip = uip;
	mp->m_quotainfo->qi_gquotaip = gip;
1551
	mp->m_quotainfo->qi_pquotaip = pip;
L
Linus Torvalds 已提交
1552

1553
	return 0;
1554 1555 1556

error_rele:
	if (uip)
1557
		xfs_irele(uip);
1558
	if (gip)
1559
		xfs_irele(gip);
1560
	if (pip)
1561
		xfs_irele(pip);
E
Eric Sandeen 已提交
1562
	return error;
L
Linus Torvalds 已提交
1563 1564
}

1565 1566
STATIC void
xfs_qm_destroy_quotainos(
1567
	struct xfs_quotainfo	*qi)
1568 1569
{
	if (qi->qi_uquotaip) {
1570
		xfs_irele(qi->qi_uquotaip);
1571 1572 1573
		qi->qi_uquotaip = NULL; /* paranoia */
	}
	if (qi->qi_gquotaip) {
1574
		xfs_irele(qi->qi_gquotaip);
1575 1576 1577
		qi->qi_gquotaip = NULL;
	}
	if (qi->qi_pquotaip) {
1578
		xfs_irele(qi->qi_pquotaip);
1579 1580 1581 1582
		qi->qi_pquotaip = NULL;
	}
}

1583 1584 1585 1586 1587 1588
STATIC void
xfs_qm_dqfree_one(
	struct xfs_dquot	*dqp)
{
	struct xfs_mount	*mp = dqp->q_mount;
	struct xfs_quotainfo	*qi = mp->m_quotainfo;
L
Linus Torvalds 已提交
1589

1590
	mutex_lock(&qi->qi_tree_lock);
1591
	radix_tree_delete(xfs_dquot_tree(qi, dqp->q_core.d_flags),
1592
			  be32_to_cpu(dqp->q_core.d_id));
1593

1594
	qi->qi_dquots--;
1595
	mutex_unlock(&qi->qi_tree_lock);
1596 1597 1598 1599

	xfs_qm_dqdestroy(dqp);
}

L
Linus Torvalds 已提交
1600 1601 1602 1603
/* --------------- utility functions for vnodeops ---------------- */


/*
1604
 * Given an inode, a uid, gid and prid make sure that we have
L
Linus Torvalds 已提交
1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
 * allocated relevant dquot(s) on disk, and that we won't exceed inode
 * quotas by creating this file.
 * This also attaches dquot(s) to the given inode after locking it,
 * and returns the dquots corresponding to the uid and/or gid.
 *
 * in	: inode (unlocked)
 * out	: udquot, gdquot with references taken and unlocked
 */
int
xfs_qm_vop_dqalloc(
C
Christoph Hellwig 已提交
1615
	struct xfs_inode	*ip,
1616 1617
	xfs_dqid_t		uid,
	xfs_dqid_t		gid,
C
Christoph Hellwig 已提交
1618 1619 1620
	prid_t			prid,
	uint			flags,
	struct xfs_dquot	**O_udqpp,
1621 1622
	struct xfs_dquot	**O_gdqpp,
	struct xfs_dquot	**O_pdqpp)
L
Linus Torvalds 已提交
1623
{
C
Christoph Hellwig 已提交
1624
	struct xfs_mount	*mp = ip->i_mount;
1625 1626
	struct xfs_dquot	*uq = NULL;
	struct xfs_dquot	*gq = NULL;
1627
	struct xfs_dquot	*pq = NULL;
C
Christoph Hellwig 已提交
1628 1629
	int			error;
	uint			lockflags;
L
Linus Torvalds 已提交
1630

C
Christoph Hellwig 已提交
1631
	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
L
Linus Torvalds 已提交
1632 1633 1634 1635 1636
		return 0;

	lockflags = XFS_ILOCK_EXCL;
	xfs_ilock(ip, lockflags);

1637
	if ((flags & XFS_QMOPT_INHERIT) && XFS_INHERIT_GID(ip))
L
Linus Torvalds 已提交
1638 1639 1640 1641 1642 1643 1644
		gid = ip->i_d.di_gid;

	/*
	 * Attach the dquot(s) to this inode, doing a dquot allocation
	 * if necessary. The dquot(s) will not be locked.
	 */
	if (XFS_NOT_DQATTACHED(mp, ip)) {
1645
		error = xfs_qm_dqattach_locked(ip, true);
C
Christoph Hellwig 已提交
1646
		if (error) {
L
Linus Torvalds 已提交
1647
			xfs_iunlock(ip, lockflags);
1648
			return error;
L
Linus Torvalds 已提交
1649 1650 1651
		}
	}

1652
	if ((flags & XFS_QMOPT_UQUOTA) && XFS_IS_UQUOTA_ON(mp)) {
L
Linus Torvalds 已提交
1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
		if (ip->i_d.di_uid != uid) {
			/*
			 * What we need is the dquot that has this uid, and
			 * if we send the inode to dqget, the uid of the inode
			 * takes priority over what's sent in the uid argument.
			 * We must unlock inode here before calling dqget if
			 * we're not sending the inode, because otherwise
			 * we'll deadlock by doing trans_reserve while
			 * holding ilock.
			 */
			xfs_iunlock(ip, lockflags);
1664
			error = xfs_qm_dqget(mp, uid, XFS_DQ_USER, true, &uq);
1665
			if (error) {
1666
				ASSERT(error != -ENOENT);
1667
				return error;
L
Linus Torvalds 已提交
1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
			}
			/*
			 * Get the ilock in the right order.
			 */
			xfs_dqunlock(uq);
			lockflags = XFS_ILOCK_SHARED;
			xfs_ilock(ip, lockflags);
		} else {
			/*
			 * Take an extra reference, because we'll return
			 * this to caller
			 */
			ASSERT(ip->i_udquot);
1681
			uq = xfs_qm_dqhold(ip->i_udquot);
L
Linus Torvalds 已提交
1682 1683
		}
	}
1684
	if ((flags & XFS_QMOPT_GQUOTA) && XFS_IS_GQUOTA_ON(mp)) {
L
Linus Torvalds 已提交
1685 1686
		if (ip->i_d.di_gid != gid) {
			xfs_iunlock(ip, lockflags);
1687
			error = xfs_qm_dqget(mp, gid, XFS_DQ_GROUP, true, &gq);
1688
			if (error) {
1689
				ASSERT(error != -ENOENT);
1690
				goto error_rele;
L
Linus Torvalds 已提交
1691 1692 1693 1694 1695 1696
			}
			xfs_dqunlock(gq);
			lockflags = XFS_ILOCK_SHARED;
			xfs_ilock(ip, lockflags);
		} else {
			ASSERT(ip->i_gdquot);
1697
			gq = xfs_qm_dqhold(ip->i_gdquot);
L
Linus Torvalds 已提交
1698
		}
1699 1700
	}
	if ((flags & XFS_QMOPT_PQUOTA) && XFS_IS_PQUOTA_ON(mp)) {
1701
		if (ip->i_d.di_projid != prid) {
1702
			xfs_iunlock(ip, lockflags);
1703
			error = xfs_qm_dqget(mp, (xfs_dqid_t)prid, XFS_DQ_PROJ,
1704
					true, &pq);
1705
			if (error) {
1706
				ASSERT(error != -ENOENT);
1707
				goto error_rele;
1708
			}
1709
			xfs_dqunlock(pq);
1710 1711 1712
			lockflags = XFS_ILOCK_SHARED;
			xfs_ilock(ip, lockflags);
		} else {
1713 1714
			ASSERT(ip->i_pdquot);
			pq = xfs_qm_dqhold(ip->i_pdquot);
1715
		}
L
Linus Torvalds 已提交
1716 1717
	}
	if (uq)
1718
		trace_xfs_dquot_dqalloc(ip);
L
Linus Torvalds 已提交
1719 1720 1721 1722

	xfs_iunlock(ip, lockflags);
	if (O_udqpp)
		*O_udqpp = uq;
1723
	else
L
Linus Torvalds 已提交
1724 1725 1726
		xfs_qm_dqrele(uq);
	if (O_gdqpp)
		*O_gdqpp = gq;
1727
	else
L
Linus Torvalds 已提交
1728
		xfs_qm_dqrele(gq);
1729 1730
	if (O_pdqpp)
		*O_pdqpp = pq;
1731
	else
1732
		xfs_qm_dqrele(pq);
1733
	return 0;
1734 1735

error_rele:
1736 1737
	xfs_qm_dqrele(gq);
	xfs_qm_dqrele(uq);
1738
	return error;
L
Linus Torvalds 已提交
1739 1740 1741 1742 1743 1744
}

/*
 * Actually transfer ownership, and do dquot modifications.
 * These were already reserved.
 */
1745
struct xfs_dquot *
L
Linus Torvalds 已提交
1746
xfs_qm_vop_chown(
1747 1748 1749 1750
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	struct xfs_dquot	**IO_olddq,
	struct xfs_dquot	*newdq)
L
Linus Torvalds 已提交
1751
{
1752
	struct xfs_dquot	*prevdq;
1753 1754 1755
	uint		bfield = XFS_IS_REALTIME_INODE(ip) ?
				 XFS_TRANS_DQ_RTBCOUNT : XFS_TRANS_DQ_BCOUNT;

C
Christoph Hellwig 已提交
1756

C
Christoph Hellwig 已提交
1757
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
L
Linus Torvalds 已提交
1758 1759 1760 1761 1762 1763 1764
	ASSERT(XFS_IS_QUOTA_RUNNING(ip->i_mount));

	/* old dquot */
	prevdq = *IO_olddq;
	ASSERT(prevdq);
	ASSERT(prevdq != newdq);

1765 1766
	xfs_trans_mod_dquot(tp, prevdq, bfield, -(ip->i_d.di_nblocks));
	xfs_trans_mod_dquot(tp, prevdq, XFS_TRANS_DQ_ICOUNT, -1);
L
Linus Torvalds 已提交
1767 1768

	/* the sparkling new dquot */
1769 1770
	xfs_trans_mod_dquot(tp, newdq, bfield, ip->i_d.di_nblocks);
	xfs_trans_mod_dquot(tp, newdq, XFS_TRANS_DQ_ICOUNT, 1);
L
Linus Torvalds 已提交
1771 1772

	/*
1773 1774
	 * Take an extra reference, because the inode is going to keep
	 * this dquot pointer even after the trans_commit.
L
Linus Torvalds 已提交
1775
	 */
1776
	*IO_olddq = xfs_qm_dqhold(newdq);
L
Linus Torvalds 已提交
1777

1778
	return prevdq;
L
Linus Torvalds 已提交
1779 1780 1781
}

/*
1782
 * Quota reservations for setattr(AT_UID|AT_GID|AT_PROJID).
L
Linus Torvalds 已提交
1783 1784 1785
 */
int
xfs_qm_vop_chown_reserve(
1786 1787 1788 1789
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	struct xfs_dquot	*udqp,
	struct xfs_dquot	*gdqp,
1790
	struct xfs_dquot	*pdqp,
1791
	uint			flags)
L
Linus Torvalds 已提交
1792
{
1793
	struct xfs_mount	*mp = ip->i_mount;
1794 1795
	uint64_t		delblks;
	unsigned int		blkflags, prjflags = 0;
1796 1797
	struct xfs_dquot	*udq_unres = NULL;
	struct xfs_dquot	*gdq_unres = NULL;
1798
	struct xfs_dquot	*pdq_unres = NULL;
1799 1800
	struct xfs_dquot	*udq_delblks = NULL;
	struct xfs_dquot	*gdq_delblks = NULL;
1801
	struct xfs_dquot	*pdq_delblks = NULL;
1802
	int			error;
C
Christoph Hellwig 已提交
1803

L
Linus Torvalds 已提交
1804

C
Christoph Hellwig 已提交
1805
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL|XFS_ILOCK_SHARED));
L
Linus Torvalds 已提交
1806 1807 1808
	ASSERT(XFS_IS_QUOTA_RUNNING(mp));

	delblks = ip->i_delayed_blks;
1809 1810
	blkflags = XFS_IS_REALTIME_INODE(ip) ?
			XFS_QMOPT_RES_RTBLKS : XFS_QMOPT_RES_REGBLKS;
L
Linus Torvalds 已提交
1811 1812

	if (XFS_IS_UQUOTA_ON(mp) && udqp &&
1813
	    ip->i_d.di_uid != be32_to_cpu(udqp->q_core.d_id)) {
1814
		udq_delblks = udqp;
L
Linus Torvalds 已提交
1815 1816 1817 1818 1819 1820 1821
		/*
		 * If there are delayed allocation blocks, then we have to
		 * unreserve those from the old dquot, and add them to the
		 * new dquot.
		 */
		if (delblks) {
			ASSERT(ip->i_udquot);
1822
			udq_unres = ip->i_udquot;
L
Linus Torvalds 已提交
1823 1824
		}
	}
1825 1826 1827 1828 1829 1830 1831 1832 1833 1834
	if (XFS_IS_GQUOTA_ON(ip->i_mount) && gdqp &&
	    ip->i_d.di_gid != be32_to_cpu(gdqp->q_core.d_id)) {
		gdq_delblks = gdqp;
		if (delblks) {
			ASSERT(ip->i_gdquot);
			gdq_unres = ip->i_gdquot;
		}
	}

	if (XFS_IS_PQUOTA_ON(ip->i_mount) && pdqp &&
1835
	    ip->i_d.di_projid != be32_to_cpu(pdqp->q_core.d_id)) {
1836 1837 1838 1839 1840
		prjflags = XFS_QMOPT_ENOSPC;
		pdq_delblks = pdqp;
		if (delblks) {
			ASSERT(ip->i_pdquot);
			pdq_unres = ip->i_pdquot;
L
Linus Torvalds 已提交
1841 1842 1843
		}
	}

1844
	error = xfs_trans_reserve_quota_bydquots(tp, ip->i_mount,
1845 1846
				udq_delblks, gdq_delblks, pdq_delblks,
				ip->i_d.di_nblocks, 1,
1847 1848 1849
				flags | blkflags | prjflags);
	if (error)
		return error;
L
Linus Torvalds 已提交
1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860

	/*
	 * Do the delayed blks reservations/unreservations now. Since, these
	 * are done without the help of a transaction, if a reservation fails
	 * its previous reservations won't be automatically undone by trans
	 * code. So, we have to do it manually here.
	 */
	if (delblks) {
		/*
		 * Do the reservations first. Unreservation can't fail.
		 */
1861 1862
		ASSERT(udq_delblks || gdq_delblks || pdq_delblks);
		ASSERT(udq_unres || gdq_unres || pdq_unres);
1863
		error = xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
1864 1865
			    udq_delblks, gdq_delblks, pdq_delblks,
			    (xfs_qcnt_t)delblks, 0,
1866 1867 1868
			    flags | blkflags | prjflags);
		if (error)
			return error;
L
Linus Torvalds 已提交
1869
		xfs_trans_reserve_quota_bydquots(NULL, ip->i_mount,
1870 1871
				udq_unres, gdq_unres, pdq_unres,
				-((xfs_qcnt_t)delblks), 0, blkflags);
L
Linus Torvalds 已提交
1872 1873
	}

1874
	return 0;
L
Linus Torvalds 已提交
1875 1876 1877 1878
}

int
xfs_qm_vop_rename_dqattach(
C
Christoph Hellwig 已提交
1879
	struct xfs_inode	**i_tab)
L
Linus Torvalds 已提交
1880
{
C
Christoph Hellwig 已提交
1881 1882
	struct xfs_mount	*mp = i_tab[0]->i_mount;
	int			i;
L
Linus Torvalds 已提交
1883

C
Christoph Hellwig 已提交
1884
	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
1885
		return 0;
L
Linus Torvalds 已提交
1886

C
Christoph Hellwig 已提交
1887 1888 1889 1890
	for (i = 0; (i < 4 && i_tab[i]); i++) {
		struct xfs_inode	*ip = i_tab[i];
		int			error;

L
Linus Torvalds 已提交
1891 1892 1893
		/*
		 * Watch out for duplicate entries in the table.
		 */
C
Christoph Hellwig 已提交
1894 1895
		if (i == 0 || ip != i_tab[i-1]) {
			if (XFS_NOT_DQATTACHED(mp, ip)) {
1896
				error = xfs_qm_dqattach(ip);
L
Linus Torvalds 已提交
1897
				if (error)
1898
					return error;
L
Linus Torvalds 已提交
1899 1900 1901
			}
		}
	}
1902
	return 0;
L
Linus Torvalds 已提交
1903 1904 1905
}

void
C
Christoph Hellwig 已提交
1906 1907 1908 1909
xfs_qm_vop_create_dqattach(
	struct xfs_trans	*tp,
	struct xfs_inode	*ip,
	struct xfs_dquot	*udqp,
1910 1911
	struct xfs_dquot	*gdqp,
	struct xfs_dquot	*pdqp)
L
Linus Torvalds 已提交
1912
{
C
Christoph Hellwig 已提交
1913 1914 1915
	struct xfs_mount	*mp = tp->t_mountp;

	if (!XFS_IS_QUOTA_RUNNING(mp) || !XFS_IS_QUOTA_ON(mp))
L
Linus Torvalds 已提交
1916 1917
		return;

C
Christoph Hellwig 已提交
1918
	ASSERT(xfs_isilocked(ip, XFS_ILOCK_EXCL));
C
Christoph Hellwig 已提交
1919
	ASSERT(XFS_IS_QUOTA_RUNNING(mp));
L
Linus Torvalds 已提交
1920

1921
	if (udqp && XFS_IS_UQUOTA_ON(mp)) {
L
Linus Torvalds 已提交
1922
		ASSERT(ip->i_udquot == NULL);
1923
		ASSERT(ip->i_d.di_uid == be32_to_cpu(udqp->q_core.d_id));
1924 1925

		ip->i_udquot = xfs_qm_dqhold(udqp);
L
Linus Torvalds 已提交
1926 1927
		xfs_trans_mod_dquot(tp, udqp, XFS_TRANS_DQ_ICOUNT, 1);
	}
1928
	if (gdqp && XFS_IS_GQUOTA_ON(mp)) {
L
Linus Torvalds 已提交
1929
		ASSERT(ip->i_gdquot == NULL);
1930
		ASSERT(ip->i_d.di_gid == be32_to_cpu(gdqp->q_core.d_id));
1931
		ip->i_gdquot = xfs_qm_dqhold(gdqp);
L
Linus Torvalds 已提交
1932 1933
		xfs_trans_mod_dquot(tp, gdqp, XFS_TRANS_DQ_ICOUNT, 1);
	}
1934
	if (pdqp && XFS_IS_PQUOTA_ON(mp)) {
1935
		ASSERT(ip->i_pdquot == NULL);
1936
		ASSERT(ip->i_d.di_projid == be32_to_cpu(pdqp->q_core.d_id));
1937 1938 1939 1940

		ip->i_pdquot = xfs_qm_dqhold(pdqp);
		xfs_trans_mod_dquot(tp, pdqp, XFS_TRANS_DQ_ICOUNT, 1);
	}
L
Linus Torvalds 已提交
1941 1942
}
新手
引导
客服 返回
顶部