xfs_qm_syscalls.c 33.6 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2 3
 * Copyright (c) 2000-2005 Silicon Graphics, Inc.
 * All Rights Reserved.
L
Linus Torvalds 已提交
4
 *
5 6
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
L
Linus Torvalds 已提交
7 8
 * published by the Free Software Foundation.
 *
9 10 11 12
 * This program is distributed in the hope that it would be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
L
Linus Torvalds 已提交
13
 *
14 15 16
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write the Free Software Foundation,
 * Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
L
Linus Torvalds 已提交
17
 */
18 19 20

#include <linux/capability.h>

L
Linus Torvalds 已提交
21 22
#include "xfs.h"
#include "xfs_fs.h"
23
#include "xfs_bit.h"
L
Linus Torvalds 已提交
24
#include "xfs_log.h"
25
#include "xfs_inum.h"
L
Linus Torvalds 已提交
26 27
#include "xfs_trans.h"
#include "xfs_sb.h"
28
#include "xfs_ag.h"
L
Linus Torvalds 已提交
29 30 31 32 33
#include "xfs_alloc.h"
#include "xfs_quota.h"
#include "xfs_mount.h"
#include "xfs_bmap_btree.h"
#include "xfs_inode.h"
34
#include "xfs_itable.h"
L
Linus Torvalds 已提交
35 36 37 38 39 40 41
#include "xfs_bmap.h"
#include "xfs_rtalloc.h"
#include "xfs_error.h"
#include "xfs_attr.h"
#include "xfs_buf_item.h"
#include "xfs_utils.h"
#include "xfs_qm.h"
C
Christoph Hellwig 已提交
42
#include "xfs_trace.h"
L
Linus Torvalds 已提交
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66

#ifdef DEBUG
# define qdprintk(s, args...)	cmn_err(CE_DEBUG, s, ## args)
#else
# define qdprintk(s, args...)	do { } while (0)
#endif

STATIC int	xfs_qm_log_quotaoff(xfs_mount_t *, xfs_qoff_logitem_t **, uint);
STATIC int	xfs_qm_log_quotaoff_end(xfs_mount_t *, xfs_qoff_logitem_t *,
					uint);
STATIC uint	xfs_qm_export_flags(uint);
STATIC uint	xfs_qm_export_qtype_flags(uint);
STATIC void	xfs_qm_export_dquot(xfs_mount_t *, xfs_disk_dquot_t *,
					fs_disk_quota_t *);


/*
 * Turn off quota accounting and/or enforcement for all udquots and/or
 * gdquots. Called only at unmount time.
 *
 * This assumes that there are no dquots of this file system cached
 * incore, and modifies the ondisk dquot directly. Therefore, for example,
 * it is an error to call this twice, without purging the cache.
 */
67
int
L
Linus Torvalds 已提交
68 69
xfs_qm_scall_quotaoff(
	xfs_mount_t		*mp,
70
	uint			flags)
L
Linus Torvalds 已提交
71
{
72
	struct xfs_quotainfo	*q = mp->m_quotainfo;
L
Linus Torvalds 已提交
73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95
	uint			dqtype;
	int			error;
	uint			inactivate_flags;
	xfs_qoff_logitem_t	*qoffstart;
	int			nculprits;

	/*
	 * No file system can have quotas enabled on disk but not in core.
	 * Note that quota utilities (like quotaoff) _expect_
	 * errno == EEXIST here.
	 */
	if ((mp->m_qflags & flags) == 0)
		return XFS_ERROR(EEXIST);
	error = 0;

	flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);

	/*
	 * We don't want to deal with two quotaoffs messing up each other,
	 * so we're going to serialize it. quotaoff isn't exactly a performance
	 * critical thing.
	 * If quotaoff, then we must be dealing with the root filesystem.
	 */
96 97
	ASSERT(q);
	mutex_lock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
98 99 100 101 102 103 104

	/*
	 * If we're just turning off quota enforcement, change mp and go.
	 */
	if ((flags & XFS_ALL_QUOTA_ACCT) == 0) {
		mp->m_qflags &= ~(flags);

E
Eric Sandeen 已提交
105
		spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
106
		mp->m_sb.sb_qflags = mp->m_qflags;
E
Eric Sandeen 已提交
107
		spin_unlock(&mp->m_sb_lock);
108
		mutex_unlock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128

		/* XXX what to do if error ? Revert back to old vals incore ? */
		error = xfs_qm_write_sb_changes(mp, XFS_SB_QFLAGS);
		return (error);
	}

	dqtype = 0;
	inactivate_flags = 0;
	/*
	 * If accounting is off, we must turn enforcement off, clear the
	 * quota 'CHKD' certificate to make it known that we have to
	 * do a quotacheck the next time this quota is turned on.
	 */
	if (flags & XFS_UQUOTA_ACCT) {
		dqtype |= XFS_QMOPT_UQUOTA;
		flags |= (XFS_UQUOTA_CHKD | XFS_UQUOTA_ENFD);
		inactivate_flags |= XFS_UQUOTA_ACTIVE;
	}
	if (flags & XFS_GQUOTA_ACCT) {
		dqtype |= XFS_QMOPT_GQUOTA;
129
		flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
L
Linus Torvalds 已提交
130
		inactivate_flags |= XFS_GQUOTA_ACTIVE;
131 132 133 134
	} else if (flags & XFS_PQUOTA_ACCT) {
		dqtype |= XFS_QMOPT_PQUOTA;
		flags |= (XFS_OQUOTA_CHKD | XFS_OQUOTA_ENFD);
		inactivate_flags |= XFS_PQUOTA_ACTIVE;
L
Linus Torvalds 已提交
135 136 137 138 139 140
	}

	/*
	 * Nothing to do?  Don't complain. This happens when we're just
	 * turning off quota enforcement.
	 */
141 142
	if ((mp->m_qflags & flags) == 0)
		goto out_unlock;
L
Linus Torvalds 已提交
143 144 145

	/*
	 * Write the LI_QUOTAOFF log record, and do SB changes atomically,
146 147
	 * and synchronously. If we fail to write, we should abort the
	 * operation as it cannot be recovered safely if we crash.
L
Linus Torvalds 已提交
148
	 */
149 150
	error = xfs_qm_log_quotaoff(mp, &qoffstart, flags);
	if (error)
151
		goto out_unlock;
L
Linus Torvalds 已提交
152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192

	/*
	 * Next we clear the XFS_MOUNT_*DQ_ACTIVE bit(s) in the mount struct
	 * to take care of the race between dqget and quotaoff. We don't take
	 * any special locks to reset these bits. All processes need to check
	 * these bits *after* taking inode lock(s) to see if the particular
	 * quota type is in the process of being turned off. If *ACTIVE, it is
	 * guaranteed that all dquot structures and all quotainode ptrs will all
	 * stay valid as long as that inode is kept locked.
	 *
	 * There is no turning back after this.
	 */
	mp->m_qflags &= ~inactivate_flags;

	/*
	 * Give back all the dquot reference(s) held by inodes.
	 * Here we go thru every single incore inode in this file system, and
	 * do a dqrele on the i_udquot/i_gdquot that it may have.
	 * Essentially, as long as somebody has an inode locked, this guarantees
	 * that quotas will not be turned off. This is handy because in a
	 * transaction once we lock the inode(s) and check for quotaon, we can
	 * depend on the quota inodes (and other things) being valid as long as
	 * we keep the lock(s).
	 */
	xfs_qm_dqrele_all_inodes(mp, flags);

	/*
	 * Next we make the changes in the quota flag in the mount struct.
	 * This isn't protected by a particular lock directly, because we
	 * don't want to take a mrlock everytime we depend on quotas being on.
	 */
	mp->m_qflags &= ~(flags);

	/*
	 * Go through all the dquots of this file system and purge them,
	 * according to what was turned off. We may not be able to get rid
	 * of all dquots, because dquots can have temporary references that
	 * are not attached to inodes. eg. xfs_setattr, xfs_create.
	 * So, if we couldn't purge all the dquots from the filesystem,
	 * we can't get rid of the incore data structures.
	 */
