Linux Audio

Check our new training course

Loading...
v6.9.4
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2002 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.h"
   8#include "xfs_shared.h"
   9#include "xfs_format.h"
  10#include "xfs_log_format.h"
  11#include "xfs_trans_resv.h"
  12#include "xfs_mount.h"
  13#include "xfs_inode.h"
  14#include "xfs_trans.h"
  15#include "xfs_trans_priv.h"
  16#include "xfs_quota.h"
  17#include "xfs_qm.h"
  18#include "xfs_trace.h"
  19#include "xfs_error.h"
  20#include "xfs_health.h"
  21
  22STATIC void	xfs_trans_alloc_dqinfo(xfs_trans_t *);
  23
  24/*
  25 * Add the locked dquot to the transaction.
  26 * The dquot must be locked, and it cannot be associated with any
  27 * transaction.
  28 */
  29void
  30xfs_trans_dqjoin(
  31	struct xfs_trans	*tp,
  32	struct xfs_dquot	*dqp)
  33{
  34	ASSERT(XFS_DQ_IS_LOCKED(dqp));
  35	ASSERT(dqp->q_logitem.qli_dquot == dqp);
  36
  37	/*
  38	 * Get a log_item_desc to point at the new item.
  39	 */
  40	xfs_trans_add_item(tp, &dqp->q_logitem.qli_item);
  41}
  42
  43/*
  44 * This is called to mark the dquot as needing
  45 * to be logged when the transaction is committed.  The dquot must
  46 * already be associated with the given transaction.
  47 * Note that it marks the entire transaction as dirty. In the ordinary
  48 * case, this gets called via xfs_trans_commit, after the transaction
  49 * is already dirty. However, there's nothing stop this from getting
  50 * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY
  51 * flag.
  52 */
  53void
  54xfs_trans_log_dquot(
  55	struct xfs_trans	*tp,
  56	struct xfs_dquot	*dqp)
  57{
  58	ASSERT(XFS_DQ_IS_LOCKED(dqp));
  59
  60	/* Upgrade the dquot to bigtime format if possible. */
  61	if (dqp->q_id != 0 &&
  62	    xfs_has_bigtime(tp->t_mountp) &&
  63	    !(dqp->q_type & XFS_DQTYPE_BIGTIME))
  64		dqp->q_type |= XFS_DQTYPE_BIGTIME;
  65
  66	tp->t_flags |= XFS_TRANS_DIRTY;
  67	set_bit(XFS_LI_DIRTY, &dqp->q_logitem.qli_item.li_flags);
  68}
  69
  70/*
  71 * Carry forward whatever is left of the quota blk reservation to
  72 * the spanky new transaction
  73 */
  74void
  75xfs_trans_dup_dqinfo(
  76	struct xfs_trans	*otp,
  77	struct xfs_trans	*ntp)
  78{
  79	struct xfs_dqtrx	*oq, *nq;
  80	int			i, j;
  81	struct xfs_dqtrx	*oqa, *nqa;
  82	uint64_t		blk_res_used;
  83
  84	if (!otp->t_dqinfo)
  85		return;
  86
  87	xfs_trans_alloc_dqinfo(ntp);
  88
  89	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
  90		oqa = otp->t_dqinfo->dqs[j];
  91		nqa = ntp->t_dqinfo->dqs[j];
  92		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
  93			blk_res_used = 0;
  94
  95			if (oqa[i].qt_dquot == NULL)
  96				break;
  97			oq = &oqa[i];
  98			nq = &nqa[i];
  99
 100			if (oq->qt_blk_res && oq->qt_bcount_delta > 0)
 101				blk_res_used = oq->qt_bcount_delta;
 102
 103			nq->qt_dquot = oq->qt_dquot;
 104			nq->qt_bcount_delta = nq->qt_icount_delta = 0;
 105			nq->qt_rtbcount_delta = 0;
 106
 107			/*
 108			 * Transfer whatever is left of the reservations.
 109			 */
 110			nq->qt_blk_res = oq->qt_blk_res - blk_res_used;
 111			oq->qt_blk_res = blk_res_used;
 112
 113			nq->qt_rtblk_res = oq->qt_rtblk_res -
 114				oq->qt_rtblk_res_used;
 115			oq->qt_rtblk_res = oq->qt_rtblk_res_used;
 116
 117			nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used;
 118			oq->qt_ino_res = oq->qt_ino_res_used;
 119
 120		}
 121	}
 122}
 123
 124#ifdef CONFIG_XFS_LIVE_HOOKS
 125/*
 126 * Use a static key here to reduce the overhead of quota live updates.  If the
 127 * compiler supports jump labels, the static branch will be replaced by a nop
 128 * sled when there are no hook users.  Online fsck is currently the only
 129 * caller, so this is a reasonable tradeoff.
 130 *
 131 * Note: Patching the kernel code requires taking the cpu hotplug lock.  Other
 132 * parts of the kernel allocate memory with that lock held, which means that
 133 * XFS callers cannot hold any locks that might be used by memory reclaim or
 134 * writeback when calling the static_branch_{inc,dec} functions.
 135 */
 136DEFINE_STATIC_XFS_HOOK_SWITCH(xfs_dqtrx_hooks_switch);
 137
 138void
 139xfs_dqtrx_hook_disable(void)
 140{
 141	xfs_hooks_switch_off(&xfs_dqtrx_hooks_switch);
 142}
 143
 144void
 145xfs_dqtrx_hook_enable(void)
 146{
 147	xfs_hooks_switch_on(&xfs_dqtrx_hooks_switch);
 148}
 149
 150/* Schedule a transactional dquot update on behalf of an inode. */
 151void
 152xfs_trans_mod_ino_dquot(
 153	struct xfs_trans		*tp,
 154	struct xfs_inode		*ip,
 155	struct xfs_dquot		*dqp,
 156	unsigned int			field,
 157	int64_t				delta)
 158{
 
 
 159	xfs_trans_mod_dquot(tp, dqp, field, delta);
 160
 161	if (xfs_hooks_switched_on(&xfs_dqtrx_hooks_switch)) {
 162		struct xfs_mod_ino_dqtrx_params	p = {
 163			.tx_id		= (uintptr_t)tp,
 164			.ino		= ip->i_ino,
 165			.q_type		= xfs_dquot_type(dqp),
 166			.q_id		= dqp->q_id,
 167			.delta		= delta
 168		};
 169		struct xfs_quotainfo	*qi = tp->t_mountp->m_quotainfo;
 170
 171		xfs_hooks_call(&qi->qi_mod_ino_dqtrx_hooks, field, &p);
 172	}
 173}
 174
 175/* Call the specified functions during a dquot counter update. */
 176int
 177xfs_dqtrx_hook_add(
 178	struct xfs_quotainfo	*qi,
 179	struct xfs_dqtrx_hook	*hook)
 180{
 181	int			error;
 182
 183	/*
 184	 * Transactional dquot updates first call the mod hook when changes
 185	 * are attached to the transaction and then call the apply hook when
 186	 * those changes are committed (or canceled).
 187	 *
 188	 * The apply hook must be installed before the mod hook so that we
 189	 * never fail to catch the end of a quota update sequence.
 190	 */
 191	error = xfs_hooks_add(&qi->qi_apply_dqtrx_hooks, &hook->apply_hook);
 192	if (error)
 193		goto out;
 194
 195	error = xfs_hooks_add(&qi->qi_mod_ino_dqtrx_hooks, &hook->mod_hook);
 196	if (error)
 197		goto out_apply;
 198
 199	return 0;
 200
 201out_apply:
 202	xfs_hooks_del(&qi->qi_apply_dqtrx_hooks, &hook->apply_hook);
 203out:
 204	return error;
 205}
 206
 207/* Stop calling the specified function during a dquot counter update. */
 208void
 209xfs_dqtrx_hook_del(
 210	struct xfs_quotainfo	*qi,
 211	struct xfs_dqtrx_hook	*hook)
 212{
 213	/*
 214	 * The mod hook must be removed before apply hook to avoid giving the
 215	 * hook consumer with an incomplete update.  No hooks should be running
 216	 * after these functions return.
 217	 */
 218	xfs_hooks_del(&qi->qi_mod_ino_dqtrx_hooks, &hook->mod_hook);
 219	xfs_hooks_del(&qi->qi_apply_dqtrx_hooks, &hook->apply_hook);
 220}
 221
 222/* Configure dquot update hook functions. */
 223void
 224xfs_dqtrx_hook_setup(
 225	struct xfs_dqtrx_hook	*hook,
 226	notifier_fn_t		mod_fn,
 227	notifier_fn_t		apply_fn)
 228{
 229	xfs_hook_setup(&hook->mod_hook, mod_fn);
 230	xfs_hook_setup(&hook->apply_hook, apply_fn);
 231}
 232#endif /* CONFIG_XFS_LIVE_HOOKS */
 233
 234/*
 235 * Wrap around mod_dquot to account for both user and group quotas.
 236 */
 237void
 238xfs_trans_mod_dquot_byino(
 239	xfs_trans_t	*tp,
 240	xfs_inode_t	*ip,
 241	uint		field,
 242	int64_t		delta)
 243{
 244	xfs_mount_t	*mp = tp->t_mountp;
 245
 246	if (!XFS_IS_QUOTA_ON(mp) ||
 247	    xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
 248		return;
 249
 
 
 250	if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot)
 251		xfs_trans_mod_ino_dquot(tp, ip, ip->i_udquot, field, delta);
 252	if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot)
 253		xfs_trans_mod_ino_dquot(tp, ip, ip->i_gdquot, field, delta);
 254	if (XFS_IS_PQUOTA_ON(mp) && ip->i_pdquot)
 255		xfs_trans_mod_ino_dquot(tp, ip, ip->i_pdquot, field, delta);
 256}
 257
 258STATIC struct xfs_dqtrx *
 259xfs_trans_get_dqtrx(
 260	struct xfs_trans	*tp,
 261	struct xfs_dquot	*dqp)
 262{
 263	int			i;
 264	struct xfs_dqtrx	*qa;
 265
 266	switch (xfs_dquot_type(dqp)) {
 267	case XFS_DQTYPE_USER:
 268		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR];
 269		break;
 270	case XFS_DQTYPE_GROUP:
 271		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP];
 272		break;
 273	case XFS_DQTYPE_PROJ:
 274		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_PRJ];
 275		break;
 276	default:
 277		return NULL;
 278	}
 279
 280	for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 281		if (qa[i].qt_dquot == NULL ||
 282		    qa[i].qt_dquot == dqp)
 283			return &qa[i];
 284	}
 285
 286	return NULL;
 287}
 288
 289/*
 290 * Make the changes in the transaction structure.
 291 * The moral equivalent to xfs_trans_mod_sb().
 292 * We don't touch any fields in the dquot, so we don't care
 293 * if it's locked or not (most of the time it won't be).
 294 */
 295void
 296xfs_trans_mod_dquot(
 297	struct xfs_trans	*tp,
 298	struct xfs_dquot	*dqp,
 299	uint			field,
 300	int64_t			delta)
 301{
 302	struct xfs_dqtrx	*qtrx;
 303
 304	ASSERT(tp);
 305	ASSERT(XFS_IS_QUOTA_ON(tp->t_mountp));
 306	qtrx = NULL;
 307
 308	if (!delta)
 309		return;
 310
 311	if (tp->t_dqinfo == NULL)
 312		xfs_trans_alloc_dqinfo(tp);
 313	/*
 314	 * Find either the first free slot or the slot that belongs
 315	 * to this dquot.
 316	 */
 317	qtrx = xfs_trans_get_dqtrx(tp, dqp);
 318	ASSERT(qtrx);
 319	if (qtrx->qt_dquot == NULL)
 320		qtrx->qt_dquot = dqp;
 321
 322	trace_xfs_trans_mod_dquot_before(qtrx);
 323	trace_xfs_trans_mod_dquot(tp, dqp, field, delta);
 324
 325	switch (field) {
 326	/* regular disk blk reservation */
 327	case XFS_TRANS_DQ_RES_BLKS:
 328		qtrx->qt_blk_res += delta;
 329		break;
 330
 331	/* inode reservation */
 332	case XFS_TRANS_DQ_RES_INOS:
 333		qtrx->qt_ino_res += delta;
 334		break;
 335
 336	/* disk blocks used. */
 337	case XFS_TRANS_DQ_BCOUNT:
 338		qtrx->qt_bcount_delta += delta;
 339		break;
 340
 341	case XFS_TRANS_DQ_DELBCOUNT:
 342		qtrx->qt_delbcnt_delta += delta;
 343		break;
 344
 345	/* Inode Count */
 346	case XFS_TRANS_DQ_ICOUNT:
 347		if (qtrx->qt_ino_res && delta > 0) {
 348			qtrx->qt_ino_res_used += delta;
 349			ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
 350		}
 351		qtrx->qt_icount_delta += delta;
 352		break;
 353
 354	/* rtblk reservation */
 355	case XFS_TRANS_DQ_RES_RTBLKS:
 356		qtrx->qt_rtblk_res += delta;
 357		break;
 358
 359	/* rtblk count */
 360	case XFS_TRANS_DQ_RTBCOUNT:
 361		if (qtrx->qt_rtblk_res && delta > 0) {
 362			qtrx->qt_rtblk_res_used += delta;
 363			ASSERT(qtrx->qt_rtblk_res >= qtrx->qt_rtblk_res_used);
 364		}
 365		qtrx->qt_rtbcount_delta += delta;
 366		break;
 367
 368	case XFS_TRANS_DQ_DELRTBCOUNT:
 369		qtrx->qt_delrtb_delta += delta;
 370		break;
 371
 372	default:
 373		ASSERT(0);
 374	}
 375
 376	trace_xfs_trans_mod_dquot_after(qtrx);
 377}
 378
 379
 380/*
 381 * Given an array of dqtrx structures, lock all the dquots associated and join
 382 * them to the transaction, provided they have been modified.  We know that the
 383 * highest number of dquots of one type - usr, grp and prj - involved in a
 384 * transaction is 3 so we don't need to make this very generic.
 385 */
 386STATIC void
 387xfs_trans_dqlockedjoin(
 388	struct xfs_trans	*tp,
 389	struct xfs_dqtrx	*q)
 390{
 
 391	ASSERT(q[0].qt_dquot != NULL);
 392	if (q[1].qt_dquot == NULL) {
 393		xfs_dqlock(q[0].qt_dquot);
 394		xfs_trans_dqjoin(tp, q[0].qt_dquot);
 395	} else {
 396		ASSERT(XFS_QM_TRANS_MAXDQS == 2);
 397		xfs_dqlock2(q[0].qt_dquot, q[1].qt_dquot);
 398		xfs_trans_dqjoin(tp, q[0].qt_dquot);
 399		xfs_trans_dqjoin(tp, q[1].qt_dquot);
 
 
 
 
 
 
 
 400	}
 401}
 402
 403/* Apply dqtrx changes to the quota reservation counters. */
 404static inline void
 405xfs_apply_quota_reservation_deltas(
 406	struct xfs_dquot_res	*res,
 407	uint64_t		reserved,
 408	int64_t			res_used,
 409	int64_t			count_delta)
 410{
 411	if (reserved != 0) {
 412		/*
 413		 * Subtle math here: If reserved > res_used (the normal case),
 414		 * we're simply subtracting the unused transaction quota
 415		 * reservation from the dquot reservation.
 416		 *
 417		 * If, however, res_used > reserved, then we have allocated
 418		 * more quota blocks than were reserved for the transaction.
 419		 * We must add that excess to the dquot reservation since it
 420		 * tracks (usage + resv) and by definition we didn't reserve
 421		 * that excess.
 422		 */
 423		res->reserved -= abs(reserved - res_used);
 424	} else if (count_delta != 0) {
 425		/*
 426		 * These blks were never reserved, either inside a transaction
 427		 * or outside one (in a delayed allocation). Also, this isn't
 428		 * always a negative number since we sometimes deliberately
 429		 * skip quota reservations.
 430		 */
 431		res->reserved += count_delta;
 432	}
 433}
 434
 435#ifdef CONFIG_XFS_LIVE_HOOKS
 436/* Call downstream hooks now that it's time to apply dquot deltas. */
 437static inline void
 438xfs_trans_apply_dquot_deltas_hook(
 439	struct xfs_trans		*tp,
 440	struct xfs_dquot		*dqp)
 441{
 442	if (xfs_hooks_switched_on(&xfs_dqtrx_hooks_switch)) {
 443		struct xfs_apply_dqtrx_params	p = {
 444			.tx_id		= (uintptr_t)tp,
 445			.q_type		= xfs_dquot_type(dqp),
 446			.q_id		= dqp->q_id,
 447		};
 448		struct xfs_quotainfo	*qi = tp->t_mountp->m_quotainfo;
 449
 450		xfs_hooks_call(&qi->qi_apply_dqtrx_hooks,
 451				XFS_APPLY_DQTRX_COMMIT, &p);
 452	}
 453}
 454#else
 455# define xfs_trans_apply_dquot_deltas_hook(tp, dqp)	((void)0)
 456#endif /* CONFIG_XFS_LIVE_HOOKS */
 457
 458/*
 459 * Called by xfs_trans_commit() and similar in spirit to
 460 * xfs_trans_apply_sb_deltas().
 461 * Go thru all the dquots belonging to this transaction and modify the
 462 * INCORE dquot to reflect the actual usages.
 463 * Unreserve just the reservations done by this transaction.
 464 * dquot is still left locked at exit.
 465 */
 466void
 467xfs_trans_apply_dquot_deltas(
 468	struct xfs_trans	*tp)
 469{
 470	int			i, j;
 471	struct xfs_dquot	*dqp;
 472	struct xfs_dqtrx	*qtrx, *qa;
 473	int64_t			totalbdelta;
 474	int64_t			totalrtbdelta;
 475
 476	if (!tp->t_dqinfo)
 477		return;
 478
 479	ASSERT(tp->t_dqinfo);
 480	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
 481		qa = tp->t_dqinfo->dqs[j];
 482		if (qa[0].qt_dquot == NULL)
 483			continue;
 484
 485		/*
 486		 * Lock all of the dquots and join them to the transaction.
 487		 */
 488		xfs_trans_dqlockedjoin(tp, qa);
 489
 490		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 491			uint64_t	blk_res_used;
 492
 493			qtrx = &qa[i];
 494			/*
 495			 * The array of dquots is filled
 496			 * sequentially, not sparsely.
 497			 */
 498			if ((dqp = qtrx->qt_dquot) == NULL)
 499				break;
 500
 501			ASSERT(XFS_DQ_IS_LOCKED(dqp));
 502
 503			xfs_trans_apply_dquot_deltas_hook(tp, dqp);
 504
 505			/*
 506			 * adjust the actual number of blocks used
 507			 */
 508
 509			/*
 510			 * The issue here is - sometimes we don't make a blkquota
 511			 * reservation intentionally to be fair to users
 512			 * (when the amount is small). On the other hand,
 513			 * delayed allocs do make reservations, but that's
 514			 * outside of a transaction, so we have no
 515			 * idea how much was really reserved.
 516			 * So, here we've accumulated delayed allocation blks and
 517			 * non-delay blks. The assumption is that the
 518			 * delayed ones are always reserved (outside of a
 519			 * transaction), and the others may or may not have
 520			 * quota reservations.
 521			 */
 522			totalbdelta = qtrx->qt_bcount_delta +
 523				qtrx->qt_delbcnt_delta;
 524			totalrtbdelta = qtrx->qt_rtbcount_delta +
 525				qtrx->qt_delrtb_delta;
 526
 527			if (totalbdelta != 0 || totalrtbdelta != 0 ||
 528			    qtrx->qt_icount_delta != 0) {
 529				trace_xfs_trans_apply_dquot_deltas_before(dqp);
 530				trace_xfs_trans_apply_dquot_deltas(qtrx);
 531			}
 532
 533#ifdef DEBUG
 534			if (totalbdelta < 0)
 535				ASSERT(dqp->q_blk.count >= -totalbdelta);
 536
 537			if (totalrtbdelta < 0)
 538				ASSERT(dqp->q_rtb.count >= -totalrtbdelta);
 539
 540			if (qtrx->qt_icount_delta < 0)
 541				ASSERT(dqp->q_ino.count >= -qtrx->qt_icount_delta);
 542#endif
 543			if (totalbdelta)
 544				dqp->q_blk.count += totalbdelta;
 545
 546			if (qtrx->qt_icount_delta)
 547				dqp->q_ino.count += qtrx->qt_icount_delta;
 548
 549			if (totalrtbdelta)
 550				dqp->q_rtb.count += totalrtbdelta;
 551
 552			if (totalbdelta != 0 || totalrtbdelta != 0 ||
 553			    qtrx->qt_icount_delta != 0)
 554				trace_xfs_trans_apply_dquot_deltas_after(dqp);
 555
 556			/*
 557			 * Get any default limits in use.
 558			 * Start/reset the timer(s) if needed.
 559			 */
 560			if (dqp->q_id) {
 561				xfs_qm_adjust_dqlimits(dqp);
 562				xfs_qm_adjust_dqtimers(dqp);
 563			}
 564
 565			dqp->q_flags |= XFS_DQFLAG_DIRTY;
 566			/*
 567			 * add this to the list of items to get logged
 568			 */
 569			xfs_trans_log_dquot(tp, dqp);
 570			/*
 571			 * Take off what's left of the original reservation.
 572			 * In case of delayed allocations, there's no
 573			 * reservation that a transaction structure knows of.
 574			 */
 575			blk_res_used = max_t(int64_t, 0, qtrx->qt_bcount_delta);
 576			xfs_apply_quota_reservation_deltas(&dqp->q_blk,
 577					qtrx->qt_blk_res, blk_res_used,
 578					qtrx->qt_bcount_delta);
 579
 580			/*
 581			 * Adjust the RT reservation.
 582			 */
 583			xfs_apply_quota_reservation_deltas(&dqp->q_rtb,
 584					qtrx->qt_rtblk_res,
 585					qtrx->qt_rtblk_res_used,
 586					qtrx->qt_rtbcount_delta);
 587
 588			/*
 589			 * Adjust the inode reservation.
 590			 */
 591			ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
 592			xfs_apply_quota_reservation_deltas(&dqp->q_ino,
 593					qtrx->qt_ino_res,
 594					qtrx->qt_ino_res_used,
 595					qtrx->qt_icount_delta);
 596
 597			ASSERT(dqp->q_blk.reserved >= dqp->q_blk.count);
 598			ASSERT(dqp->q_ino.reserved >= dqp->q_ino.count);
 599			ASSERT(dqp->q_rtb.reserved >= dqp->q_rtb.count);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 600		}
 601	}
 602}
 603
 604#ifdef CONFIG_XFS_LIVE_HOOKS
 605/* Call downstream hooks now that it's time to cancel dquot deltas. */
 606static inline void
 607xfs_trans_unreserve_and_mod_dquots_hook(
 608	struct xfs_trans		*tp,
 609	struct xfs_dquot		*dqp)
 610{
 611	if (xfs_hooks_switched_on(&xfs_dqtrx_hooks_switch)) {
 612		struct xfs_apply_dqtrx_params	p = {
 613			.tx_id		= (uintptr_t)tp,
 614			.q_type		= xfs_dquot_type(dqp),
 615			.q_id		= dqp->q_id,
 616		};
 617		struct xfs_quotainfo	*qi = tp->t_mountp->m_quotainfo;
 618
 619		xfs_hooks_call(&qi->qi_apply_dqtrx_hooks,
 620				XFS_APPLY_DQTRX_UNRESERVE, &p);
 621	}
 622}
 623#else
 624# define xfs_trans_unreserve_and_mod_dquots_hook(tp, dqp)	((void)0)
 625#endif /* CONFIG_XFS_LIVE_HOOKS */
 626
 627/*
 628 * Release the reservations, and adjust the dquots accordingly.
 629 * This is called only when the transaction is being aborted. If by
 630 * any chance we have done dquot modifications incore (ie. deltas) already,
 631 * we simply throw those away, since that's the expected behavior
 632 * when a transaction is curtailed without a commit.
 633 */
 634void
 635xfs_trans_unreserve_and_mod_dquots(
 636	struct xfs_trans	*tp)
 
 637{
 638	int			i, j;
 639	struct xfs_dquot	*dqp;
 640	struct xfs_dqtrx	*qtrx, *qa;
 641	bool			locked;
 642
 643	if (!tp->t_dqinfo)
 644		return;
 645
 646	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
 647		qa = tp->t_dqinfo->dqs[j];
 648
 649		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 650			qtrx = &qa[i];
 651			/*
 652			 * We assume that the array of dquots is filled
 653			 * sequentially, not sparsely.
 654			 */
 655			if ((dqp = qtrx->qt_dquot) == NULL)
 656				break;
 657
 658			xfs_trans_unreserve_and_mod_dquots_hook(tp, dqp);
 659
 660			/*
 661			 * Unreserve the original reservation. We don't care
 662			 * about the number of blocks used field, or deltas.
 663			 * Also we don't bother to zero the fields.
 664			 */
 665			locked = false;
 666			if (qtrx->qt_blk_res) {
 667				xfs_dqlock(dqp);
 668				locked = true;
 
 
 669				dqp->q_blk.reserved -=
 670					(xfs_qcnt_t)qtrx->qt_blk_res;
 671			}
 672			if (qtrx->qt_ino_res) {
 673				if (!locked) {
 674					xfs_dqlock(dqp);
 675					locked = true;
 676				}
 677				dqp->q_ino.reserved -=
 678					(xfs_qcnt_t)qtrx->qt_ino_res;
 679			}
 680
 681			if (qtrx->qt_rtblk_res) {
 682				if (!locked) {
 683					xfs_dqlock(dqp);
 684					locked = true;
 685				}
 686				dqp->q_rtb.reserved -=
 687					(xfs_qcnt_t)qtrx->qt_rtblk_res;
 688			}
 689			if (locked)
 690				xfs_dqunlock(dqp);
 691
 692		}
 693	}
 694}
 695
 696STATIC void
 697xfs_quota_warn(
 698	struct xfs_mount	*mp,
 699	struct xfs_dquot	*dqp,
 700	int			type)
 701{
 702	enum quota_type		qtype;
 703
 704	switch (xfs_dquot_type(dqp)) {
 705	case XFS_DQTYPE_PROJ:
 706		qtype = PRJQUOTA;
 707		break;
 708	case XFS_DQTYPE_USER:
 709		qtype = USRQUOTA;
 710		break;
 711	case XFS_DQTYPE_GROUP:
 712		qtype = GRPQUOTA;
 713		break;
 714	default:
 715		return;
 716	}
 717
 718	quota_send_warning(make_kqid(&init_user_ns, qtype, dqp->q_id),
 719			   mp->m_super->s_dev, type);
 720}
 721
 722/*
 723 * Decide if we can make an additional reservation against a quota resource.
 724 * Returns an inode QUOTA_NL_ warning code and whether or not it's fatal.
 725 *
 726 * Note that we assume that the numeric difference between the inode and block
 727 * warning codes will always be 3 since it's userspace ABI now, and will never
 728 * decrease the quota reservation, so the *BELOW messages are irrelevant.
 729 */
 730static inline int
 731xfs_dqresv_check(
 732	struct xfs_dquot_res	*res,
 733	struct xfs_quota_limits	*qlim,
 734	int64_t			delta,
 735	bool			*fatal)
 736{
 737	xfs_qcnt_t		hardlimit = res->hardlimit;
 738	xfs_qcnt_t		softlimit = res->softlimit;
 739	xfs_qcnt_t		total_count = res->reserved + delta;
 740
 741	BUILD_BUG_ON(QUOTA_NL_BHARDWARN     != QUOTA_NL_IHARDWARN + 3);
 742	BUILD_BUG_ON(QUOTA_NL_BSOFTLONGWARN != QUOTA_NL_ISOFTLONGWARN + 3);
 743	BUILD_BUG_ON(QUOTA_NL_BSOFTWARN     != QUOTA_NL_ISOFTWARN + 3);
 744
 745	*fatal = false;
 746	if (delta <= 0)
 747		return QUOTA_NL_NOWARN;
 748
 749	if (!hardlimit)
 750		hardlimit = qlim->hard;
 751	if (!softlimit)
 752		softlimit = qlim->soft;
 753
 754	if (hardlimit && total_count > hardlimit) {
 755		*fatal = true;
 756		return QUOTA_NL_IHARDWARN;
 757	}
 758
 759	if (softlimit && total_count > softlimit) {
 760		time64_t	now = ktime_get_real_seconds();
 761
 762		if (res->timer != 0 && now > res->timer) {
 763			*fatal = true;
 764			return QUOTA_NL_ISOFTLONGWARN;
 765		}
 766
 767		return QUOTA_NL_ISOFTWARN;
 768	}
 769
 770	return QUOTA_NL_NOWARN;
 771}
 772
 773/*
 774 * This reserves disk blocks and inodes against a dquot.
 775 * Flags indicate if the dquot is to be locked here and also
 776 * if the blk reservation is for RT or regular blocks.
 777 * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
 778 */
 779STATIC int
 780xfs_trans_dqresv(
 781	struct xfs_trans	*tp,
 782	struct xfs_mount	*mp,
 783	struct xfs_dquot	*dqp,
 784	int64_t			nblks,
 785	long			ninos,
 786	uint			flags)
 787{
 788	struct xfs_quotainfo	*q = mp->m_quotainfo;
 789	struct xfs_def_quota	*defq;
 790	struct xfs_dquot_res	*blkres;
 791	struct xfs_quota_limits	*qlim;
 792
 793	xfs_dqlock(dqp);
 794
 795	defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
 796
 797	if (flags & XFS_TRANS_DQ_RES_BLKS) {
 798		blkres = &dqp->q_blk;
 799		qlim = &defq->blk;
 800	} else {
 801		blkres = &dqp->q_rtb;
 802		qlim = &defq->rtb;
 803	}
 804
 805	if ((flags & XFS_QMOPT_FORCE_RES) == 0 && dqp->q_id &&
 806	    xfs_dquot_is_enforced(dqp)) {
 807		int		quota_nl;
 808		bool		fatal;
 809
 810		/*
 811		 * dquot is locked already. See if we'd go over the hardlimit
 812		 * or exceed the timelimit if we'd reserve resources.
 813		 */
 814		quota_nl = xfs_dqresv_check(blkres, qlim, nblks, &fatal);
 815		if (quota_nl != QUOTA_NL_NOWARN) {
 816			/*
 817			 * Quota block warning codes are 3 more than the inode
 818			 * codes, which we check above.
 819			 */
 820			xfs_quota_warn(mp, dqp, quota_nl + 3);
 821			if (fatal)
 822				goto error_return;
 823		}
 824
 825		quota_nl = xfs_dqresv_check(&dqp->q_ino, &defq->ino, ninos,
 826				&fatal);
 827		if (quota_nl != QUOTA_NL_NOWARN) {
 828			xfs_quota_warn(mp, dqp, quota_nl);
 829			if (fatal)
 830				goto error_return;
 831		}
 832	}
 833
 834	/*
 835	 * Change the reservation, but not the actual usage.
 836	 * Note that q_blk.reserved = q_blk.count + resv
 837	 */
 838	blkres->reserved += (xfs_qcnt_t)nblks;
 839	dqp->q_ino.reserved += (xfs_qcnt_t)ninos;
 840
 841	/*
 842	 * note the reservation amt in the trans struct too,
 843	 * so that the transaction knows how much was reserved by
 844	 * it against this particular dquot.
 845	 * We don't do this when we are reserving for a delayed allocation,
 846	 * because we don't have the luxury of a transaction envelope then.
 847	 */
 848	if (tp) {
 849		ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 850		xfs_trans_mod_dquot(tp, dqp, flags & XFS_QMOPT_RESBLK_MASK,
 851				    nblks);
 852		xfs_trans_mod_dquot(tp, dqp, XFS_TRANS_DQ_RES_INOS, ninos);
 853	}
 854
 855	if (XFS_IS_CORRUPT(mp, dqp->q_blk.reserved < dqp->q_blk.count) ||
 856	    XFS_IS_CORRUPT(mp, dqp->q_rtb.reserved < dqp->q_rtb.count) ||
 857	    XFS_IS_CORRUPT(mp, dqp->q_ino.reserved < dqp->q_ino.count))
 858		goto error_corrupt;
 859
 860	xfs_dqunlock(dqp);
 861	return 0;
 862
 863error_return:
 864	xfs_dqunlock(dqp);
 865	if (xfs_dquot_type(dqp) == XFS_DQTYPE_PROJ)
 866		return -ENOSPC;
 867	return -EDQUOT;
 868error_corrupt:
 869	xfs_dqunlock(dqp);
 870	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 871	xfs_fs_mark_sick(mp, XFS_SICK_FS_QUOTACHECK);
 872	return -EFSCORRUPTED;
 873}
 874
 875
 876/*
 877 * Given dquot(s), make disk block and/or inode reservations against them.
 878 * The fact that this does the reservation against user, group and
 879 * project quotas is important, because this follows a all-or-nothing
 880 * approach.
 881 *
 882 * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
 883 *	   XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT.  Used by pquota.
 884 *	   XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
 885 *	   XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
 886 * dquots are unlocked on return, if they were not locked by caller.
 887 */
 888int
 889xfs_trans_reserve_quota_bydquots(
 890	struct xfs_trans	*tp,
 891	struct xfs_mount	*mp,
 892	struct xfs_dquot	*udqp,
 893	struct xfs_dquot	*gdqp,
 894	struct xfs_dquot	*pdqp,
 895	int64_t			nblks,
 896	long			ninos,
 897	uint			flags)
 898{
 899	int		error;
 900
 901	if (!XFS_IS_QUOTA_ON(mp))
 902		return 0;
 903
 904	ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 905
 906	if (udqp) {
 907		error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos, flags);
 908		if (error)
 909			return error;
 910	}
 911
 912	if (gdqp) {
 913		error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
 914		if (error)
 915			goto unwind_usr;
 916	}
 917
 918	if (pdqp) {
 919		error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags);
 920		if (error)
 921			goto unwind_grp;
 922	}
 923
 924	/*
 925	 * Didn't change anything critical, so, no need to log
 926	 */
 927	return 0;
 928
 929unwind_grp:
 930	flags |= XFS_QMOPT_FORCE_RES;
 931	if (gdqp)
 932		xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags);
 933unwind_usr:
 934	flags |= XFS_QMOPT_FORCE_RES;
 935	if (udqp)
 936		xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags);
 937	return error;
 938}
 939
 940
 941/*
 942 * Lock the dquot and change the reservation if we can.
 943 * This doesn't change the actual usage, just the reservation.
 944 * The inode sent in is locked.
 945 */
 946int
 947xfs_trans_reserve_quota_nblks(
 948	struct xfs_trans	*tp,
 949	struct xfs_inode	*ip,
 950	int64_t			dblocks,
 951	int64_t			rblocks,
 952	bool			force)
 953{
 954	struct xfs_mount	*mp = ip->i_mount;
 955	unsigned int		qflags = 0;
 956	int			error;
 957
 958	if (!XFS_IS_QUOTA_ON(mp))
 959		return 0;
 
 
 960
 961	ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
 962	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 963
 964	if (force)
 965		qflags |= XFS_QMOPT_FORCE_RES;
 966
 967	/* Reserve data device quota against the inode's dquots. */
 968	error = xfs_trans_reserve_quota_bydquots(tp, mp, ip->i_udquot,
 969			ip->i_gdquot, ip->i_pdquot, dblocks, 0,
 970			XFS_QMOPT_RES_REGBLKS | qflags);
 971	if (error)
 972		return error;
 973
 974	/* Do the same but for realtime blocks. */
 975	error = xfs_trans_reserve_quota_bydquots(tp, mp, ip->i_udquot,
 976			ip->i_gdquot, ip->i_pdquot, rblocks, 0,
 977			XFS_QMOPT_RES_RTBLKS | qflags);
 978	if (error) {
 979		xfs_trans_reserve_quota_bydquots(tp, mp, ip->i_udquot,
 980				ip->i_gdquot, ip->i_pdquot, -dblocks, 0,
 981				XFS_QMOPT_RES_REGBLKS);
 982		return error;
 983	}
 984
 985	return 0;
 986}
 987
 988/* Change the quota reservations for an inode creation activity. */
 989int
 990xfs_trans_reserve_quota_icreate(
 991	struct xfs_trans	*tp,
 992	struct xfs_dquot	*udqp,
 993	struct xfs_dquot	*gdqp,
 994	struct xfs_dquot	*pdqp,
 995	int64_t			dblocks)
 996{
 997	struct xfs_mount	*mp = tp->t_mountp;
 998
 999	if (!XFS_IS_QUOTA_ON(mp))
1000		return 0;
1001
1002	return xfs_trans_reserve_quota_bydquots(tp, mp, udqp, gdqp, pdqp,
1003			dblocks, 1, XFS_QMOPT_RES_REGBLKS);
1004}
1005
1006STATIC void
1007xfs_trans_alloc_dqinfo(
1008	xfs_trans_t	*tp)
1009{
1010	tp->t_dqinfo = kmem_cache_zalloc(xfs_dqtrx_cache,
1011					 GFP_KERNEL | __GFP_NOFAIL);
1012}
1013
1014void
1015xfs_trans_free_dqinfo(
1016	xfs_trans_t	*tp)
1017{
1018	if (!tp->t_dqinfo)
1019		return;
1020	kmem_cache_free(xfs_dqtrx_cache, tp->t_dqinfo);
1021	tp->t_dqinfo = NULL;
 
 
 
 
 
 
 
 
 
 
 
1022}
v6.13.7
   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 * Copyright (c) 2000-2002 Silicon Graphics, Inc.
   4 * All Rights Reserved.
   5 */
   6#include "xfs.h"
   7#include "xfs_fs.h"
   8#include "xfs_shared.h"
   9#include "xfs_format.h"
  10#include "xfs_log_format.h"
  11#include "xfs_trans_resv.h"
  12#include "xfs_mount.h"
  13#include "xfs_inode.h"
  14#include "xfs_trans.h"
  15#include "xfs_trans_priv.h"
  16#include "xfs_quota.h"
  17#include "xfs_qm.h"
  18#include "xfs_trace.h"
  19#include "xfs_error.h"
  20#include "xfs_health.h"
  21
  22STATIC void	xfs_trans_alloc_dqinfo(xfs_trans_t *);
  23
  24/*
  25 * Add the locked dquot to the transaction.
  26 * The dquot must be locked, and it cannot be associated with any
  27 * transaction.
  28 */
  29void
  30xfs_trans_dqjoin(
  31	struct xfs_trans	*tp,
  32	struct xfs_dquot	*dqp)
  33{
  34	ASSERT(XFS_DQ_IS_LOCKED(dqp));
  35	ASSERT(dqp->q_logitem.qli_dquot == dqp);
  36
  37	/*
  38	 * Get a log_item_desc to point at the new item.
  39	 */
  40	xfs_trans_add_item(tp, &dqp->q_logitem.qli_item);
  41}
  42
  43/*
  44 * This is called to mark the dquot as needing
  45 * to be logged when the transaction is committed.  The dquot must
  46 * already be associated with the given transaction.
  47 * Note that it marks the entire transaction as dirty. In the ordinary
  48 * case, this gets called via xfs_trans_commit, after the transaction
  49 * is already dirty. However, there's nothing stop this from getting
  50 * called directly, as done by xfs_qm_scall_setqlim. Hence, the TRANS_DIRTY
  51 * flag.
  52 */
  53void
  54xfs_trans_log_dquot(
  55	struct xfs_trans	*tp,
  56	struct xfs_dquot	*dqp)
  57{
  58	ASSERT(XFS_DQ_IS_LOCKED(dqp));
  59
  60	/* Upgrade the dquot to bigtime format if possible. */
  61	if (dqp->q_id != 0 &&
  62	    xfs_has_bigtime(tp->t_mountp) &&
  63	    !(dqp->q_type & XFS_DQTYPE_BIGTIME))
  64		dqp->q_type |= XFS_DQTYPE_BIGTIME;
  65
  66	tp->t_flags |= XFS_TRANS_DIRTY;
  67	set_bit(XFS_LI_DIRTY, &dqp->q_logitem.qli_item.li_flags);
  68}
  69
  70/*
  71 * Carry forward whatever is left of the quota blk reservation to
  72 * the spanky new transaction
  73 */
  74void
  75xfs_trans_dup_dqinfo(
  76	struct xfs_trans	*otp,
  77	struct xfs_trans	*ntp)
  78{
  79	struct xfs_dqtrx	*oq, *nq;
  80	int			i, j;
  81	struct xfs_dqtrx	*oqa, *nqa;
  82	uint64_t		blk_res_used;
  83
  84	if (!otp->t_dqinfo)
  85		return;
  86
  87	xfs_trans_alloc_dqinfo(ntp);
  88
  89	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
  90		oqa = otp->t_dqinfo->dqs[j];
  91		nqa = ntp->t_dqinfo->dqs[j];
  92		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
  93			blk_res_used = 0;
  94
  95			if (oqa[i].qt_dquot == NULL)
  96				break;
  97			oq = &oqa[i];
  98			nq = &nqa[i];
  99
 100			if (oq->qt_blk_res && oq->qt_bcount_delta > 0)
 101				blk_res_used = oq->qt_bcount_delta;
 102
 103			nq->qt_dquot = oq->qt_dquot;
 104			nq->qt_bcount_delta = nq->qt_icount_delta = 0;
 105			nq->qt_rtbcount_delta = 0;
 106
 107			/*
 108			 * Transfer whatever is left of the reservations.
 109			 */
 110			nq->qt_blk_res = oq->qt_blk_res - blk_res_used;
 111			oq->qt_blk_res = blk_res_used;
 112
 113			nq->qt_rtblk_res = oq->qt_rtblk_res -
 114				oq->qt_rtblk_res_used;
 115			oq->qt_rtblk_res = oq->qt_rtblk_res_used;
 116
 117			nq->qt_ino_res = oq->qt_ino_res - oq->qt_ino_res_used;
 118			oq->qt_ino_res = oq->qt_ino_res_used;
 119
 120		}
 121	}
 122}
 123
 124#ifdef CONFIG_XFS_LIVE_HOOKS
 125/*
 126 * Use a static key here to reduce the overhead of quota live updates.  If the
 127 * compiler supports jump labels, the static branch will be replaced by a nop
 128 * sled when there are no hook users.  Online fsck is currently the only
 129 * caller, so this is a reasonable tradeoff.
 130 *
 131 * Note: Patching the kernel code requires taking the cpu hotplug lock.  Other
 132 * parts of the kernel allocate memory with that lock held, which means that
 133 * XFS callers cannot hold any locks that might be used by memory reclaim or
 134 * writeback when calling the static_branch_{inc,dec} functions.
 135 */
 136DEFINE_STATIC_XFS_HOOK_SWITCH(xfs_dqtrx_hooks_switch);
 137
 138void
 139xfs_dqtrx_hook_disable(void)
 140{
 141	xfs_hooks_switch_off(&xfs_dqtrx_hooks_switch);
 142}
 143
 144void
 145xfs_dqtrx_hook_enable(void)
 146{
 147	xfs_hooks_switch_on(&xfs_dqtrx_hooks_switch);
 148}
 149
 150/* Schedule a transactional dquot update on behalf of an inode. */
 151void
 152xfs_trans_mod_ino_dquot(
 153	struct xfs_trans		*tp,
 154	struct xfs_inode		*ip,
 155	struct xfs_dquot		*dqp,
 156	unsigned int			field,
 157	int64_t				delta)
 158{
 159	ASSERT(!xfs_is_metadir_inode(ip) || XFS_IS_DQDETACHED(ip));
 160
 161	xfs_trans_mod_dquot(tp, dqp, field, delta);
 162
 163	if (xfs_hooks_switched_on(&xfs_dqtrx_hooks_switch)) {
 164		struct xfs_mod_ino_dqtrx_params	p = {
 165			.tx_id		= (uintptr_t)tp,
 166			.ino		= ip->i_ino,
 167			.q_type		= xfs_dquot_type(dqp),
 168			.q_id		= dqp->q_id,
 169			.delta		= delta
 170		};
 171		struct xfs_quotainfo	*qi = tp->t_mountp->m_quotainfo;
 172
 173		xfs_hooks_call(&qi->qi_mod_ino_dqtrx_hooks, field, &p);
 174	}
 175}
 176
 177/* Call the specified functions during a dquot counter update. */
 178int
 179xfs_dqtrx_hook_add(
 180	struct xfs_quotainfo	*qi,
 181	struct xfs_dqtrx_hook	*hook)
 182{
 183	int			error;
 184
 185	/*
 186	 * Transactional dquot updates first call the mod hook when changes
 187	 * are attached to the transaction and then call the apply hook when
 188	 * those changes are committed (or canceled).
 189	 *
 190	 * The apply hook must be installed before the mod hook so that we
 191	 * never fail to catch the end of a quota update sequence.
 192	 */
 193	error = xfs_hooks_add(&qi->qi_apply_dqtrx_hooks, &hook->apply_hook);
 194	if (error)
 195		goto out;
 196
 197	error = xfs_hooks_add(&qi->qi_mod_ino_dqtrx_hooks, &hook->mod_hook);
 198	if (error)
 199		goto out_apply;
 200
 201	return 0;
 202
 203out_apply:
 204	xfs_hooks_del(&qi->qi_apply_dqtrx_hooks, &hook->apply_hook);
 205out:
 206	return error;
 207}
 208
 209/* Stop calling the specified function during a dquot counter update. */
 210void
 211xfs_dqtrx_hook_del(
 212	struct xfs_quotainfo	*qi,
 213	struct xfs_dqtrx_hook	*hook)
 214{
 215	/*
 216	 * The mod hook must be removed before apply hook to avoid giving the
 217	 * hook consumer with an incomplete update.  No hooks should be running
 218	 * after these functions return.
 219	 */
 220	xfs_hooks_del(&qi->qi_mod_ino_dqtrx_hooks, &hook->mod_hook);
 221	xfs_hooks_del(&qi->qi_apply_dqtrx_hooks, &hook->apply_hook);
 222}
 223
 224/* Configure dquot update hook functions. */
 225void
 226xfs_dqtrx_hook_setup(
 227	struct xfs_dqtrx_hook	*hook,
 228	notifier_fn_t		mod_fn,
 229	notifier_fn_t		apply_fn)
 230{
 231	xfs_hook_setup(&hook->mod_hook, mod_fn);
 232	xfs_hook_setup(&hook->apply_hook, apply_fn);
 233}
 234#endif /* CONFIG_XFS_LIVE_HOOKS */
 235
 236/*
 237 * Wrap around mod_dquot to account for both user and group quotas.
 238 */
 239void
 240xfs_trans_mod_dquot_byino(
 241	xfs_trans_t	*tp,
 242	xfs_inode_t	*ip,
 243	uint		field,
 244	int64_t		delta)
 245{
 246	xfs_mount_t	*mp = tp->t_mountp;
 247
 248	if (!XFS_IS_QUOTA_ON(mp) ||
 249	    xfs_is_quota_inode(&mp->m_sb, ip->i_ino))
 250		return;
 251
 252	ASSERT(!xfs_is_metadir_inode(ip) || XFS_IS_DQDETACHED(ip));
 253
 254	if (XFS_IS_UQUOTA_ON(mp) && ip->i_udquot)
 255		xfs_trans_mod_ino_dquot(tp, ip, ip->i_udquot, field, delta);
 256	if (XFS_IS_GQUOTA_ON(mp) && ip->i_gdquot)
 257		xfs_trans_mod_ino_dquot(tp, ip, ip->i_gdquot, field, delta);
 258	if (XFS_IS_PQUOTA_ON(mp) && ip->i_pdquot)
 259		xfs_trans_mod_ino_dquot(tp, ip, ip->i_pdquot, field, delta);
 260}
 261
 262STATIC struct xfs_dqtrx *
 263xfs_trans_get_dqtrx(
 264	struct xfs_trans	*tp,
 265	struct xfs_dquot	*dqp)
 266{
 267	int			i;
 268	struct xfs_dqtrx	*qa;
 269
 270	switch (xfs_dquot_type(dqp)) {
 271	case XFS_DQTYPE_USER:
 272		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_USR];
 273		break;
 274	case XFS_DQTYPE_GROUP:
 275		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_GRP];
 276		break;
 277	case XFS_DQTYPE_PROJ:
 278		qa = tp->t_dqinfo->dqs[XFS_QM_TRANS_PRJ];
 279		break;
 280	default:
 281		return NULL;
 282	}
 283
 284	for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 285		if (qa[i].qt_dquot == NULL ||
 286		    qa[i].qt_dquot == dqp)
 287			return &qa[i];
 288	}
 289
 290	return NULL;
 291}
 292
 293/*
 294 * Make the changes in the transaction structure.
 295 * The moral equivalent to xfs_trans_mod_sb().
 296 * We don't touch any fields in the dquot, so we don't care
 297 * if it's locked or not (most of the time it won't be).
 298 */
 299void
 300xfs_trans_mod_dquot(
 301	struct xfs_trans	*tp,
 302	struct xfs_dquot	*dqp,
 303	uint			field,
 304	int64_t			delta)
 305{
 306	struct xfs_dqtrx	*qtrx;
 307
 308	ASSERT(tp);
 309	ASSERT(XFS_IS_QUOTA_ON(tp->t_mountp));
 310	qtrx = NULL;
 311
 312	if (!delta)
 313		return;
 314
 315	if (tp->t_dqinfo == NULL)
 316		xfs_trans_alloc_dqinfo(tp);
 317	/*
 318	 * Find either the first free slot or the slot that belongs
 319	 * to this dquot.
 320	 */
 321	qtrx = xfs_trans_get_dqtrx(tp, dqp);
 322	ASSERT(qtrx);
 323	if (qtrx->qt_dquot == NULL)
 324		qtrx->qt_dquot = dqp;
 325
 326	trace_xfs_trans_mod_dquot_before(qtrx);
 327	trace_xfs_trans_mod_dquot(tp, dqp, field, delta);
 328
 329	switch (field) {
 330	/* regular disk blk reservation */
 331	case XFS_TRANS_DQ_RES_BLKS:
 332		qtrx->qt_blk_res += delta;
 333		break;
 334
 335	/* inode reservation */
 336	case XFS_TRANS_DQ_RES_INOS:
 337		qtrx->qt_ino_res += delta;
 338		break;
 339
 340	/* disk blocks used. */
 341	case XFS_TRANS_DQ_BCOUNT:
 342		qtrx->qt_bcount_delta += delta;
 343		break;
 344
 345	case XFS_TRANS_DQ_DELBCOUNT:
 346		qtrx->qt_delbcnt_delta += delta;
 347		break;
 348
 349	/* Inode Count */
 350	case XFS_TRANS_DQ_ICOUNT:
 351		if (qtrx->qt_ino_res && delta > 0) {
 352			qtrx->qt_ino_res_used += delta;
 353			ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
 354		}
 355		qtrx->qt_icount_delta += delta;
 356		break;
 357
 358	/* rtblk reservation */
 359	case XFS_TRANS_DQ_RES_RTBLKS:
 360		qtrx->qt_rtblk_res += delta;
 361		break;
 362
 363	/* rtblk count */
 364	case XFS_TRANS_DQ_RTBCOUNT:
 365		if (qtrx->qt_rtblk_res && delta > 0) {
 366			qtrx->qt_rtblk_res_used += delta;
 367			ASSERT(qtrx->qt_rtblk_res >= qtrx->qt_rtblk_res_used);
 368		}
 369		qtrx->qt_rtbcount_delta += delta;
 370		break;
 371
 372	case XFS_TRANS_DQ_DELRTBCOUNT:
 373		qtrx->qt_delrtb_delta += delta;
 374		break;
 375
 376	default:
 377		ASSERT(0);
 378	}
 379
 380	trace_xfs_trans_mod_dquot_after(qtrx);
 381}
 382
 383
 384/*
 385 * Given an array of dqtrx structures, lock all the dquots associated and join
 386 * them to the transaction, provided they have been modified.
 
 
 387 */
 388STATIC void
 389xfs_trans_dqlockedjoin(
 390	struct xfs_trans	*tp,
 391	struct xfs_dqtrx	*q)
 392{
 393	unsigned int		i;
 394	ASSERT(q[0].qt_dquot != NULL);
 395	if (q[1].qt_dquot == NULL) {
 396		xfs_dqlock(q[0].qt_dquot);
 397		xfs_trans_dqjoin(tp, q[0].qt_dquot);
 398	} else if (q[2].qt_dquot == NULL) {
 
 399		xfs_dqlock2(q[0].qt_dquot, q[1].qt_dquot);
 400		xfs_trans_dqjoin(tp, q[0].qt_dquot);
 401		xfs_trans_dqjoin(tp, q[1].qt_dquot);
 402	} else {
 403		xfs_dqlockn(q);
 404		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 405			if (q[i].qt_dquot == NULL)
 406				break;
 407			xfs_trans_dqjoin(tp, q[i].qt_dquot);
 408		}
 409	}
 410}
 411
 412/* Apply dqtrx changes to the quota reservation counters. */
 413static inline void
 414xfs_apply_quota_reservation_deltas(
 415	struct xfs_dquot_res	*res,
 416	uint64_t		reserved,
 417	int64_t			res_used,
 418	int64_t			count_delta)
 419{
 420	if (reserved != 0) {
 421		/*
 422		 * Subtle math here: If reserved > res_used (the normal case),
 423		 * we're simply subtracting the unused transaction quota
 424		 * reservation from the dquot reservation.
 425		 *
 426		 * If, however, res_used > reserved, then we have allocated
 427		 * more quota blocks than were reserved for the transaction.
 428		 * We must add that excess to the dquot reservation since it
 429		 * tracks (usage + resv) and by definition we didn't reserve
 430		 * that excess.
 431		 */
 432		res->reserved -= abs(reserved - res_used);
 433	} else if (count_delta != 0) {
 434		/*
 435		 * These blks were never reserved, either inside a transaction
 436		 * or outside one (in a delayed allocation). Also, this isn't
 437		 * always a negative number since we sometimes deliberately
 438		 * skip quota reservations.
 439		 */
 440		res->reserved += count_delta;
 441	}
 442}
 443
 444#ifdef CONFIG_XFS_LIVE_HOOKS
 445/* Call downstream hooks now that it's time to apply dquot deltas. */
 446static inline void
 447xfs_trans_apply_dquot_deltas_hook(
 448	struct xfs_trans		*tp,
 449	struct xfs_dquot		*dqp)
 450{
 451	if (xfs_hooks_switched_on(&xfs_dqtrx_hooks_switch)) {
 452		struct xfs_apply_dqtrx_params	p = {
 453			.tx_id		= (uintptr_t)tp,
 454			.q_type		= xfs_dquot_type(dqp),
 455			.q_id		= dqp->q_id,
 456		};
 457		struct xfs_quotainfo	*qi = tp->t_mountp->m_quotainfo;
 458
 459		xfs_hooks_call(&qi->qi_apply_dqtrx_hooks,
 460				XFS_APPLY_DQTRX_COMMIT, &p);
 461	}
 462}
 463#else
 464# define xfs_trans_apply_dquot_deltas_hook(tp, dqp)	((void)0)
 465#endif /* CONFIG_XFS_LIVE_HOOKS */
 466
 467/*
 468 * Called by xfs_trans_commit() and similar in spirit to
 469 * xfs_trans_apply_sb_deltas().
 470 * Go thru all the dquots belonging to this transaction and modify the
 471 * INCORE dquot to reflect the actual usages.
 472 * Unreserve just the reservations done by this transaction.
 473 * dquot is still left locked at exit.
 474 */
 475void
 476xfs_trans_apply_dquot_deltas(
 477	struct xfs_trans	*tp)
 478{
 479	int			i, j;
 480	struct xfs_dquot	*dqp;
 481	struct xfs_dqtrx	*qtrx, *qa;
 482	int64_t			totalbdelta;
 483	int64_t			totalrtbdelta;
 484
 485	if (!tp->t_dqinfo)
 486		return;
 487
 488	ASSERT(tp->t_dqinfo);
 489	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
 490		qa = tp->t_dqinfo->dqs[j];
 491		if (qa[0].qt_dquot == NULL)
 492			continue;
 493
 494		/*
 495		 * Lock all of the dquots and join them to the transaction.
 496		 */
 497		xfs_trans_dqlockedjoin(tp, qa);
 498
 499		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 500			uint64_t	blk_res_used;
 501
 502			qtrx = &qa[i];
 503			/*
 504			 * The array of dquots is filled
 505			 * sequentially, not sparsely.
 506			 */
 507			if ((dqp = qtrx->qt_dquot) == NULL)
 508				break;
 509
 510			ASSERT(XFS_DQ_IS_LOCKED(dqp));
 511
 512			xfs_trans_apply_dquot_deltas_hook(tp, dqp);
 513
 514			/*
 515			 * adjust the actual number of blocks used
 516			 */
 517
 518			/*
 519			 * The issue here is - sometimes we don't make a blkquota
 520			 * reservation intentionally to be fair to users
 521			 * (when the amount is small). On the other hand,
 522			 * delayed allocs do make reservations, but that's
 523			 * outside of a transaction, so we have no
 524			 * idea how much was really reserved.
 525			 * So, here we've accumulated delayed allocation blks and
 526			 * non-delay blks. The assumption is that the
 527			 * delayed ones are always reserved (outside of a
 528			 * transaction), and the others may or may not have
 529			 * quota reservations.
 530			 */
 531			totalbdelta = qtrx->qt_bcount_delta +
 532				qtrx->qt_delbcnt_delta;
 533			totalrtbdelta = qtrx->qt_rtbcount_delta +
 534				qtrx->qt_delrtb_delta;
 535
 536			if (totalbdelta != 0 || totalrtbdelta != 0 ||
 537			    qtrx->qt_icount_delta != 0) {
 538				trace_xfs_trans_apply_dquot_deltas_before(dqp);
 539				trace_xfs_trans_apply_dquot_deltas(qtrx);
 540			}
 541
 542#ifdef DEBUG
 543			if (totalbdelta < 0)
 544				ASSERT(dqp->q_blk.count >= -totalbdelta);
 545
 546			if (totalrtbdelta < 0)
 547				ASSERT(dqp->q_rtb.count >= -totalrtbdelta);
 548
 549			if (qtrx->qt_icount_delta < 0)
 550				ASSERT(dqp->q_ino.count >= -qtrx->qt_icount_delta);
 551#endif
 552			if (totalbdelta)
 553				dqp->q_blk.count += totalbdelta;
 554
 555			if (qtrx->qt_icount_delta)
 556				dqp->q_ino.count += qtrx->qt_icount_delta;
 557
 558			if (totalrtbdelta)
 559				dqp->q_rtb.count += totalrtbdelta;
 560
 561			if (totalbdelta != 0 || totalrtbdelta != 0 ||
 562			    qtrx->qt_icount_delta != 0)
 563				trace_xfs_trans_apply_dquot_deltas_after(dqp);
 564
 565			/*
 566			 * Get any default limits in use.
 567			 * Start/reset the timer(s) if needed.
 568			 */
 569			if (dqp->q_id) {
 570				xfs_qm_adjust_dqlimits(dqp);
 571				xfs_qm_adjust_dqtimers(dqp);
 572			}
 573
 574			dqp->q_flags |= XFS_DQFLAG_DIRTY;
 575			/*
 576			 * add this to the list of items to get logged
 577			 */
 578			xfs_trans_log_dquot(tp, dqp);
 579			/*
 580			 * Take off what's left of the original reservation.
 581			 * In case of delayed allocations, there's no
 582			 * reservation that a transaction structure knows of.
 583			 */
 584			blk_res_used = max_t(int64_t, 0, qtrx->qt_bcount_delta);
 585			xfs_apply_quota_reservation_deltas(&dqp->q_blk,
 586					qtrx->qt_blk_res, blk_res_used,
 587					qtrx->qt_bcount_delta);
 588
 589			/*
 590			 * Adjust the RT reservation.
 591			 */
 592			xfs_apply_quota_reservation_deltas(&dqp->q_rtb,
 593					qtrx->qt_rtblk_res,
 594					qtrx->qt_rtblk_res_used,
 595					qtrx->qt_rtbcount_delta);
 596
 597			/*
 598			 * Adjust the inode reservation.
 599			 */
 600			ASSERT(qtrx->qt_ino_res >= qtrx->qt_ino_res_used);
 601			xfs_apply_quota_reservation_deltas(&dqp->q_ino,
 602					qtrx->qt_ino_res,
 603					qtrx->qt_ino_res_used,
 604					qtrx->qt_icount_delta);
 605
 606			ASSERT(dqp->q_blk.reserved >= dqp->q_blk.count);
 607			ASSERT(dqp->q_ino.reserved >= dqp->q_ino.count);
 608			ASSERT(dqp->q_rtb.reserved >= dqp->q_rtb.count);
 609
 610			/*
 611			 * We've applied the count changes and given back
 612			 * whatever reservation we didn't use.  Zero out the
 613			 * dqtrx fields.
 614			 */
 615			qtrx->qt_blk_res = 0;
 616			qtrx->qt_bcount_delta = 0;
 617			qtrx->qt_delbcnt_delta = 0;
 618
 619			qtrx->qt_rtblk_res = 0;
 620			qtrx->qt_rtblk_res_used = 0;
 621			qtrx->qt_rtbcount_delta = 0;
 622			qtrx->qt_delrtb_delta = 0;
 623
 624			qtrx->qt_ino_res = 0;
 625			qtrx->qt_ino_res_used = 0;
 626			qtrx->qt_icount_delta = 0;
 627		}
 628	}
 629}
 630
 631#ifdef CONFIG_XFS_LIVE_HOOKS
 632/* Call downstream hooks now that it's time to cancel dquot deltas. */
 633static inline void
 634xfs_trans_unreserve_and_mod_dquots_hook(
 635	struct xfs_trans		*tp,
 636	struct xfs_dquot		*dqp)
 637{
 638	if (xfs_hooks_switched_on(&xfs_dqtrx_hooks_switch)) {
 639		struct xfs_apply_dqtrx_params	p = {
 640			.tx_id		= (uintptr_t)tp,
 641			.q_type		= xfs_dquot_type(dqp),
 642			.q_id		= dqp->q_id,
 643		};
 644		struct xfs_quotainfo	*qi = tp->t_mountp->m_quotainfo;
 645
 646		xfs_hooks_call(&qi->qi_apply_dqtrx_hooks,
 647				XFS_APPLY_DQTRX_UNRESERVE, &p);
 648	}
 649}
 650#else
 651# define xfs_trans_unreserve_and_mod_dquots_hook(tp, dqp)	((void)0)
 652#endif /* CONFIG_XFS_LIVE_HOOKS */
 653
 654/*
 655 * Release the reservations, and adjust the dquots accordingly.
 656 * This is called only when the transaction is being aborted. If by
 657 * any chance we have done dquot modifications incore (ie. deltas) already,
 658 * we simply throw those away, since that's the expected behavior
 659 * when a transaction is curtailed without a commit.
 660 */
 661void
 662xfs_trans_unreserve_and_mod_dquots(
 663	struct xfs_trans	*tp,
 664	bool			already_locked)
 665{
 666	int			i, j;
 667	struct xfs_dquot	*dqp;
 668	struct xfs_dqtrx	*qtrx, *qa;
 669	bool			locked;
 670
 671	if (!tp->t_dqinfo)
 672		return;
 673
 674	for (j = 0; j < XFS_QM_TRANS_DQTYPES; j++) {
 675		qa = tp->t_dqinfo->dqs[j];
 676
 677		for (i = 0; i < XFS_QM_TRANS_MAXDQS; i++) {
 678			qtrx = &qa[i];
 679			/*
 680			 * We assume that the array of dquots is filled
 681			 * sequentially, not sparsely.
 682			 */
 683			if ((dqp = qtrx->qt_dquot) == NULL)
 684				break;
 685
 686			xfs_trans_unreserve_and_mod_dquots_hook(tp, dqp);
 687
 688			/*
 689			 * Unreserve the original reservation. We don't care
 690			 * about the number of blocks used field, or deltas.
 691			 * Also we don't bother to zero the fields.
 692			 */
 693			locked = already_locked;
 694			if (qtrx->qt_blk_res) {
 695				if (!locked) {
 696					xfs_dqlock(dqp);
 697					locked = true;
 698				}
 699				dqp->q_blk.reserved -=
 700					(xfs_qcnt_t)qtrx->qt_blk_res;
 701			}
 702			if (qtrx->qt_ino_res) {
 703				if (!locked) {
 704					xfs_dqlock(dqp);
 705					locked = true;
 706				}
 707				dqp->q_ino.reserved -=
 708					(xfs_qcnt_t)qtrx->qt_ino_res;
 709			}
 710
 711			if (qtrx->qt_rtblk_res) {
 712				if (!locked) {
 713					xfs_dqlock(dqp);
 714					locked = true;
 715				}
 716				dqp->q_rtb.reserved -=
 717					(xfs_qcnt_t)qtrx->qt_rtblk_res;
 718			}
 719			if (locked && !already_locked)
 720				xfs_dqunlock(dqp);
 721
 722		}
 723	}
 724}
 725
 726STATIC void
 727xfs_quota_warn(
 728	struct xfs_mount	*mp,
 729	struct xfs_dquot	*dqp,
 730	int			type)
 731{
 732	enum quota_type		qtype;
 733
 734	switch (xfs_dquot_type(dqp)) {
 735	case XFS_DQTYPE_PROJ:
 736		qtype = PRJQUOTA;
 737		break;
 738	case XFS_DQTYPE_USER:
 739		qtype = USRQUOTA;
 740		break;
 741	case XFS_DQTYPE_GROUP:
 742		qtype = GRPQUOTA;
 743		break;
 744	default:
 745		return;
 746	}
 747
 748	quota_send_warning(make_kqid(&init_user_ns, qtype, dqp->q_id),
 749			   mp->m_super->s_dev, type);
 750}
 751
 752/*
 753 * Decide if we can make an additional reservation against a quota resource.
 754 * Returns an inode QUOTA_NL_ warning code and whether or not it's fatal.
 755 *
 756 * Note that we assume that the numeric difference between the inode and block
 757 * warning codes will always be 3 since it's userspace ABI now, and will never
 758 * decrease the quota reservation, so the *BELOW messages are irrelevant.
 759 */
 760static inline int
 761xfs_dqresv_check(
 762	struct xfs_dquot_res	*res,
 763	struct xfs_quota_limits	*qlim,
 764	int64_t			delta,
 765	bool			*fatal)
 766{
 767	xfs_qcnt_t		hardlimit = res->hardlimit;
 768	xfs_qcnt_t		softlimit = res->softlimit;
 769	xfs_qcnt_t		total_count = res->reserved + delta;
 770
 771	BUILD_BUG_ON(QUOTA_NL_BHARDWARN     != QUOTA_NL_IHARDWARN + 3);
 772	BUILD_BUG_ON(QUOTA_NL_BSOFTLONGWARN != QUOTA_NL_ISOFTLONGWARN + 3);
 773	BUILD_BUG_ON(QUOTA_NL_BSOFTWARN     != QUOTA_NL_ISOFTWARN + 3);
 774
 775	*fatal = false;
 776	if (delta <= 0)
 777		return QUOTA_NL_NOWARN;
 778
 779	if (!hardlimit)
 780		hardlimit = qlim->hard;
 781	if (!softlimit)
 782		softlimit = qlim->soft;
 783
 784	if (hardlimit && total_count > hardlimit) {
 785		*fatal = true;
 786		return QUOTA_NL_IHARDWARN;
 787	}
 788
 789	if (softlimit && total_count > softlimit) {
 790		time64_t	now = ktime_get_real_seconds();
 791
 792		if (res->timer != 0 && now > res->timer) {
 793			*fatal = true;
 794			return QUOTA_NL_ISOFTLONGWARN;
 795		}
 796
 797		return QUOTA_NL_ISOFTWARN;
 798	}
 799
 800	return QUOTA_NL_NOWARN;
 801}
 802
 803/*
 804 * This reserves disk blocks and inodes against a dquot.
 805 * Flags indicate if the dquot is to be locked here and also
 806 * if the blk reservation is for RT or regular blocks.
 807 * Sending in XFS_QMOPT_FORCE_RES flag skips the quota check.
 808 */
 809STATIC int
 810xfs_trans_dqresv(
 811	struct xfs_trans	*tp,
 812	struct xfs_mount	*mp,
 813	struct xfs_dquot	*dqp,
 814	int64_t			nblks,
 815	long			ninos,
 816	uint			flags)
 817{
 818	struct xfs_quotainfo	*q = mp->m_quotainfo;
 819	struct xfs_def_quota	*defq;
 820	struct xfs_dquot_res	*blkres;
 821	struct xfs_quota_limits	*qlim;
 822
 823	xfs_dqlock(dqp);
 824
 825	defq = xfs_get_defquota(q, xfs_dquot_type(dqp));
 826
 827	if (flags & XFS_TRANS_DQ_RES_BLKS) {
 828		blkres = &dqp->q_blk;
 829		qlim = &defq->blk;
 830	} else {
 831		blkres = &dqp->q_rtb;
 832		qlim = &defq->rtb;
 833	}
 834
 835	if ((flags & XFS_QMOPT_FORCE_RES) == 0 && dqp->q_id &&
 836	    xfs_dquot_is_enforced(dqp)) {
 837		int		quota_nl;
 838		bool		fatal;
 839
 840		/*
 841		 * dquot is locked already. See if we'd go over the hardlimit
 842		 * or exceed the timelimit if we'd reserve resources.
 843		 */
 844		quota_nl = xfs_dqresv_check(blkres, qlim, nblks, &fatal);
 845		if (quota_nl != QUOTA_NL_NOWARN) {
 846			/*
 847			 * Quota block warning codes are 3 more than the inode
 848			 * codes, which we check above.
 849			 */
 850			xfs_quota_warn(mp, dqp, quota_nl + 3);
 851			if (fatal)
 852				goto error_return;
 853		}
 854
 855		quota_nl = xfs_dqresv_check(&dqp->q_ino, &defq->ino, ninos,
 856				&fatal);
 857		if (quota_nl != QUOTA_NL_NOWARN) {
 858			xfs_quota_warn(mp, dqp, quota_nl);
 859			if (fatal)
 860				goto error_return;
 861		}
 862	}
 863
 864	/*
 865	 * Change the reservation, but not the actual usage.
 866	 * Note that q_blk.reserved = q_blk.count + resv
 867	 */
 868	blkres->reserved += (xfs_qcnt_t)nblks;
 869	dqp->q_ino.reserved += (xfs_qcnt_t)ninos;
 870
 871	/*
 872	 * note the reservation amt in the trans struct too,
 873	 * so that the transaction knows how much was reserved by
 874	 * it against this particular dquot.
 875	 * We don't do this when we are reserving for a delayed allocation,
 876	 * because we don't have the luxury of a transaction envelope then.
 877	 */
 878	if (tp) {
 879		ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 880		xfs_trans_mod_dquot(tp, dqp, flags & XFS_QMOPT_RESBLK_MASK,
 881				    nblks);
 882		xfs_trans_mod_dquot(tp, dqp, XFS_TRANS_DQ_RES_INOS, ninos);
 883	}
 884
 885	if (XFS_IS_CORRUPT(mp, dqp->q_blk.reserved < dqp->q_blk.count) ||
 886	    XFS_IS_CORRUPT(mp, dqp->q_rtb.reserved < dqp->q_rtb.count) ||
 887	    XFS_IS_CORRUPT(mp, dqp->q_ino.reserved < dqp->q_ino.count))
 888		goto error_corrupt;
 889
 890	xfs_dqunlock(dqp);
 891	return 0;
 892
 893error_return:
 894	xfs_dqunlock(dqp);
 895	if (xfs_dquot_type(dqp) == XFS_DQTYPE_PROJ)
 896		return -ENOSPC;
 897	return -EDQUOT;
 898error_corrupt:
 899	xfs_dqunlock(dqp);
 900	xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 901	xfs_fs_mark_sick(mp, XFS_SICK_FS_QUOTACHECK);
 902	return -EFSCORRUPTED;
 903}
 904
 905
 906/*
 907 * Given dquot(s), make disk block and/or inode reservations against them.
 908 * The fact that this does the reservation against user, group and
 909 * project quotas is important, because this follows a all-or-nothing
 910 * approach.
 911 *
 912 * flags = XFS_QMOPT_FORCE_RES evades limit enforcement. Used by chown.
 913 *	   XFS_QMOPT_ENOSPC returns ENOSPC not EDQUOT.  Used by pquota.
 914 *	   XFS_TRANS_DQ_RES_BLKS reserves regular disk blocks
 915 *	   XFS_TRANS_DQ_RES_RTBLKS reserves realtime disk blocks
 916 * dquots are unlocked on return, if they were not locked by caller.
 917 */
 918int
 919xfs_trans_reserve_quota_bydquots(
 920	struct xfs_trans	*tp,
 921	struct xfs_mount	*mp,
 922	struct xfs_dquot	*udqp,
 923	struct xfs_dquot	*gdqp,
 924	struct xfs_dquot	*pdqp,
 925	int64_t			nblks,
 926	long			ninos,
 927	uint			flags)
 928{
 929	int		error;
 930
 931	if (!XFS_IS_QUOTA_ON(mp))
 932		return 0;
 933
 934	ASSERT(flags & XFS_QMOPT_RESBLK_MASK);
 935
 936	if (udqp) {
 937		error = xfs_trans_dqresv(tp, mp, udqp, nblks, ninos, flags);
 938		if (error)
 939			return error;
 940	}
 941
 942	if (gdqp) {
 943		error = xfs_trans_dqresv(tp, mp, gdqp, nblks, ninos, flags);
 944		if (error)
 945			goto unwind_usr;
 946	}
 947
 948	if (pdqp) {
 949		error = xfs_trans_dqresv(tp, mp, pdqp, nblks, ninos, flags);
 950		if (error)
 951			goto unwind_grp;
 952	}
 953
 954	/*
 955	 * Didn't change anything critical, so, no need to log
 956	 */
 957	return 0;
 958
 959unwind_grp:
 960	flags |= XFS_QMOPT_FORCE_RES;
 961	if (gdqp)
 962		xfs_trans_dqresv(tp, mp, gdqp, -nblks, -ninos, flags);
 963unwind_usr:
 964	flags |= XFS_QMOPT_FORCE_RES;
 965	if (udqp)
 966		xfs_trans_dqresv(tp, mp, udqp, -nblks, -ninos, flags);
 967	return error;
 968}
 969
 970
 971/*
 972 * Lock the dquot and change the reservation if we can.
 973 * This doesn't change the actual usage, just the reservation.
 974 * The inode sent in is locked.
 975 */
 976int
 977xfs_trans_reserve_quota_nblks(
 978	struct xfs_trans	*tp,
 979	struct xfs_inode	*ip,
 980	int64_t			dblocks,
 981	int64_t			rblocks,
 982	bool			force)
 983{
 984	struct xfs_mount	*mp = ip->i_mount;
 985	unsigned int		qflags = 0;
 986	int			error;
 987
 988	if (!XFS_IS_QUOTA_ON(mp))
 989		return 0;
 990	if (xfs_is_metadir_inode(ip))
 991		return 0;
 992
 993	ASSERT(!xfs_is_quota_inode(&mp->m_sb, ip->i_ino));
 994	xfs_assert_ilocked(ip, XFS_ILOCK_EXCL);
 995
 996	if (force)
 997		qflags |= XFS_QMOPT_FORCE_RES;
 998
 999	/* Reserve data device quota against the inode's dquots. */
1000	error = xfs_trans_reserve_quota_bydquots(tp, mp, ip->i_udquot,
1001			ip->i_gdquot, ip->i_pdquot, dblocks, 0,
1002			XFS_QMOPT_RES_REGBLKS | qflags);
1003	if (error)
1004		return error;
1005
1006	/* Do the same but for realtime blocks. */
1007	error = xfs_trans_reserve_quota_bydquots(tp, mp, ip->i_udquot,
1008			ip->i_gdquot, ip->i_pdquot, rblocks, 0,
1009			XFS_QMOPT_RES_RTBLKS | qflags);
1010	if (error) {
1011		xfs_trans_reserve_quota_bydquots(tp, mp, ip->i_udquot,
1012				ip->i_gdquot, ip->i_pdquot, -dblocks, 0,
1013				XFS_QMOPT_RES_REGBLKS);
1014		return error;
1015	}
1016
1017	return 0;
1018}
1019
1020/* Change the quota reservations for an inode creation activity. */
1021int
1022xfs_trans_reserve_quota_icreate(
1023	struct xfs_trans	*tp,
1024	struct xfs_dquot	*udqp,
1025	struct xfs_dquot	*gdqp,
1026	struct xfs_dquot	*pdqp,
1027	int64_t			dblocks)
1028{
1029	struct xfs_mount	*mp = tp->t_mountp;
1030
1031	if (!XFS_IS_QUOTA_ON(mp))
1032		return 0;
1033
1034	return xfs_trans_reserve_quota_bydquots(tp, mp, udqp, gdqp, pdqp,
1035			dblocks, 1, XFS_QMOPT_RES_REGBLKS);
1036}
1037
1038STATIC void
1039xfs_trans_alloc_dqinfo(
1040	xfs_trans_t	*tp)
1041{
1042	tp->t_dqinfo = kmem_cache_zalloc(xfs_dqtrx_cache,
1043					 GFP_KERNEL | __GFP_NOFAIL);
1044}
1045
1046void
1047xfs_trans_free_dqinfo(
1048	xfs_trans_t	*tp)
1049{
1050	if (!tp->t_dqinfo)
1051		return;
1052	kmem_cache_free(xfs_dqtrx_cache, tp->t_dqinfo);
1053	tp->t_dqinfo = NULL;
1054}
1055
1056int
1057xfs_quota_reserve_blkres(
1058	struct xfs_inode	*ip,
1059	int64_t			blocks)
1060{
1061	if (XFS_IS_REALTIME_INODE(ip))
1062		return xfs_trans_reserve_quota_nblks(NULL, ip, 0, blocks,
1063				false);
1064	return xfs_trans_reserve_quota_nblks(NULL, ip, blocks, 0, false);
1065}