193
	while ((nculprits = xfs_qm_dqpurge_all(mp, dqtype)))
L
Linus Torvalds 已提交
194 195 196 197 198 199 200 201 202 203 204 205 206
		delay(10 * nculprits);

	/*
	 * Transactions that had started before ACTIVE state bit was cleared
	 * could have logged many dquots, so they'd have higher LSNs than
	 * the first QUOTAOFF log record does. If we happen to crash when
	 * the tail of the log has gone past the QUOTAOFF record, but
	 * before the last dquot modification, those dquots __will__
	 * recover, and that's not good.
	 *
	 * So, we have QUOTAOFF start and end logitems; the start
	 * logitem won't get overwritten until the end logitem appears...
	 */
207 208 209 210
	error = xfs_qm_log_quotaoff_end(mp, qoffstart, flags);
	if (error) {
		/* We're screwed now. Shutdown is the only option. */
		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
211
		goto out_unlock;
212
	}
L
Linus Torvalds 已提交
213 214 215 216

	/*
	 * If quotas is completely disabled, close shop.
	 */
217 218
	if (((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET1) ||
	    ((flags & XFS_MOUNT_QUOTA_ALL) == XFS_MOUNT_QUOTA_SET2)) {
219
		mutex_unlock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
220 221 222 223 224
		xfs_qm_destroy_quotainfo(mp);
		return (0);
	}

	/*
225
	 * Release our quotainode references if we don't need them anymore.
L
Linus Torvalds 已提交
226
	 */
227 228 229
	if ((dqtype & XFS_QMOPT_UQUOTA) && q->qi_uquotaip) {
		IRELE(q->qi_uquotaip);
		q->qi_uquotaip = NULL;
L
Linus Torvalds 已提交
230
	}
231 232 233
	if ((dqtype & (XFS_QMOPT_GQUOTA|XFS_QMOPT_PQUOTA)) && q->qi_gquotaip) {
		IRELE(q->qi_gquotaip);
		q->qi_gquotaip = NULL;
L
Linus Torvalds 已提交
234 235
	}

236 237 238
out_unlock:
	mutex_unlock(&q->qi_quotaofflock);
	return error;
L
Linus Torvalds 已提交
239 240
}

241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278
STATIC int
xfs_qm_scall_trunc_qfile(
	struct xfs_mount	*mp,
	xfs_ino_t		ino)
{
	struct xfs_inode	*ip;
	struct xfs_trans	*tp;
	int			error;

	if (ino == NULLFSINO)
		return 0;

	error = xfs_iget(mp, NULL, ino, 0, 0, &ip);
	if (error)
		return error;

	xfs_ilock(ip, XFS_IOLOCK_EXCL);

	tp = xfs_trans_alloc(mp, XFS_TRANS_TRUNCATE_FILE);
	error = xfs_trans_reserve(tp, 0, XFS_ITRUNCATE_LOG_RES(mp), 0,
				  XFS_TRANS_PERM_LOG_RES,
				  XFS_ITRUNCATE_LOG_COUNT);
	if (error) {
		xfs_trans_cancel(tp, 0);
		xfs_iunlock(ip, XFS_IOLOCK_EXCL);
		goto out_put;
	}

	xfs_ilock(ip, XFS_ILOCK_EXCL);
	xfs_trans_ijoin(tp, ip);

	error = xfs_itruncate_finish(&tp, ip, 0, XFS_DATA_FORK, 1);
	if (error) {
		xfs_trans_cancel(tp, XFS_TRANS_RELEASE_LOG_RES |
				     XFS_TRANS_ABORT);
		goto out_unlock;
	}

279
	xfs_trans_ichgtime(tp, ip, XFS_ICHGTIME_MOD | XFS_ICHGTIME_CHG);
280 281 282 283 284 285 286 287 288
	error = xfs_trans_commit(tp, XFS_TRANS_RELEASE_LOG_RES);

out_unlock:
	xfs_iunlock(ip, XFS_ILOCK_EXCL | XFS_IOLOCK_EXCL);
out_put:
	IRELE(ip);
	return error;
}

289
int
L
Linus Torvalds 已提交
290 291 292 293
xfs_qm_scall_trunc_qfiles(
	xfs_mount_t	*mp,
	uint		flags)
{
294
	int		error = 0, error2 = 0;
L
Linus Torvalds 已提交
295

296
	if (!xfs_sb_version_hasquota(&mp->m_sb) || flags == 0) {
L
Linus Torvalds 已提交
297 298 299 300
		qdprintk("qtrunc flags=%x m_qflags=%x\n", flags, mp->m_qflags);
		return XFS_ERROR(EINVAL);
	}

301 302 303 304
	if (flags & XFS_DQ_USER)
		error = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_uquotino);
	if (flags & (XFS_DQ_GROUP|XFS_DQ_PROJ))
		error2 = xfs_qm_scall_trunc_qfile(mp, mp->m_sb.sb_gquotino);
L
Linus Torvalds 已提交
305

306
	return error ? error : error2;
L
Linus Torvalds 已提交
307 308 309 310 311 312 313
}

/*
 * Switch on (a given) quota enforcement for a filesystem.  This takes
 * effect immediately.
 * (Switching on quota accounting must be done at mount time.)
 */
314
int
L
Linus Torvalds 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349
xfs_qm_scall_quotaon(
	xfs_mount_t	*mp,
	uint		flags)
{
	int		error;
	uint		qf;
	uint		accflags;
	__int64_t	sbflags;

	flags &= (XFS_ALL_QUOTA_ACCT | XFS_ALL_QUOTA_ENFD);
	/*
	 * Switching on quota accounting must be done at mount time.
	 */
	accflags = flags & XFS_ALL_QUOTA_ACCT;
	flags &= ~(XFS_ALL_QUOTA_ACCT);

	sbflags = 0;

	if (flags == 0) {
		qdprintk("quotaon: zero flags, m_qflags=%x\n", mp->m_qflags);
		return XFS_ERROR(EINVAL);
	}

	/* No fs can turn on quotas with a delayed effect */
	ASSERT((flags & XFS_ALL_QUOTA_ACCT) == 0);

	/*
	 * Can't enforce without accounting. We check the superblock
	 * qflags here instead of m_qflags because rootfs can have
	 * quota acct on ondisk without m_qflags' knowing.
	 */
	if (((flags & XFS_UQUOTA_ACCT) == 0 &&
	    (mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) == 0 &&
	    (flags & XFS_UQUOTA_ENFD))
	    ||
350 351
	    ((flags & XFS_PQUOTA_ACCT) == 0 &&
	    (mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) == 0 &&
352
	    (flags & XFS_GQUOTA_ACCT) == 0 &&
L
Linus Torvalds 已提交
353
	    (mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) == 0 &&
354
	    (flags & XFS_OQUOTA_ENFD))) {
L
Linus Torvalds 已提交
355 356 357 358 359 360 361 362 363 364 365 366 367 368
		qdprintk("Can't enforce without acct, flags=%x sbflags=%x\n",
			flags, mp->m_sb.sb_qflags);
		return XFS_ERROR(EINVAL);
	}
	/*
	 * If everything's upto-date incore, then don't waste time.
	 */
	if ((mp->m_qflags & flags) == flags)
		return XFS_ERROR(EEXIST);

	/*
	 * Change sb_qflags on disk but not incore mp->qflags
	 * if this is the root filesystem.
	 */
E
Eric Sandeen 已提交
369
	spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
370 371
	qf = mp->m_sb.sb_qflags;
	mp->m_sb.sb_qflags = qf | flags;
E
Eric Sandeen 已提交
372
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
373 374 375 376 377 378 379 380 381 382 383 384 385 386 387

	/*
	 * There's nothing to change if it's the same.
	 */
	if ((qf & flags) == flags && sbflags == 0)
		return XFS_ERROR(EEXIST);
	sbflags |= XFS_SB_QFLAGS;

	if ((error = xfs_qm_write_sb_changes(mp, sbflags)))
		return (error);
	/*
	 * If we aren't trying to switch on quota enforcement, we are done.
	 */
	if  (((mp->m_sb.sb_qflags & XFS_UQUOTA_ACCT) !=
	     (mp->m_qflags & XFS_UQUOTA_ACCT)) ||
388 389 390 391
	     ((mp->m_sb.sb_qflags & XFS_PQUOTA_ACCT) !=
	     (mp->m_qflags & XFS_PQUOTA_ACCT)) ||
	     ((mp->m_sb.sb_qflags & XFS_GQUOTA_ACCT) !=
	     (mp->m_qflags & XFS_GQUOTA_ACCT)) ||
L
Linus Torvalds 已提交
392 393 394 395 396 397 398 399 400
	    (flags & XFS_ALL_QUOTA_ENFD) == 0)
		return (0);

	if (! XFS_IS_QUOTA_RUNNING(mp))
		return XFS_ERROR(ESRCH);

	/*
	 * Switch on quota enforcement in core.
	 */
401
	mutex_lock(&mp->m_quotainfo->qi_quotaofflock);
L
Linus Torvalds 已提交
402
	mp->m_qflags |= (flags & XFS_ALL_QUOTA_ENFD);
403
	mutex_unlock(&mp->m_quotainfo->qi_quotaofflock);
L
Linus Torvalds 已提交
404 405 406 407 408 409 410 411

	return (0);
}


/*
 * Return quota status information, such as uquota-off, enforcements, etc.
 */
412
int
L
Linus Torvalds 已提交
413
xfs_qm_scall_getqstat(
414 415
	struct xfs_mount	*mp,
	struct fs_quota_stat	*out)
L
Linus Torvalds 已提交
416
{
417 418 419
	struct xfs_quotainfo	*q = mp->m_quotainfo;
	struct xfs_inode	*uip, *gip;
	boolean_t		tempuqip, tempgqip;
L
Linus Torvalds 已提交
420 421 422 423 424 425

	uip = gip = NULL;
	tempuqip = tempgqip = B_FALSE;
	memset(out, 0, sizeof(fs_quota_stat_t));

	out->qs_version = FS_QSTAT_VERSION;
426
	if (!xfs_sb_version_hasquota(&mp->m_sb)) {
L
Linus Torvalds 已提交
427 428 429 430 431 432 433 434 435 436 437
		out->qs_uquota.qfs_ino = NULLFSINO;
		out->qs_gquota.qfs_ino = NULLFSINO;
		return (0);
	}
	out->qs_flags = (__uint16_t) xfs_qm_export_flags(mp->m_qflags &
							(XFS_ALL_QUOTA_ACCT|
							 XFS_ALL_QUOTA_ENFD));
	out->qs_pad = 0;
	out->qs_uquota.qfs_ino = mp->m_sb.sb_uquotino;
	out->qs_gquota.qfs_ino = mp->m_sb.sb_gquotino;

438 439 440
	if (q) {
		uip = q->qi_uquotaip;
		gip = q->qi_gquotaip;
L
Linus Torvalds 已提交
441 442 443
	}
	if (!uip && mp->m_sb.sb_uquotino != NULLFSINO) {
		if (xfs_iget(mp, NULL, mp->m_sb.sb_uquotino,
444
					0, 0, &uip) == 0)
L
Linus Torvalds 已提交
445 446 447 448
			tempuqip = B_TRUE;
	}
	if (!gip && mp->m_sb.sb_gquotino != NULLFSINO) {
		if (xfs_iget(mp, NULL, mp->m_sb.sb_gquotino,
449
					0, 0, &gip) == 0)
L
Linus Torvalds 已提交
450 451 452 453 454 455
			tempgqip = B_TRUE;
	}
	if (uip) {
		out->qs_uquota.qfs_nblks = uip->i_d.di_nblocks;
		out->qs_uquota.qfs_nextents = uip->i_d.di_nextents;
		if (tempuqip)
456
			IRELE(uip);
L
Linus Torvalds 已提交
457 458 459 460 461
	}
	if (gip) {
		out->qs_gquota.qfs_nblks = gip->i_d.di_nblocks;
		out->qs_gquota.qfs_nextents = gip->i_d.di_nextents;
		if (tempgqip)
462
			IRELE(gip);
L
Linus Torvalds 已提交
463
	}
464 465 466 467 468 469 470
	if (q) {
		out->qs_incoredqs = q->qi_dquots;
		out->qs_btimelimit = q->qi_btimelimit;
		out->qs_itimelimit = q->qi_itimelimit;
		out->qs_rtbtimelimit = q->qi_rtbtimelimit;
		out->qs_bwarnlimit = q->qi_bwarnlimit;
		out->qs_iwarnlimit = q->qi_iwarnlimit;
L
Linus Torvalds 已提交
471
	}
472
	return 0;
L
Linus Torvalds 已提交
473 474
}

C
Christoph Hellwig 已提交
475 476 477
#define XFS_DQ_MASK \
	(FS_DQ_LIMIT_MASK | FS_DQ_TIMER_MASK | FS_DQ_WARNS_MASK)

L
Linus Torvalds 已提交
478 479 480
/*
 * Adjust quota limits, and start/stop timers accordingly.
 */
481
int
L
Linus Torvalds 已提交
482 483 484 485 486 487
xfs_qm_scall_setqlim(
	xfs_mount_t		*mp,
	xfs_dqid_t		id,
	uint			type,
	fs_disk_quota_t		*newlim)
{
488
	struct xfs_quotainfo	*q = mp->m_quotainfo;
L
Linus Torvalds 已提交
489 490 491 492 493 494
	xfs_disk_dquot_t	*ddq;
	xfs_dquot_t		*dqp;
	xfs_trans_t		*tp;
	int			error;
	xfs_qcnt_t		hard, soft;

C
Christoph Hellwig 已提交
495 496 497 498
	if (newlim->d_fieldmask & ~XFS_DQ_MASK)
		return EINVAL;
	if ((newlim->d_fieldmask & XFS_DQ_MASK) == 0)
		return 0;
L
Linus Torvalds 已提交
499 500 501 502 503 504 505 506 507 508 509 510 511 512

	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SETQLIM);
	if ((error = xfs_trans_reserve(tp, 0, sizeof(xfs_disk_dquot_t) + 128,
				      0, 0, XFS_DEFAULT_LOG_COUNT))) {
		xfs_trans_cancel(tp, 0);
		return (error);
	}

	/*
	 * We don't want to race with a quotaoff so take the quotaoff lock.
	 * (We don't hold an inode lock, so there's nothing else to stop
	 * a quotaoff from happening). (XXXThis doesn't currently happen
	 * because we take the vfslock before calling xfs_qm_sysent).
	 */
513
	mutex_lock(&q->qi_quotaofflock);
L
Linus Torvalds 已提交
514 515 516 517 518 519 520 521

	/*
	 * Get the dquot (locked), and join it to the transaction.
	 * Allocate the dquot if this doesn't exist.
	 */
	if ((error = xfs_qm_dqget(mp, NULL, id, type, XFS_QMOPT_DQALLOC, &dqp))) {
		xfs_trans_cancel(tp, XFS_TRANS_ABORT);
		ASSERT(error != ENOENT);
522
		goto out_unlock;
L
Linus Torvalds 已提交
523 524 525 526 527 528 529 530 531
	}
	xfs_trans_dqjoin(tp, dqp);
	ddq = &dqp->q_core;

	/*
	 * Make sure that hardlimits are >= soft limits before changing.
	 */
	hard = (newlim->d_fieldmask & FS_DQ_BHARD) ?
		(xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_blk_hardlimit) :
532
			be64_to_cpu(ddq->d_blk_hardlimit);
L
Linus Torvalds 已提交
533 534
	soft = (newlim->d_fieldmask & FS_DQ_BSOFT) ?
		(xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_blk_softlimit) :
535
			be64_to_cpu(ddq->d_blk_softlimit);
L
Linus Torvalds 已提交
536
	if (hard == 0 || hard >= soft) {
537 538
		ddq->d_blk_hardlimit = cpu_to_be64(hard);
		ddq->d_blk_softlimit = cpu_to_be64(soft);
L
Linus Torvalds 已提交
539
		if (id == 0) {
540 541
			q->qi_bhardlimit = hard;
			q->qi_bsoftlimit = soft;
L
Linus Torvalds 已提交
542 543 544 545 546 547
		}
	} else {
		qdprintk("blkhard %Ld < blksoft %Ld\n", hard, soft);
	}
	hard = (newlim->d_fieldmask & FS_DQ_RTBHARD) ?
		(xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_rtb_hardlimit) :
548
			be64_to_cpu(ddq->d_rtb_hardlimit);
L
Linus Torvalds 已提交
549 550
	soft = (newlim->d_fieldmask & FS_DQ_RTBSOFT) ?
		(xfs_qcnt_t) XFS_BB_TO_FSB(mp, newlim->d_rtb_softlimit) :
551
			be64_to_cpu(ddq->d_rtb_softlimit);
L
Linus Torvalds 已提交
552
	if (hard == 0 || hard >= soft) {
553 554
		ddq->d_rtb_hardlimit = cpu_to_be64(hard);
		ddq->d_rtb_softlimit = cpu_to_be64(soft);
L
Linus Torvalds 已提交
555
		if (id == 0) {
556 557
			q->qi_rtbhardlimit = hard;
			q->qi_rtbsoftlimit = soft;
L
Linus Torvalds 已提交
558 559 560 561 562 563 564
		}
	} else {
		qdprintk("rtbhard %Ld < rtbsoft %Ld\n", hard, soft);
	}

	hard = (newlim->d_fieldmask & FS_DQ_IHARD) ?
		(xfs_qcnt_t) newlim->d_ino_hardlimit :
565
			be64_to_cpu(ddq->d_ino_hardlimit);
L
Linus Torvalds 已提交
566 567
	soft = (newlim->d_fieldmask & FS_DQ_ISOFT) ?
		(xfs_qcnt_t) newlim->d_ino_softlimit :
568
			be64_to_cpu(ddq->d_ino_softlimit);
L
Linus Torvalds 已提交
569
	if (hard == 0 || hard >= soft) {
570 571
		ddq->d_ino_hardlimit = cpu_to_be64(hard);
		ddq->d_ino_softlimit = cpu_to_be64(soft);
L
Linus Torvalds 已提交
572
		if (id == 0) {
573 574
			q->qi_ihardlimit = hard;
			q->qi_isoftlimit = soft;
L
Linus Torvalds 已提交
575 576 577 578 579
		}
	} else {
		qdprintk("ihard %Ld < isoft %Ld\n", hard, soft);
	}

580 581 582 583
	/*
	 * Update warnings counter(s) if requested
	 */
	if (newlim->d_fieldmask & FS_DQ_BWARNS)
584
		ddq->d_bwarns = cpu_to_be16(newlim->d_bwarns);
585
	if (newlim->d_fieldmask & FS_DQ_IWARNS)
586
		ddq->d_iwarns = cpu_to_be16(newlim->d_iwarns);
587
	if (newlim->d_fieldmask & FS_DQ_RTBWARNS)
588
		ddq->d_rtbwarns = cpu_to_be16(newlim->d_rtbwarns);
589

L
Linus Torvalds 已提交
590 591 592 593 594
	if (id == 0) {
		/*
		 * Timelimits for the super user set the relative time
		 * the other users can be over quota for this file system.
		 * If it is zero a default is used.  Ditto for the default
595 596
		 * soft and hard limit values (already done, above), and
		 * for warnings.
L
Linus Torvalds 已提交
597 598
		 */
		if (newlim->d_fieldmask & FS_DQ_BTIMER) {
599
			q->qi_btimelimit = newlim->d_btimer;
600
			ddq->d_btimer = cpu_to_be32(newlim->d_btimer);
L
Linus Torvalds 已提交
601 602
		}
		if (newlim->d_fieldmask & FS_DQ_ITIMER) {
603
			q->qi_itimelimit = newlim->d_itimer;
604
			ddq->d_itimer = cpu_to_be32(newlim->d_itimer);
L
Linus Torvalds 已提交
605 606
		}
		if (newlim->d_fieldmask & FS_DQ_RTBTIMER) {
607
			q->qi_rtbtimelimit = newlim->d_rtbtimer;
608
			ddq->d_rtbtimer = cpu_to_be32(newlim->d_rtbtimer);
L
Linus Torvalds 已提交
609
		}
610
		if (newlim->d_fieldmask & FS_DQ_BWARNS)
611
			q->qi_bwarnlimit = newlim->d_bwarns;
612
		if (newlim->d_fieldmask & FS_DQ_IWARNS)
613
			q->qi_iwarnlimit = newlim->d_iwarns;
614
		if (newlim->d_fieldmask & FS_DQ_RTBWARNS)
615
			q->qi_rtbwarnlimit = newlim->d_rtbwarns;
616
	} else {
L
Linus Torvalds 已提交
617 618 619 620 621 622 623 624 625 626 627 628
		/*
		 * If the user is now over quota, start the timelimit.
		 * The user will not be 'warned'.
		 * Note that we keep the timers ticking, whether enforcement
		 * is on or off. We don't really want to bother with iterating
		 * over all ondisk dquots and turning the timers on/off.
		 */
		xfs_qm_adjust_dqtimers(mp, ddq);
	}
	dqp->dq_flags |= XFS_DQ_DIRTY;
	xfs_trans_log_dquot(tp, dqp);

629
	error = xfs_trans_commit(tp, 0);
L
Linus Torvalds 已提交
630 631 632
	xfs_qm_dqprint(dqp);
	xfs_qm_dqrele(dqp);

633 634
 out_unlock:
	mutex_unlock(&q->qi_quotaofflock);
635
	return error;
L
Linus Torvalds 已提交
636 637
}

638
int
L
Linus Torvalds 已提交
639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680
xfs_qm_scall_getquota(
	xfs_mount_t	*mp,
	xfs_dqid_t	id,
	uint		type,
	fs_disk_quota_t *out)
{
	xfs_dquot_t	*dqp;
	int		error;

	/*
	 * Try to get the dquot. We don't want it allocated on disk, so
	 * we aren't passing the XFS_QMOPT_DOALLOC flag. If it doesn't
	 * exist, we'll get ENOENT back.
	 */
	if ((error = xfs_qm_dqget(mp, NULL, id, type, 0, &dqp))) {
		return (error);
	}

	/*
	 * If everything's NULL, this dquot doesn't quite exist as far as
	 * our utility programs are concerned.
	 */
	if (XFS_IS_DQUOT_UNINITIALIZED(dqp)) {
		xfs_qm_dqput(dqp);
		return XFS_ERROR(ENOENT);
	}
	/* xfs_qm_dqprint(dqp); */
	/*
	 * Convert the disk dquot to the exportable format
	 */
	xfs_qm_export_dquot(mp, &dqp->q_core, out);
	xfs_qm_dqput(dqp);
	return (error ? XFS_ERROR(EFAULT) : 0);
}


STATIC int
xfs_qm_log_quotaoff_end(
	xfs_mount_t		*mp,
	xfs_qoff_logitem_t	*startqoff,
	uint			flags)
{
681
	xfs_trans_t		*tp;
L
Linus Torvalds 已提交
682
	int			error;
683
	xfs_qoff_logitem_t	*qoffi;
L
Linus Torvalds 已提交
684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702

	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF_END);

	if ((error = xfs_trans_reserve(tp, 0, sizeof(xfs_qoff_logitem_t) * 2,
				      0, 0, XFS_DEFAULT_LOG_COUNT))) {
		xfs_trans_cancel(tp, 0);
		return (error);
	}

	qoffi = xfs_trans_get_qoff_item(tp, startqoff,
					flags & XFS_ALL_QUOTA_ACCT);
	xfs_trans_log_quotaoff_item(tp, qoffi);

	/*
	 * We have to make sure that the transaction is secure on disk before we
	 * return and actually stop quota accounting. So, make it synchronous.
	 * We don't care about quotoff's performance.
	 */
	xfs_trans_set_sync(tp);
703
	error = xfs_trans_commit(tp, 0);
L
Linus Torvalds 已提交
704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731
	return (error);
}


STATIC int
xfs_qm_log_quotaoff(
	xfs_mount_t	       *mp,
	xfs_qoff_logitem_t     **qoffstartp,
	uint		       flags)
{
	xfs_trans_t	       *tp;
	int			error;
	xfs_qoff_logitem_t     *qoffi=NULL;
	uint			oldsbqflag=0;

	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_QUOTAOFF);
	if ((error = xfs_trans_reserve(tp, 0,
				      sizeof(xfs_qoff_logitem_t) * 2 +
				      mp->m_sb.sb_sectsize + 128,
				      0,
				      0,
				      XFS_DEFAULT_LOG_COUNT))) {
		goto error0;
	}

	qoffi = xfs_trans_get_qoff_item(tp, NULL, flags & XFS_ALL_QUOTA_ACCT);
	xfs_trans_log_quotaoff_item(tp, qoffi);

E
Eric Sandeen 已提交
732
	spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
733 734
	oldsbqflag = mp->m_sb.sb_qflags;
	mp->m_sb.sb_qflags = (mp->m_qflags & ~(flags)) & XFS_MOUNT_QUOTA_ALL;
E
Eric Sandeen 已提交
735
	spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
736 737 738 739 740 741 742 743 744

	xfs_mod_sb(tp, XFS_SB_QFLAGS);

	/*
	 * We have to make sure that the transaction is secure on disk before we
	 * return and actually stop quota accounting. So, make it synchronous.
	 * We don't care about quotoff's performance.
	 */
	xfs_trans_set_sync(tp);
745
	error = xfs_trans_commit(tp, 0);
L
Linus Torvalds 已提交
746 747 748 749 750 751 752 753

error0:
	if (error) {
		xfs_trans_cancel(tp, 0);
		/*
		 * No one else is modifying sb_qflags, so this is OK.
		 * We still hold the quotaofflock.
		 */
E
Eric Sandeen 已提交
754
		spin_lock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
755
		mp->m_sb.sb_qflags = oldsbqflag;
E
Eric Sandeen 已提交
756
		spin_unlock(&mp->m_sb_lock);
L
Linus Torvalds 已提交
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
	}
	*qoffstartp = qoffi;
	return (error);
}


/*
 * Translate an internal style on-disk-dquot to the exportable format.
 * The main differences are that the counters/limits are all in Basic
 * Blocks (BBs) instead of the internal FSBs, and all on-disk data has
 * to be converted to the native endianness.
 */
STATIC void
xfs_qm_export_dquot(
	xfs_mount_t		*mp,
	xfs_disk_dquot_t	*src,
	struct fs_disk_quota	*dst)
{
	memset(dst, 0, sizeof(*dst));
	dst->d_version = FS_DQUOT_VERSION;  /* different from src->d_version */
777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797
	dst->d_flags = xfs_qm_export_qtype_flags(src->d_flags);
	dst->d_id = be32_to_cpu(src->d_id);
	dst->d_blk_hardlimit =
		XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_blk_hardlimit));
	dst->d_blk_softlimit =
		XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_blk_softlimit));
	dst->d_ino_hardlimit = be64_to_cpu(src->d_ino_hardlimit);
	dst->d_ino_softlimit = be64_to_cpu(src->d_ino_softlimit);
	dst->d_bcount = XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_bcount));
	dst->d_icount = be64_to_cpu(src->d_icount);
	dst->d_btimer = be32_to_cpu(src->d_btimer);
	dst->d_itimer = be32_to_cpu(src->d_itimer);
	dst->d_iwarns = be16_to_cpu(src->d_iwarns);
	dst->d_bwarns = be16_to_cpu(src->d_bwarns);
	dst->d_rtb_hardlimit =
		XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtb_hardlimit));
	dst->d_rtb_softlimit =
		XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtb_softlimit));
	dst->d_rtbcount = XFS_FSB_TO_BB(mp, be64_to_cpu(src->d_rtbcount));
	dst->d_rtbtimer = be32_to_cpu(src->d_rtbtimer);
	dst->d_rtbwarns = be16_to_cpu(src->d_rtbwarns);
L
Linus Torvalds 已提交
798 799 800

	/*
	 * Internally, we don't reset all the timers when quota enforcement
801
	 * gets turned off. No need to confuse the user level code,
L
Linus Torvalds 已提交
802 803
	 * so return zeroes in that case.
	 */
804 805 806
	if ((!XFS_IS_UQUOTA_ENFORCED(mp) && src->d_flags == XFS_DQ_USER) ||
	    (!XFS_IS_OQUOTA_ENFORCED(mp) &&
			(src->d_flags & (XFS_DQ_PROJ | XFS_DQ_GROUP)))) {
L
Linus Torvalds 已提交
807 808 809 810 811 812
		dst->d_btimer = 0;
		dst->d_itimer = 0;
		dst->d_rtbtimer = 0;
	}

#ifdef DEBUG
813
	if (((XFS_IS_UQUOTA_ENFORCED(mp) && dst->d_flags == FS_USER_QUOTA) ||
814
	     (XFS_IS_OQUOTA_ENFORCED(mp) &&
815
			(dst->d_flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)))) &&
816
	    dst->d_id != 0) {
L
Linus Torvalds 已提交
817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833
		if (((int) dst->d_bcount >= (int) dst->d_blk_softlimit) &&
		    (dst->d_blk_softlimit > 0)) {
			ASSERT(dst->d_btimer != 0);
		}
		if (((int) dst->d_icount >= (int) dst->d_ino_softlimit) &&
		    (dst->d_ino_softlimit > 0)) {
			ASSERT(dst->d_itimer != 0);
		}
	}
#endif
}

STATIC uint
xfs_qm_export_qtype_flags(
	uint flags)
{
	/*
834
	 * Can't be more than one, or none.
L
Linus Torvalds 已提交
835
	 */
836 837 838 839 840 841 842
	ASSERT((flags & (FS_PROJ_QUOTA | FS_USER_QUOTA)) !=
		(FS_PROJ_QUOTA | FS_USER_QUOTA));
	ASSERT((flags & (FS_PROJ_QUOTA | FS_GROUP_QUOTA)) !=
		(FS_PROJ_QUOTA | FS_GROUP_QUOTA));
	ASSERT((flags & (FS_USER_QUOTA | FS_GROUP_QUOTA)) !=
		(FS_USER_QUOTA | FS_GROUP_QUOTA));
	ASSERT((flags & (FS_PROJ_QUOTA|FS_USER_QUOTA|FS_GROUP_QUOTA)) != 0);
L
Linus Torvalds 已提交
843 844

	return (flags & XFS_DQ_USER) ?
845 846
		FS_USER_QUOTA : (flags & XFS_DQ_PROJ) ?
			FS_PROJ_QUOTA : FS_GROUP_QUOTA;
L
Linus Torvalds 已提交
847 848 849 850 851 852 853 854 855 856
}

STATIC uint
xfs_qm_export_flags(
	uint flags)
{
	uint uflags;

	uflags = 0;
	if (flags & XFS_UQUOTA_ACCT)
857
		uflags |= FS_QUOTA_UDQ_ACCT;
858
	if (flags & XFS_PQUOTA_ACCT)
859
		uflags |= FS_QUOTA_PDQ_ACCT;
L
Linus Torvalds 已提交
860
	if (flags & XFS_GQUOTA_ACCT)
861
		uflags |= FS_QUOTA_GDQ_ACCT;
L
Linus Torvalds 已提交
862
	if (flags & XFS_UQUOTA_ENFD)
863
		uflags |= FS_QUOTA_UDQ_ENFD;
864 865
	if (flags & (XFS_OQUOTA_ENFD)) {
		uflags |= (flags & XFS_GQUOTA_ACCT) ?
866
			FS_QUOTA_GDQ_ENFD : FS_QUOTA_PDQ_ENFD;
867
	}
L
Linus Torvalds 已提交
868 869 870 871
	return (uflags);
}


872 873 874 875 876
STATIC int
xfs_dqrele_inode(
	struct xfs_inode	*ip,
	struct xfs_perag	*pag,
	int			flags)
L
Linus Torvalds 已提交
877
{
878
	int			error;
879

880
	/* skip quota inodes */
881 882
	if (ip == ip->i_mount->m_quotainfo->qi_uquotaip ||
	    ip == ip->i_mount->m_quotainfo->qi_gquotaip) {
883 884
		ASSERT(ip->i_udquot == NULL);
		ASSERT(ip->i_gdquot == NULL);
885
		read_unlock(&pag->pag_ici_lock);
886 887
		return 0;
	}
888

889 890 891
	error = xfs_sync_inode_valid(ip, pag);
	if (error)
		return error;
892

893 894 895 896 897 898 899 900 901
	xfs_ilock(ip, XFS_ILOCK_EXCL);
	if ((flags & XFS_UQUOTA_ACCT) && ip->i_udquot) {
		xfs_qm_dqrele(ip->i_udquot);
		ip->i_udquot = NULL;
	}
	if (flags & (XFS_PQUOTA_ACCT|XFS_GQUOTA_ACCT) && ip->i_gdquot) {
		xfs_qm_dqrele(ip->i_gdquot);
		ip->i_gdquot = NULL;
	}
C
Christoph Hellwig 已提交
902
	xfs_iunlock(ip, XFS_ILOCK_EXCL);
903

C
Christoph Hellwig 已提交
904
	IRELE(ip);
905
	return 0;
906 907
}

908

909 910
/*
 * Go thru all the inodes in the file system, releasing their dquots.
911
 *
912
 * Note that the mount structure gets modified to indicate that quotas are off
913
 * AFTER this, in the case of quotaoff.
914 915 916 917 918 919 920
 */
void
xfs_qm_dqrele_all_inodes(
	struct xfs_mount *mp,
	uint		 flags)
{
	ASSERT(mp->m_quotainfo);
921
	xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags);
L
Linus Torvalds 已提交
922 923 924 925 926 927 928 929 930 931 932 933 934 935
}

/*------------------------------------------------------------------------*/
#ifdef DEBUG
/*
 * This contains all the test functions for XFS disk quotas.
 * Currently it does a quota accounting check. ie. it walks through
 * all inodes in the file system, calculating the dquot accounting fields,
 * and prints out any inconsistencies.
 */
xfs_dqhash_t *qmtest_udqtab;
xfs_dqhash_t *qmtest_gdqtab;
int	      qmtest_hashmask;
int	      qmtest_nfails;
C
Christoph Hellwig 已提交
936
struct mutex  qcheck_lock;
L
Linus Torvalds 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959

#define DQTEST_HASHVAL(mp, id) (((__psunsigned_t)(mp) + \
				 (__psunsigned_t)(id)) & \
				(qmtest_hashmask - 1))

#define DQTEST_HASH(mp, id, type)   ((type & XFS_DQ_USER) ? \
				     (qmtest_udqtab + \
				      DQTEST_HASHVAL(mp, id)) : \
				     (qmtest_gdqtab + \
				      DQTEST_HASHVAL(mp, id)))

#define DQTEST_LIST_PRINT(l, NXT, title) \
{ \
	  xfs_dqtest_t	*dqp; int i = 0;\
	  cmn_err(CE_DEBUG, "%s (#%d)", title, (int) (l)->qh_nelems); \
	  for (dqp = (xfs_dqtest_t *)(l)->qh_next; dqp != NULL; \
	       dqp = (xfs_dqtest_t *)dqp->NXT) { \
		cmn_err(CE_DEBUG, "  %d. \"%d (%s)\"  bcnt = %d, icnt = %d", \
			 ++i, dqp->d_id, DQFLAGTO_TYPESTR(dqp),	     \
			 dqp->d_bcount, dqp->d_icount); } \
}

typedef struct dqtest {
C
Christoph Hellwig 已提交
960
	uint		 dq_flags;	/* various flags (XFS_DQ_*) */
961
	struct list_head q_hashlist;
L
Linus Torvalds 已提交
962 963 964 965 966 967 968 969 970 971
	xfs_dqhash_t	*q_hash;	/* the hashchain header */
	xfs_mount_t	*q_mount;	/* filesystem this relates to */
	xfs_dqid_t	d_id;		/* user id or group id */
	xfs_qcnt_t	d_bcount;	/* # disk blocks owned by the user */
	xfs_qcnt_t	d_icount;	/* # inodes owned by the user */
} xfs_dqtest_t;

STATIC void
xfs_qm_hashinsert(xfs_dqhash_t *h, xfs_dqtest_t *dqp)
{
972 973 974
	list_add(&dqp->q_hashlist, &h->qh_list);
	h->qh_version++;
	h->qh_nelems++;
L
Linus Torvalds 已提交
975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001
}
STATIC void
xfs_qm_dqtest_print(
	xfs_dqtest_t	*d)
{
	cmn_err(CE_DEBUG, "-----------DQTEST DQUOT----------------");
	cmn_err(CE_DEBUG, "---- dquot ID = %d", d->d_id);
	cmn_err(CE_DEBUG, "---- fs       = 0x%p", d->q_mount);
	cmn_err(CE_DEBUG, "---- bcount   = %Lu (0x%x)",
		d->d_bcount, (int)d->d_bcount);
	cmn_err(CE_DEBUG, "---- icount   = %Lu (0x%x)",
		d->d_icount, (int)d->d_icount);
	cmn_err(CE_DEBUG, "---------------------------");
}

STATIC void
xfs_qm_dqtest_failed(
	xfs_dqtest_t	*d,
	xfs_dquot_t	*dqp,
	char		*reason,
	xfs_qcnt_t	a,
	xfs_qcnt_t	b,
	int		error)
{
	qmtest_nfails++;
	if (error)
		cmn_err(CE_DEBUG, "quotacheck failed id=%d, err=%d\nreason: %s",
1002
		       d->d_id, error, reason);
L
Linus Torvalds 已提交
1003 1004
	else
		cmn_err(CE_DEBUG, "quotacheck failed id=%d (%s) [%d != %d]",
1005
		       d->d_id, reason, (int)a, (int)b);
L
Linus Torvalds 已提交
1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016
	xfs_qm_dqtest_print(d);
	if (dqp)
		xfs_qm_dqprint(dqp);
}

STATIC int
xfs_dqtest_cmp2(
	xfs_dqtest_t	*d,
	xfs_dquot_t	*dqp)
{
	int err = 0;
1017
	if (be64_to_cpu(dqp->q_core.d_icount) != d->d_icount) {
L
Linus Torvalds 已提交
1018
		xfs_qm_dqtest_failed(d, dqp, "icount mismatch",
1019
			be64_to_cpu(dqp->q_core.d_icount),
L
Linus Torvalds 已提交
1020 1021 1022
			d->d_icount, 0);
		err++;
	}
1023
	if (be64_to_cpu(dqp->q_core.d_bcount) != d->d_bcount) {
L
Linus Torvalds 已提交
1024
		xfs_qm_dqtest_failed(d, dqp, "bcount mismatch",
1025
			be64_to_cpu(dqp->q_core.d_bcount),
L
Linus Torvalds 已提交
1026 1027 1028
			d->d_bcount, 0);
		err++;
	}
1029 1030 1031
	if (dqp->q_core.d_blk_softlimit &&
	    be64_to_cpu(dqp->q_core.d_bcount) >=
	    be64_to_cpu(dqp->q_core.d_blk_softlimit)) {
L
Linus Torvalds 已提交
1032 1033 1034 1035 1036 1037 1038
		if (!dqp->q_core.d_btimer && dqp->q_core.d_id) {
			cmn_err(CE_DEBUG,
				"%d [%s] [0x%p] BLK TIMER NOT STARTED",
				d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
			err++;
		}
	}
1039 1040 1041
	if (dqp->q_core.d_ino_softlimit &&
	    be64_to_cpu(dqp->q_core.d_icount) >=
	    be64_to_cpu(dqp->q_core.d_ino_softlimit)) {
L
Linus Torvalds 已提交
1042 1043 1044 1045 1046 1047 1048 1049 1050 1051
		if (!dqp->q_core.d_itimer && dqp->q_core.d_id) {
			cmn_err(CE_DEBUG,
				"%d [%s] [0x%p] INO TIMER NOT STARTED",
				d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
			err++;
		}
	}
#ifdef QUOTADEBUG
	if (!err) {
		cmn_err(CE_DEBUG, "%d [%s] [0x%p] qchecked",
1052
			d->d_id, DQFLAGTO_TYPESTR(d), d->q_mount);
L
Linus Torvalds 已提交
1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085
	}
#endif
	return (err);
}

STATIC void
xfs_dqtest_cmp(
	xfs_dqtest_t	*d)
{
	xfs_dquot_t	*dqp;
	int		error;

	/* xfs_qm_dqtest_print(d); */
	if ((error = xfs_qm_dqget(d->q_mount, NULL, d->d_id, d->dq_flags, 0,
				 &dqp))) {
		xfs_qm_dqtest_failed(d, NULL, "dqget failed", 0, 0, error);
		return;
	}
	xfs_dqtest_cmp2(d, dqp);
	xfs_qm_dqput(dqp);
}

STATIC int
xfs_qm_internalqcheck_dqget(
	xfs_mount_t	*mp,
	xfs_dqid_t	id,
	uint		type,
	xfs_dqtest_t	**O_dq)
{
	xfs_dqtest_t	*d;
	xfs_dqhash_t	*h;

	h = DQTEST_HASH(mp, id, type);
1086
	list_for_each_entry(d, &h->qh_list, q_hashlist) {
L
Linus Torvalds 已提交
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
		if (d->d_id == id && mp == d->q_mount) {
			*O_dq = d;
			return (0);
		}
	}
	d = kmem_zalloc(sizeof(xfs_dqtest_t), KM_SLEEP);
	d->dq_flags = type;
	d->d_id = id;
	d->q_mount = mp;
	d->q_hash = h;
1097
	INIT_LIST_HEAD(&d->q_hashlist);
L
Linus Torvalds 已提交
1098 1099 1100 1101 1102 1103 1104 1105 1106
	xfs_qm_hashinsert(h, d);
	*O_dq = d;
	return (0);
}

STATIC void
xfs_qm_internalqcheck_get_dquots(
	xfs_mount_t	*mp,
	xfs_dqid_t	uid,
1107
	xfs_dqid_t	projid,
L
Linus Torvalds 已提交
1108 1109 1110 1111 1112 1113 1114 1115
	xfs_dqid_t	gid,
	xfs_dqtest_t	**ud,
	xfs_dqtest_t	**gd)
{
	if (XFS_IS_UQUOTA_ON(mp))
		xfs_qm_internalqcheck_dqget(mp, uid, XFS_DQ_USER, ud);
	if (XFS_IS_GQUOTA_ON(mp))
		xfs_qm_internalqcheck_dqget(mp, gid, XFS_DQ_GROUP, gd);
1116 1117
	else if (XFS_IS_PQUOTA_ON(mp))
		xfs_qm_internalqcheck_dqget(mp, projid, XFS_DQ_PROJ, gd);
L
Linus Torvalds 已提交
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157
}


STATIC void
xfs_qm_internalqcheck_dqadjust(
	xfs_inode_t		*ip,
	xfs_dqtest_t		*d)
{
	d->d_icount++;
	d->d_bcount += (xfs_qcnt_t)ip->i_d.di_nblocks;
}

STATIC int
xfs_qm_internalqcheck_adjust(
	xfs_mount_t	*mp,		/* mount point for filesystem */
	xfs_ino_t	ino,		/* inode number to get data for */
	void		__user *buffer,	/* not used */
	int		ubsize,		/* not used */
	int		*ubused,	/* not used */
	int		*res)		/* bulkstat result code */
{
	xfs_inode_t		*ip;
	xfs_dqtest_t		*ud, *gd;
	uint			lock_flags;
	boolean_t		ipreleased;
	int			error;

	ASSERT(XFS_IS_QUOTA_RUNNING(mp));

	if (ino == mp->m_sb.sb_uquotino || ino == mp->m_sb.sb_gquotino) {
		*res = BULKSTAT_RV_NOTHING;
		qdprintk("internalqcheck: ino=%llu, uqino=%llu, gqino=%llu\n",
			(unsigned long long) ino,
			(unsigned long long) mp->m_sb.sb_uquotino,
			(unsigned long long) mp->m_sb.sb_gquotino);
		return XFS_ERROR(EINVAL);
	}
	ipreleased = B_FALSE;
 again:
	lock_flags = XFS_ILOCK_SHARED;
1158
	if ((error = xfs_iget(mp, NULL, ino, 0, lock_flags, &ip))) {
L
Linus Torvalds 已提交
1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169
		*res = BULKSTAT_RV_NOTHING;
		return (error);
	}

	/*
	 * This inode can have blocks after eof which can get released
	 * when we send it to inactive. Since we don't check the dquot
	 * until the after all our calculations are done, we must get rid
	 * of those now.
	 */
	if (! ipreleased) {
C
Christoph Hellwig 已提交
1170 1171
		xfs_iunlock(ip, lock_flags);
		IRELE(ip);
L
Linus Torvalds 已提交
1172 1173 1174 1175 1176
		ipreleased = B_TRUE;
		goto again;
	}
	xfs_qm_internalqcheck_get_dquots(mp,
					(xfs_dqid_t) ip->i_d.di_uid,
1177
					(xfs_dqid_t) ip->i_d.di_projid,
L
Linus Torvalds 已提交
1178 1179 1180 1181 1182 1183
					(xfs_dqid_t) ip->i_d.di_gid,
					&ud, &gd);
	if (XFS_IS_UQUOTA_ON(mp)) {
		ASSERT(ud);
		xfs_qm_internalqcheck_dqadjust(ip, ud);
	}
1184
	if (XFS_IS_OQUOTA_ON(mp)) {
L
Linus Torvalds 已提交
1185 1186 1187
		ASSERT(gd);
		xfs_qm_internalqcheck_dqadjust(ip, gd);
	}
C
Christoph Hellwig 已提交
1188 1189
	xfs_iunlock(ip, lock_flags);
	IRELE(ip);
L
Linus Torvalds 已提交
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
	*res = BULKSTAT_RV_DIDONE;
	return (0);
}


/* PRIVATE, debugging */
int
xfs_qm_internalqcheck(
	xfs_mount_t	*mp)
{
	xfs_ino_t	lastino;
	int		done, count;
	int		i;
	int		error;

	lastino = 0;
	qmtest_hashmask = 32;
	count = 5;
	done = 0;
	qmtest_nfails = 0;

	if (! XFS_IS_QUOTA_ON(mp))
		return XFS_ERROR(ESRCH);

1214
	xfs_log_force(mp, XFS_LOG_SYNC);
L
Linus Torvalds 已提交
1215
	XFS_bflush(mp->m_ddev_targp);
1216
	xfs_log_force(mp, XFS_LOG_SYNC);
L
Linus Torvalds 已提交
1217 1218
	XFS_bflush(mp->m_ddev_targp);

1219
	mutex_lock(&qcheck_lock);
L
Linus Torvalds 已提交
1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
	/* There should be absolutely no quota activity while this
	   is going on. */
	qmtest_udqtab = kmem_zalloc(qmtest_hashmask *
				    sizeof(xfs_dqhash_t), KM_SLEEP);
	qmtest_gdqtab = kmem_zalloc(qmtest_hashmask *
				    sizeof(xfs_dqhash_t), KM_SLEEP);
	do {
		/*
		 * Iterate thru all the inodes in the file system,
		 * adjusting the corresponding dquot counters
		 */
1231 1232 1233 1234 1235
		error = xfs_bulkstat(mp, &lastino, &count,
				 xfs_qm_internalqcheck_adjust,
				 0, NULL, &done);
		if (error) {
			cmn_err(CE_DEBUG, "Bulkstat returned error 0x%x", error);
L
Linus Torvalds 已提交
1236 1237
			break;
		}
1238 1239
	} while (!done);

L
Linus Torvalds 已提交
1240 1241
	cmn_err(CE_DEBUG, "Checking results against system dquots");
	for (i = 0; i < qmtest_hashmask; i++) {
1242 1243 1244 1245 1246
		xfs_dqtest_t	*d, *n;
		xfs_dqhash_t	*h;

		h = &qmtest_udqtab[i];
		list_for_each_entry_safe(d, n, &h->qh_list, q_hashlist) {
L
Linus Torvalds 已提交
1247
			xfs_dqtest_cmp(d);
1248
			kmem_free(d);
L
Linus Torvalds 已提交
1249
		}
1250 1251
		h = &qmtest_gdqtab[i];
		list_for_each_entry_safe(d, n, &h->qh_list, q_hashlist) {
L
Linus Torvalds 已提交
1252
			xfs_dqtest_cmp(d);
1253
			kmem_free(d);
L
Linus Torvalds 已提交
1254 1255 1256 1257 1258 1259 1260 1261 1262
		}
	}

	if (qmtest_nfails) {
		cmn_err(CE_DEBUG, "******** quotacheck failed  ********");
		cmn_err(CE_DEBUG, "failures = %d", qmtest_nfails);
	} else {
		cmn_err(CE_DEBUG, "******** quotacheck successful! ********");
	}
1263 1264
	kmem_free(qmtest_udqtab);
	kmem_free(qmtest_gdqtab);
L
Linus Torvalds 已提交
1265 1266 1267 1268 1269
	mutex_unlock(&qcheck_lock);
	return (qmtest_nfails);
}

#endif /* DEBUG */