xfs: remove the dead QUOTADEBUG code

Remove the dead hash table test rid which has been rotting away under QUOTADEBUG, including some code that was compiled for normal debug builds, but not actually called without QUOTADEBUG, and enable a few cheap debug checks that were hidden under QUOTADEBUG for normal debug builds. Signed-off-by: Christoph Hellwig <hch@lst.de> Reviewed-by: Alex Elder <aelder@sgi.com> Reviewed-by: Dave Chinner <dchinner@redhat.com>

xfs: remove the dead QUOTADEBUG code
Remove the dead hash table test rid which has been rotting away under QUOTADEBUG, including some code that was compiled for normal debug builds, but not actually called without QUOTADEBUG, and enable a few cheap debug checks that were hidden under QUOTADEBUG for normal debug builds. Signed-off-by: Christoph Hellwig <hch@lst.de> Reviewed-by: Alex Elder <aelder@sgi.com> Reviewed-by: Dave Chinner <dchinner@redhat.com>
Christoph Hellwig
1 parent 54244fec67
Showing 8 changed files with 8 additions and 466 deletions Side-by-side Diff
fs/xfs/quota/xfs_dquot.c
fs/xfs/quota/xfs_dquot.h
fs/xfs/quota/xfs_qm.c
fs/xfs/quota/xfs_qm.h
fs/xfs/quota/xfs_qm_syscalls.c
fs/xfs/quota/xfs_trans_dquot.c
fs/xfs/xfs.h
fs/xfs/xfs_mount.c
@@ -220,7 +220,7 @@
 {
 	ASSERT(d->d_id);
  
-#ifdef QUOTADEBUG
+#ifdef DEBUG
 	if (d->d_blk_hardlimit)
 		ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
 		       be64_to_cpu(d->d_blk_hardlimit));
@@ -231,6 +231,7 @@
 		ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
 		       be64_to_cpu(d->d_rtb_hardlimit));
 #endif
+
 	if (!d->d_btimer) {
 		if ((d->d_blk_softlimit &&
 		     (be64_to_cpu(d->d_bcount) >=
@@ -1422,45 +1423,6 @@
 	return (0);
 }
  
-
-#ifdef QUOTADEBUG
-void
-xfs_qm_dqprint(xfs_dquot_t *dqp)
-{
-	struct xfs_mount	*mp = dqp->q_mount;
-
-	xfs_debug(mp, "-----------KERNEL DQUOT----------------");
-	xfs_debug(mp, "---- dquotID =  %d",
-		(int)be32_to_cpu(dqp->q_core.d_id));
-	xfs_debug(mp, "---- type    =  %s", DQFLAGTO_TYPESTR(dqp));
-	xfs_debug(mp, "---- fs      =  0x%p", dqp->q_mount);
-	xfs_debug(mp, "---- blkno   =  0x%x", (int) dqp->q_blkno);
-	xfs_debug(mp, "---- boffset =  0x%x", (int) dqp->q_bufoffset);
-	xfs_debug(mp, "---- blkhlimit =  %Lu (0x%x)",
-		be64_to_cpu(dqp->q_core.d_blk_hardlimit),
-		(int)be64_to_cpu(dqp->q_core.d_blk_hardlimit));
-	xfs_debug(mp, "---- blkslimit =  %Lu (0x%x)",
-		be64_to_cpu(dqp->q_core.d_blk_softlimit),
-		(int)be64_to_cpu(dqp->q_core.d_blk_softlimit));
-	xfs_debug(mp, "---- inohlimit =  %Lu (0x%x)",
-		be64_to_cpu(dqp->q_core.d_ino_hardlimit),
-		(int)be64_to_cpu(dqp->q_core.d_ino_hardlimit));
-	xfs_debug(mp, "---- inoslimit =  %Lu (0x%x)",
-		be64_to_cpu(dqp->q_core.d_ino_softlimit),
-		(int)be64_to_cpu(dqp->q_core.d_ino_softlimit));
-	xfs_debug(mp, "---- bcount  =  %Lu (0x%x)",
-		be64_to_cpu(dqp->q_core.d_bcount),
-		(int)be64_to_cpu(dqp->q_core.d_bcount));
-	xfs_debug(mp, "---- icount  =  %Lu (0x%x)",
-		be64_to_cpu(dqp->q_core.d_icount),
-		(int)be64_to_cpu(dqp->q_core.d_icount));
-	xfs_debug(mp, "---- btimer  =  %d",
-		(int)be32_to_cpu(dqp->q_core.d_btimer));
-	xfs_debug(mp, "---- itimer  =  %d",
-		(int)be32_to_cpu(dqp->q_core.d_itimer));
-	xfs_debug(mp, "---------------------------");
-}
-#endif
  
 /*
  * Give the buffer a little push if it is incore and
@@ -116,12 +116,6 @@
 				     (XFS_IS_UQUOTA_ON((d)->q_mount)) : \
 				     (XFS_IS_OQUOTA_ON((d)->q_mount))))
  
-#ifdef QUOTADEBUG
-extern void		xfs_qm_dqprint(xfs_dquot_t *);
-#else
-#define xfs_qm_dqprint(a)
-#endif
-
 extern void		xfs_qm_dqdestroy(xfs_dquot_t *);
 extern int		xfs_qm_dqflush(xfs_dquot_t *, uint);
 extern int		xfs_qm_dqpurge(xfs_dquot_t *);
@@ -67,32 +67,6 @@
 	.seeks = DEFAULT_SEEKS,
 };
  
-#ifdef DEBUG
-extern struct mutex	qcheck_lock;
-#endif
-
-#ifdef QUOTADEBUG
-static void
-xfs_qm_dquot_list_print(
-	struct xfs_mount *mp)
-{
-	xfs_dquot_t	*dqp;
-	int		i = 0;
-
-	list_for_each_entry(dqp, &mp->m_quotainfo->qi_dqlist_lock, qi_mplist) {
-		xfs_debug(mp, "   %d. \"%d (%s)\"   "
-				  "bcnt = %lld, icnt = %lld, refs = %d",
-			i++, be32_to_cpu(dqp->q_core.d_id),
-			DQFLAGTO_TYPESTR(dqp),
-			(long long)be64_to_cpu(dqp->q_core.d_bcount),
-			(long long)be64_to_cpu(dqp->q_core.d_icount),
-			dqp->q_nrefs);
-	}
-}
-#else
-static void xfs_qm_dquot_list_print(struct xfs_mount *mp) { }
-#endif
-
 /*
  * Initialize the XQM structure.
  * Note that there is not one quota manager per file system.
@@ -165,9 +139,6 @@
 	atomic_set(&xqm->qm_totaldquots, 0);
 	xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
 	xqm->qm_nrefs = 0;
-#ifdef DEBUG
-	mutex_init(&qcheck_lock);
-#endif
 	return xqm;
  
  out_free_udqhash:
@@ -204,9 +175,6 @@
 	mutex_lock(&xqm->qm_dqfrlist_lock);
 	list_for_each_entry_safe(dqp, n, &xqm->qm_dqfrlist, q_freelist) {
 		xfs_dqlock(dqp);
-#ifdef QUOTADEBUG
-		xfs_debug(dqp->q_mount, "FREELIST destroy 0x%p", dqp);
-#endif
 		list_del_init(&dqp->q_freelist);
 		xfs_Gqm->qm_dqfrlist_cnt--;
 		xfs_dqunlock(dqp);
@@ -214,9 +182,6 @@
 	}
 	mutex_unlock(&xqm->qm_dqfrlist_lock);
 	mutex_destroy(&xqm->qm_dqfrlist_lock);
-#ifdef DEBUG
-	mutex_destroy(&qcheck_lock);
-#endif
 	kmem_free(xqm);
 }
  
@@ -409,11 +374,6 @@
 		xfs_warn(mp, "Failed to initialize disk quotas.");
 		return;
 	}
-
-#ifdef QUOTADEBUG
-	if (XFS_IS_QUOTA_ON(mp))
-		xfs_qm_internalqcheck(mp);
-#endif
 }
  
 /*
@@ -866,8 +826,8 @@
 	}
  
  done:
-#ifdef QUOTADEBUG
-	if (! error) {
+#ifdef DEBUG
+	if (!error) {
 		if (XFS_IS_UQUOTA_ON(mp))
 			ASSERT(ip->i_udquot);
 		if (XFS_IS_OQUOTA_ON(mp))
@@ -1733,8 +1693,6 @@
 	mp->m_qflags &= ~(XFS_OQUOTA_CHKD | XFS_UQUOTA_CHKD);
 	mp->m_qflags |= flags;
  
-	xfs_qm_dquot_list_print(mp);
-
  error_return:
 	if (error) {
 		xfs_warn(mp,
@@ -2096,9 +2054,6 @@
 	xfs_trans_t	*tp;
 	int		error;
  
-#ifdef QUOTADEBUG
-	xfs_notice(mp, "Writing superblock quota changes");
-#endif
 	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
 	if ((error = xfs_trans_reserve(tp, 0,
 				      mp->m_sb.sb_sectsize + 128, 0,
@@ -163,11 +163,5 @@
 extern int		xfs_qm_scall_quotaon(xfs_mount_t *, uint);
 extern int		xfs_qm_scall_quotaoff(xfs_mount_t *, uint);
  
-#ifdef DEBUG
-extern int		xfs_qm_internalqcheck(xfs_mount_t *);
-#else
-#define xfs_qm_internalqcheck(mp)	(0)
-#endif
-
 #endif /* __XFS_QM_H__ */
@@ -622,7 +622,6 @@
 	xfs_trans_log_dquot(tp, dqp);
  
 	error = xfs_trans_commit(tp, 0);
-	xfs_qm_dqprint(dqp);
 	xfs_qm_dqrele(dqp);
  
  out_unlock:
@@ -657,7 +656,6 @@
 		xfs_qm_dqput(dqp);
 		return XFS_ERROR(ENOENT);
 	}
-	/* xfs_qm_dqprint(dqp); */
 	/*
 	 * Convert the disk dquot to the exportable format
 	 */
@@ -906,355 +904,4 @@
 	ASSERT(mp->m_quotainfo);
 	xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags);
 }
-
-/*------------------------------------------------------------------------*/
-#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;
-struct mutex  qcheck_lock;
-
-#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;\
-	  xfs_debug(NULL, "%s (#%d)", title, (int) (l)->qh_nelems); \
-	  for (dqp = (xfs_dqtest_t *)(l)->qh_next; dqp != NULL; \
-	       dqp = (xfs_dqtest_t *)dqp->NXT) { \
-		xfs_debug(dqp->q_mount,		\
-			"  %d. \"%d (%s)\"  bcnt = %d, icnt = %d", \
-			 ++i, dqp->d_id, DQFLAGTO_TYPESTR(dqp),	     \
-			 dqp->d_bcount, dqp->d_icount); } \
-}
-
-typedef struct dqtest {
-	uint		 dq_flags;	/* various flags (XFS_DQ_*) */
-	struct list_head q_hashlist;
-	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)
-{
-	list_add(&dqp->q_hashlist, &h->qh_list);
-	h->qh_version++;
-	h->qh_nelems++;
-}
-STATIC void
-xfs_qm_dqtest_print(
-	struct xfs_mount	*mp,
-	struct dqtest		*d)
-{
-	xfs_debug(mp, "-----------DQTEST DQUOT----------------");
-	xfs_debug(mp, "---- dquot ID = %d", d->d_id);
-	xfs_debug(mp, "---- fs       = 0x%p", d->q_mount);
-	xfs_debug(mp, "---- bcount   = %Lu (0x%x)",
-		d->d_bcount, (int)d->d_bcount);
-	xfs_debug(mp, "---- icount   = %Lu (0x%x)",
-		d->d_icount, (int)d->d_icount);
-	xfs_debug(mp, "---------------------------");
-}
-
-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)
-		xfs_debug(dqp->q_mount,
-			"quotacheck failed id=%d, err=%d\nreason: %s",
-			d->d_id, error, reason);
-	else
-		xfs_debug(dqp->q_mount,
-			"quotacheck failed id=%d (%s) [%d != %d]",
-			d->d_id, reason, (int)a, (int)b);
-	xfs_qm_dqtest_print(dqp->q_mount, d);
-	if (dqp)
-		xfs_qm_dqprint(dqp);
-}
-
-STATIC int
-xfs_dqtest_cmp2(
-	xfs_dqtest_t	*d,
-	xfs_dquot_t	*dqp)
-{
-	int err = 0;
-	if (be64_to_cpu(dqp->q_core.d_icount) != d->d_icount) {
-		xfs_qm_dqtest_failed(d, dqp, "icount mismatch",
-			be64_to_cpu(dqp->q_core.d_icount),
-			d->d_icount, 0);
-		err++;
-	}
-	if (be64_to_cpu(dqp->q_core.d_bcount) != d->d_bcount) {
-		xfs_qm_dqtest_failed(d, dqp, "bcount mismatch",
-			be64_to_cpu(dqp->q_core.d_bcount),
-			d->d_bcount, 0);
-		err++;
-	}
-	if (dqp->q_core.d_blk_softlimit &&
-	    be64_to_cpu(dqp->q_core.d_bcount) >=
-	    be64_to_cpu(dqp->q_core.d_blk_softlimit)) {
-		if (!dqp->q_core.d_btimer && dqp->q_core.d_id) {
-			xfs_debug(dqp->q_mount,
-				"%d [%s] BLK TIMER NOT STARTED",
-				d->d_id, DQFLAGTO_TYPESTR(d));
-			err++;
-		}
-	}
-	if (dqp->q_core.d_ino_softlimit &&
-	    be64_to_cpu(dqp->q_core.d_icount) >=
-	    be64_to_cpu(dqp->q_core.d_ino_softlimit)) {
-		if (!dqp->q_core.d_itimer && dqp->q_core.d_id) {
-			xfs_debug(dqp->q_mount,
-				"%d [%s] INO TIMER NOT STARTED",
-				d->d_id, DQFLAGTO_TYPESTR(d));
-			err++;
-		}
-	}
-#ifdef QUOTADEBUG
-	if (!err) {
-		xfs_debug(dqp->q_mount, "%d [%s] qchecked",
-			d->d_id, DQFLAGTO_TYPESTR(d));
-	}
-#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);
-	list_for_each_entry(d, &h->qh_list, q_hashlist) {
-		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;
-	INIT_LIST_HEAD(&d->q_hashlist);
-	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,
-	xfs_dqid_t	projid,
-	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);
-	else if (XFS_IS_PQUOTA_ON(mp))
-		xfs_qm_internalqcheck_dqget(mp, projid, XFS_DQ_PROJ, gd);
-}
-
-
-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;
-		xfs_debug(mp, "%s: ino=%llu, uqino=%llu, gqino=%llu\n",
-			__func__, (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;
-	if ((error = xfs_iget(mp, NULL, ino, 0, lock_flags, &ip))) {
-		*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) {
-		xfs_iunlock(ip, lock_flags);
-		IRELE(ip);
-		ipreleased = B_TRUE;
-		goto again;
-	}
-	xfs_qm_internalqcheck_get_dquots(mp,
-					(xfs_dqid_t) ip->i_d.di_uid,
-					(xfs_dqid_t) xfs_get_projid(ip),
-					(xfs_dqid_t) ip->i_d.di_gid,
-					&ud, &gd);
-	if (XFS_IS_UQUOTA_ON(mp)) {
-		ASSERT(ud);
-		xfs_qm_internalqcheck_dqadjust(ip, ud);
-	}
-	if (XFS_IS_OQUOTA_ON(mp)) {
-		ASSERT(gd);
-		xfs_qm_internalqcheck_dqadjust(ip, gd);
-	}
-	xfs_iunlock(ip, lock_flags);
-	IRELE(ip);
-	*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);
-
-	xfs_log_force(mp, XFS_LOG_SYNC);
-	XFS_bflush(mp->m_ddev_targp);
-	xfs_log_force(mp, XFS_LOG_SYNC);
-	XFS_bflush(mp->m_ddev_targp);
-
-	mutex_lock(&qcheck_lock);
-	/* 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
-		 */
-		error = xfs_bulkstat(mp, &lastino, &count,
-				 xfs_qm_internalqcheck_adjust,
-				 0, NULL, &done);
-		if (error) {
-			xfs_debug(mp, "Bulkstat returned error 0x%x", error);
-			break;
-		}
-	} while (!done);
-
-	xfs_debug(mp, "Checking results against system dquots");
-	for (i = 0; i < qmtest_hashmask; i++) {
-		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) {
-			xfs_dqtest_cmp(d);
-			kmem_free(d);
-		}
-		h = &qmtest_gdqtab[i];
-		list_for_each_entry_safe(d, n, &h->qh_list, q_hashlist) {
-			xfs_dqtest_cmp(d);
-			kmem_free(d);
-		}
-	}
-
-	if (qmtest_nfails) {
-		xfs_debug(mp, "******** quotacheck failed  ********");
-		xfs_debug(mp, "failures = %d", qmtest_nfails);
-	} else {
-		xfs_debug(mp, "******** quotacheck successful! ********");
-	}
-	kmem_free(qmtest_udqtab);
-	kmem_free(qmtest_gdqtab);
-	mutex_unlock(&qcheck_lock);
-	return (qmtest_nfails);
-}
-
-#endif /* DEBUG */
@@ -387,18 +387,18 @@
 				qtrx->qt_delbcnt_delta;
 			totalrtbdelta = qtrx->qt_rtbcount_delta +
 				qtrx->qt_delrtb_delta;
-#ifdef QUOTADEBUG
+#ifdef DEBUG
 			if (totalbdelta < 0)
 				ASSERT(be64_to_cpu(d->d_bcount) >=
-				       (xfs_qcnt_t) -totalbdelta);
+				       -totalbdelta);
  
 			if (totalrtbdelta < 0)
 				ASSERT(be64_to_cpu(d->d_rtbcount) >=
-				       (xfs_qcnt_t) -totalrtbdelta);
+				       -totalrtbdelta);
  
 			if (qtrx->qt_icount_delta < 0)
 				ASSERT(be64_to_cpu(d->d_icount) >=
-				       (xfs_qcnt_t) -qtrx->qt_icount_delta);
+				       -qtrx->qt_icount_delta);
 #endif
 			if (totalbdelta)
 				be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta);
@@ -642,11 +642,6 @@
 	    ((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) ||
 	     (XFS_IS_OQUOTA_ENFORCED(dqp->q_mount) &&
 	      (XFS_QM_ISPDQ(dqp) || XFS_QM_ISGDQ(dqp))))) {
-#ifdef QUOTADEBUG
-		xfs_debug(mp,
-			"BLK Res: nblks=%ld + resbcount=%Ld > hardlimit=%Ld?",
-			nblks, *resbcountp, hardlimit);
-#endif
 		if (nblks > 0) {
 			/*
 			 * dquot is locked already. See if we'd go over the
@@ -22,7 +22,6 @@
 #define STATIC
 #define DEBUG 1
 #define XFS_BUF_LOCK_TRACKING 1
-/* #define QUOTADEBUG 1 */
 #endif
  
 #include <linux-2.6/xfs_linux.h>
@@ -1089,10 +1089,6 @@
 	if (mp->m_flags & XFS_MOUNT_RDONLY)
 		return 0;
  
-#ifdef QUOTADEBUG
-	xfs_notice(mp, "Writing superblock quota changes");
-#endif
-
 	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
 	error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
 				      XFS_DEFAULT_LOG_COUNT);
...	...	@@ -220,7 +220,7 @@
220	220	{
221	221	ASSERT(d->d_id);
222	222
223		-#ifdef QUOTADEBUG
	223	+#ifdef DEBUG
224	224	if (d->d_blk_hardlimit)
225	225	ASSERT(be64_to_cpu(d->d_blk_softlimit) <=
226	226	be64_to_cpu(d->d_blk_hardlimit));
...	...	@@ -231,6 +231,7 @@
231	231	ASSERT(be64_to_cpu(d->d_rtb_softlimit) <=
232	232	be64_to_cpu(d->d_rtb_hardlimit));
233	233	#endif
	234	+
234	235	if (!d->d_btimer) {
235	236	if ((d->d_blk_softlimit &&
236	237	(be64_to_cpu(d->d_bcount) >=
...	...	@@ -1422,45 +1423,6 @@
1422	1423	return (0);
1423	1424	}
1424	1425
1425		-
1426		-#ifdef QUOTADEBUG
1427		-void
1428		-xfs_qm_dqprint(xfs_dquot_t *dqp)
1429		-{
1430		- struct xfs_mount *mp = dqp->q_mount;
1431		-
1432		- xfs_debug(mp, "-----------KERNEL DQUOT----------------");
1433		- xfs_debug(mp, "---- dquotID = %d",
1434		- (int)be32_to_cpu(dqp->q_core.d_id));
1435		- xfs_debug(mp, "---- type = %s", DQFLAGTO_TYPESTR(dqp));
1436		- xfs_debug(mp, "---- fs = 0x%p", dqp->q_mount);
1437		- xfs_debug(mp, "---- blkno = 0x%x", (int) dqp->q_blkno);
1438		- xfs_debug(mp, "---- boffset = 0x%x", (int) dqp->q_bufoffset);
1439		- xfs_debug(mp, "---- blkhlimit = %Lu (0x%x)",
1440		- be64_to_cpu(dqp->q_core.d_blk_hardlimit),
1441		- (int)be64_to_cpu(dqp->q_core.d_blk_hardlimit));
1442		- xfs_debug(mp, "---- blkslimit = %Lu (0x%x)",
1443		- be64_to_cpu(dqp->q_core.d_blk_softlimit),
1444		- (int)be64_to_cpu(dqp->q_core.d_blk_softlimit));
1445		- xfs_debug(mp, "---- inohlimit = %Lu (0x%x)",
1446		- be64_to_cpu(dqp->q_core.d_ino_hardlimit),
1447		- (int)be64_to_cpu(dqp->q_core.d_ino_hardlimit));
1448		- xfs_debug(mp, "---- inoslimit = %Lu (0x%x)",
1449		- be64_to_cpu(dqp->q_core.d_ino_softlimit),
1450		- (int)be64_to_cpu(dqp->q_core.d_ino_softlimit));
1451		- xfs_debug(mp, "---- bcount = %Lu (0x%x)",
1452		- be64_to_cpu(dqp->q_core.d_bcount),
1453		- (int)be64_to_cpu(dqp->q_core.d_bcount));
1454		- xfs_debug(mp, "---- icount = %Lu (0x%x)",
1455		- be64_to_cpu(dqp->q_core.d_icount),
1456		- (int)be64_to_cpu(dqp->q_core.d_icount));
1457		- xfs_debug(mp, "---- btimer = %d",
1458		- (int)be32_to_cpu(dqp->q_core.d_btimer));
1459		- xfs_debug(mp, "---- itimer = %d",
1460		- (int)be32_to_cpu(dqp->q_core.d_itimer));
1461		- xfs_debug(mp, "---------------------------");
1462		-}
1463		-#endif
1464	1426
1465	1427	/*
1466	1428	* Give the buffer a little push if it is incore and
...	...	@@ -116,12 +116,6 @@
116	116	(XFS_IS_UQUOTA_ON((d)->q_mount)) : \
117	117	(XFS_IS_OQUOTA_ON((d)->q_mount))))
118	118
119		-#ifdef QUOTADEBUG
120		-extern void xfs_qm_dqprint(xfs_dquot_t *);
121		-#else
122		-#define xfs_qm_dqprint(a)
123		-#endif
124		-
125	119	extern void xfs_qm_dqdestroy(xfs_dquot_t *);
126	120	extern int xfs_qm_dqflush(xfs_dquot_t *, uint);
127	121	extern int xfs_qm_dqpurge(xfs_dquot_t *);
...	...	@@ -67,32 +67,6 @@
67	67	.seeks = DEFAULT_SEEKS,
68	68	};
69	69
70		-#ifdef DEBUG
71		-extern struct mutex qcheck_lock;
72		-#endif
73		-
74		-#ifdef QUOTADEBUG
75		-static void
76		-xfs_qm_dquot_list_print(
77		- struct xfs_mount *mp)
78		-{
79		- xfs_dquot_t *dqp;
80		- int i = 0;
81		-
82		- list_for_each_entry(dqp, &mp->m_quotainfo->qi_dqlist_lock, qi_mplist) {
83		- xfs_debug(mp, " %d. \"%d (%s)\" "
84		- "bcnt = %lld, icnt = %lld, refs = %d",
85		- i++, be32_to_cpu(dqp->q_core.d_id),
86		- DQFLAGTO_TYPESTR(dqp),
87		- (long long)be64_to_cpu(dqp->q_core.d_bcount),
88		- (long long)be64_to_cpu(dqp->q_core.d_icount),
89		- dqp->q_nrefs);
90		- }
91		-}
92		-#else
93		-static void xfs_qm_dquot_list_print(struct xfs_mount *mp) { }
94		-#endif
95		-
96	70	/*
97	71	* Initialize the XQM structure.
98	72	* Note that there is not one quota manager per file system.
...	...	@@ -165,9 +139,6 @@
165	139	atomic_set(&xqm->qm_totaldquots, 0);
166	140	xqm->qm_dqfree_ratio = XFS_QM_DQFREE_RATIO;
167	141	xqm->qm_nrefs = 0;
168		-#ifdef DEBUG
169		- mutex_init(&qcheck_lock);
170		-#endif
171	142	return xqm;
172	143
173	144	out_free_udqhash:
...	...	@@ -204,9 +175,6 @@
204	175	mutex_lock(&xqm->qm_dqfrlist_lock);
205	176	list_for_each_entry_safe(dqp, n, &xqm->qm_dqfrlist, q_freelist) {
206	177	xfs_dqlock(dqp);
207		-#ifdef QUOTADEBUG
208		- xfs_debug(dqp->q_mount, "FREELIST destroy 0x%p", dqp);
209		-#endif
210	178	list_del_init(&dqp->q_freelist);
211	179	xfs_Gqm->qm_dqfrlist_cnt--;
212	180	xfs_dqunlock(dqp);
...	...	@@ -214,9 +182,6 @@
214	182	}
215	183	mutex_unlock(&xqm->qm_dqfrlist_lock);
216	184	mutex_destroy(&xqm->qm_dqfrlist_lock);
217		-#ifdef DEBUG
218		- mutex_destroy(&qcheck_lock);
219		-#endif
220	185	kmem_free(xqm);
221	186	}
222	187
...	...	@@ -409,11 +374,6 @@
409	374	xfs_warn(mp, "Failed to initialize disk quotas.");
410	375	return;
411	376	}
412		-
413		-#ifdef QUOTADEBUG
414		- if (XFS_IS_QUOTA_ON(mp))
415		- xfs_qm_internalqcheck(mp);
416		-#endif
417	377	}
418	378
419	379	/*
...	...	@@ -866,8 +826,8 @@
866	826	}
867	827
868	828	done:
869		-#ifdef QUOTADEBUG
870		- if (! error) {
	829	+#ifdef DEBUG
	830	+ if (!error) {
871	831	if (XFS_IS_UQUOTA_ON(mp))
872	832	ASSERT(ip->i_udquot);
873	833	if (XFS_IS_OQUOTA_ON(mp))
...	...	@@ -1733,8 +1693,6 @@
1733	1693	mp->m_qflags &= ~(XFS_OQUOTA_CHKD \| XFS_UQUOTA_CHKD);
1734	1694	mp->m_qflags \|= flags;
1735	1695
1736		- xfs_qm_dquot_list_print(mp);
1737		-
1738	1696	error_return:
1739	1697	if (error) {
1740	1698	xfs_warn(mp,
...	...	@@ -2096,9 +2054,6 @@
2096	2054	xfs_trans_t *tp;
2097	2055	int error;
2098	2056
2099		-#ifdef QUOTADEBUG
2100		- xfs_notice(mp, "Writing superblock quota changes");
2101		-#endif
2102	2057	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
2103	2058	if ((error = xfs_trans_reserve(tp, 0,
2104	2059	mp->m_sb.sb_sectsize + 128, 0,
...	...	@@ -163,11 +163,5 @@
163	163	extern int xfs_qm_scall_quotaon(xfs_mount_t *, uint);
164	164	extern int xfs_qm_scall_quotaoff(xfs_mount_t *, uint);
165	165
166		-#ifdef DEBUG
167		-extern int xfs_qm_internalqcheck(xfs_mount_t *);
168		-#else
169		-#define xfs_qm_internalqcheck(mp) (0)
170		-#endif
171		-
172	166	#endif /* __XFS_QM_H__ */
...	...	@@ -622,7 +622,6 @@
622	622	xfs_trans_log_dquot(tp, dqp);
623	623
624	624	error = xfs_trans_commit(tp, 0);
625		- xfs_qm_dqprint(dqp);
626	625	xfs_qm_dqrele(dqp);
627	626
628	627	out_unlock:
...	...	@@ -657,7 +656,6 @@
657	656	xfs_qm_dqput(dqp);
658	657	return XFS_ERROR(ENOENT);
659	658	}
660		- /* xfs_qm_dqprint(dqp); */
661	659	/*
662	660	* Convert the disk dquot to the exportable format
663	661	*/
...	...	@@ -906,355 +904,4 @@
906	904	ASSERT(mp->m_quotainfo);
907	905	xfs_inode_ag_iterator(mp, xfs_dqrele_inode, flags);
908	906	}
909		-
910		-/------------------------------------------------------------------------/
911		-#ifdef DEBUG
912		-/*
913		- * This contains all the test functions for XFS disk quotas.
914		- * Currently it does a quota accounting check. ie. it walks through
915		- * all inodes in the file system, calculating the dquot accounting fields,
916		- * and prints out any inconsistencies.
917		- */
918		-xfs_dqhash_t *qmtest_udqtab;
919		-xfs_dqhash_t *qmtest_gdqtab;
920		-int qmtest_hashmask;
921		-int qmtest_nfails;
922		-struct mutex qcheck_lock;
923		-
924		-#define DQTEST_HASHVAL(mp, id) (((__psunsigned_t)(mp) + \
925		- (__psunsigned_t)(id)) & \
926		- (qmtest_hashmask - 1))
927		-
928		-#define DQTEST_HASH(mp, id, type) ((type & XFS_DQ_USER) ? \
929		- (qmtest_udqtab + \
930		- DQTEST_HASHVAL(mp, id)) : \
931		- (qmtest_gdqtab + \
932		- DQTEST_HASHVAL(mp, id)))
933		-
934		-#define DQTEST_LIST_PRINT(l, NXT, title) \
935		-{ \
936		- xfs_dqtest_t *dqp; int i = 0;\
937		- xfs_debug(NULL, "%s (#%d)", title, (int) (l)->qh_nelems); \
938		- for (dqp = (xfs_dqtest_t *)(l)->qh_next; dqp != NULL; \
939		- dqp = (xfs_dqtest_t *)dqp->NXT) { \
940		- xfs_debug(dqp->q_mount, \
941		- " %d. \"%d (%s)\" bcnt = %d, icnt = %d", \
942		- ++i, dqp->d_id, DQFLAGTO_TYPESTR(dqp), \
943		- dqp->d_bcount, dqp->d_icount); } \
944		-}
945		-
946		-typedef struct dqtest {
947		- uint dq_flags; /* various flags (XFS_DQ_) /
948		- struct list_head q_hashlist;
949		- xfs_dqhash_t q_hash; / the hashchain header */
950		- xfs_mount_t q_mount; / filesystem this relates to */
951		- xfs_dqid_t d_id; /* user id or group id */
952		- xfs_qcnt_t d_bcount; /* # disk blocks owned by the user */
953		- xfs_qcnt_t d_icount; /* # inodes owned by the user */
954		-} xfs_dqtest_t;
955		-
956		-STATIC void
957		-xfs_qm_hashinsert(xfs_dqhash_t h, xfs_dqtest_t dqp)
958		-{
959		- list_add(&dqp->q_hashlist, &h->qh_list);
960		- h->qh_version++;
961		- h->qh_nelems++;
962		-}
963		-STATIC void
964		-xfs_qm_dqtest_print(
965		- struct xfs_mount *mp,
966		- struct dqtest *d)
967		-{
968		- xfs_debug(mp, "-----------DQTEST DQUOT----------------");
969		- xfs_debug(mp, "---- dquot ID = %d", d->d_id);
970		- xfs_debug(mp, "---- fs = 0x%p", d->q_mount);
971		- xfs_debug(mp, "---- bcount = %Lu (0x%x)",
972		- d->d_bcount, (int)d->d_bcount);
973		- xfs_debug(mp, "---- icount = %Lu (0x%x)",
974		- d->d_icount, (int)d->d_icount);
975		- xfs_debug(mp, "---------------------------");
976		-}
977		-
978		-STATIC void
979		-xfs_qm_dqtest_failed(
980		- xfs_dqtest_t *d,
981		- xfs_dquot_t *dqp,
982		- char *reason,
983		- xfs_qcnt_t a,
984		- xfs_qcnt_t b,
985		- int error)
986		-{
987		- qmtest_nfails++;
988		- if (error)
989		- xfs_debug(dqp->q_mount,
990		- "quotacheck failed id=%d, err=%d\nreason: %s",
991		- d->d_id, error, reason);
992		- else
993		- xfs_debug(dqp->q_mount,
994		- "quotacheck failed id=%d (%s) [%d != %d]",
995		- d->d_id, reason, (int)a, (int)b);
996		- xfs_qm_dqtest_print(dqp->q_mount, d);
997		- if (dqp)
998		- xfs_qm_dqprint(dqp);
999		-}
1000		-
1001		-STATIC int
1002		-xfs_dqtest_cmp2(
1003		- xfs_dqtest_t *d,
1004		- xfs_dquot_t *dqp)
1005		-{
1006		- int err = 0;
1007		- if (be64_to_cpu(dqp->q_core.d_icount) != d->d_icount) {
1008		- xfs_qm_dqtest_failed(d, dqp, "icount mismatch",
1009		- be64_to_cpu(dqp->q_core.d_icount),
1010		- d->d_icount, 0);
1011		- err++;
1012		- }
1013		- if (be64_to_cpu(dqp->q_core.d_bcount) != d->d_bcount) {
1014		- xfs_qm_dqtest_failed(d, dqp, "bcount mismatch",
1015		- be64_to_cpu(dqp->q_core.d_bcount),
1016		- d->d_bcount, 0);
1017		- err++;
1018		- }
1019		- if (dqp->q_core.d_blk_softlimit &&
1020		- be64_to_cpu(dqp->q_core.d_bcount) >=
1021		- be64_to_cpu(dqp->q_core.d_blk_softlimit)) {
1022		- if (!dqp->q_core.d_btimer && dqp->q_core.d_id) {
1023		- xfs_debug(dqp->q_mount,
1024		- "%d [%s] BLK TIMER NOT STARTED",
1025		- d->d_id, DQFLAGTO_TYPESTR(d));
1026		- err++;
1027		- }
1028		- }
1029		- if (dqp->q_core.d_ino_softlimit &&
1030		- be64_to_cpu(dqp->q_core.d_icount) >=
1031		- be64_to_cpu(dqp->q_core.d_ino_softlimit)) {
1032		- if (!dqp->q_core.d_itimer && dqp->q_core.d_id) {
1033		- xfs_debug(dqp->q_mount,
1034		- "%d [%s] INO TIMER NOT STARTED",
1035		- d->d_id, DQFLAGTO_TYPESTR(d));
1036		- err++;
1037		- }
1038		- }
1039		-#ifdef QUOTADEBUG
1040		- if (!err) {
1041		- xfs_debug(dqp->q_mount, "%d [%s] qchecked",
1042		- d->d_id, DQFLAGTO_TYPESTR(d));
1043		- }
1044		-#endif
1045		- return (err);
1046		-}
1047		-
1048		-STATIC void
1049		-xfs_dqtest_cmp(
1050		- xfs_dqtest_t *d)
1051		-{
1052		- xfs_dquot_t *dqp;
1053		- int error;
1054		-
1055		- /* xfs_qm_dqtest_print(d); */
1056		- if ((error = xfs_qm_dqget(d->q_mount, NULL, d->d_id, d->dq_flags, 0,
1057		- &dqp))) {
1058		- xfs_qm_dqtest_failed(d, NULL, "dqget failed", 0, 0, error);
1059		- return;
1060		- }
1061		- xfs_dqtest_cmp2(d, dqp);
1062		- xfs_qm_dqput(dqp);
1063		-}
1064		-
1065		-STATIC int
1066		-xfs_qm_internalqcheck_dqget(
1067		- xfs_mount_t *mp,
1068		- xfs_dqid_t id,
1069		- uint type,
1070		- xfs_dqtest_t **O_dq)
1071		-{
1072		- xfs_dqtest_t *d;
1073		- xfs_dqhash_t *h;
1074		-
1075		- h = DQTEST_HASH(mp, id, type);
1076		- list_for_each_entry(d, &h->qh_list, q_hashlist) {
1077		- if (d->d_id == id && mp == d->q_mount) {
1078		- *O_dq = d;
1079		- return (0);
1080		- }
1081		- }
1082		- d = kmem_zalloc(sizeof(xfs_dqtest_t), KM_SLEEP);
1083		- d->dq_flags = type;
1084		- d->d_id = id;
1085		- d->q_mount = mp;
1086		- d->q_hash = h;
1087		- INIT_LIST_HEAD(&d->q_hashlist);
1088		- xfs_qm_hashinsert(h, d);
1089		- *O_dq = d;
1090		- return (0);
1091		-}
1092		-
1093		-STATIC void
1094		-xfs_qm_internalqcheck_get_dquots(
1095		- xfs_mount_t *mp,
1096		- xfs_dqid_t uid,
1097		- xfs_dqid_t projid,
1098		- xfs_dqid_t gid,
1099		- xfs_dqtest_t **ud,
1100		- xfs_dqtest_t **gd)
1101		-{
1102		- if (XFS_IS_UQUOTA_ON(mp))
1103		- xfs_qm_internalqcheck_dqget(mp, uid, XFS_DQ_USER, ud);
1104		- if (XFS_IS_GQUOTA_ON(mp))
1105		- xfs_qm_internalqcheck_dqget(mp, gid, XFS_DQ_GROUP, gd);
1106		- else if (XFS_IS_PQUOTA_ON(mp))
1107		- xfs_qm_internalqcheck_dqget(mp, projid, XFS_DQ_PROJ, gd);
1108		-}
1109		-
1110		-
1111		-STATIC void
1112		-xfs_qm_internalqcheck_dqadjust(
1113		- xfs_inode_t *ip,
1114		- xfs_dqtest_t *d)
1115		-{
1116		- d->d_icount++;
1117		- d->d_bcount += (xfs_qcnt_t)ip->i_d.di_nblocks;
1118		-}
1119		-
1120		-STATIC int
1121		-xfs_qm_internalqcheck_adjust(
1122		- xfs_mount_t mp, / mount point for filesystem */
1123		- xfs_ino_t ino, /* inode number to get data for */
1124		- void __user buffer, / not used */
1125		- int ubsize, /* not used */
1126		- int ubused, / not used */
1127		- int res) / bulkstat result code */
1128		-{
1129		- xfs_inode_t *ip;
1130		- xfs_dqtest_t ud, gd;
1131		- uint lock_flags;
1132		- boolean_t ipreleased;
1133		- int error;
1134		-
1135		- ASSERT(XFS_IS_QUOTA_RUNNING(mp));
1136		-
1137		- if (ino == mp->m_sb.sb_uquotino \|\| ino == mp->m_sb.sb_gquotino) {
1138		- *res = BULKSTAT_RV_NOTHING;
1139		- xfs_debug(mp, "%s: ino=%llu, uqino=%llu, gqino=%llu\n",
1140		- __func__, (unsigned long long) ino,
1141		- (unsigned long long) mp->m_sb.sb_uquotino,
1142		- (unsigned long long) mp->m_sb.sb_gquotino);
1143		- return XFS_ERROR(EINVAL);
1144		- }
1145		- ipreleased = B_FALSE;
1146		- again:
1147		- lock_flags = XFS_ILOCK_SHARED;
1148		- if ((error = xfs_iget(mp, NULL, ino, 0, lock_flags, &ip))) {
1149		- *res = BULKSTAT_RV_NOTHING;
1150		- return (error);
1151		- }
1152		-
1153		- /*
1154		- * This inode can have blocks after eof which can get released
1155		- * when we send it to inactive. Since we don't check the dquot
1156		- * until the after all our calculations are done, we must get rid
1157		- * of those now.
1158		- */
1159		- if (! ipreleased) {
1160		- xfs_iunlock(ip, lock_flags);
1161		- IRELE(ip);
1162		- ipreleased = B_TRUE;
1163		- goto again;
1164		- }
1165		- xfs_qm_internalqcheck_get_dquots(mp,
1166		- (xfs_dqid_t) ip->i_d.di_uid,
1167		- (xfs_dqid_t) xfs_get_projid(ip),
1168		- (xfs_dqid_t) ip->i_d.di_gid,
1169		- &ud, &gd);
1170		- if (XFS_IS_UQUOTA_ON(mp)) {
1171		- ASSERT(ud);
1172		- xfs_qm_internalqcheck_dqadjust(ip, ud);
1173		- }
1174		- if (XFS_IS_OQUOTA_ON(mp)) {
1175		- ASSERT(gd);
1176		- xfs_qm_internalqcheck_dqadjust(ip, gd);
1177		- }
1178		- xfs_iunlock(ip, lock_flags);
1179		- IRELE(ip);
1180		- *res = BULKSTAT_RV_DIDONE;
1181		- return (0);
1182		-}
1183		-
1184		-
1185		-/* PRIVATE, debugging */
1186		-int
1187		-xfs_qm_internalqcheck(
1188		- xfs_mount_t *mp)
1189		-{
1190		- xfs_ino_t lastino;
1191		- int done, count;
1192		- int i;
1193		- int error;
1194		-
1195		- lastino = 0;
1196		- qmtest_hashmask = 32;
1197		- count = 5;
1198		- done = 0;
1199		- qmtest_nfails = 0;
1200		-
1201		- if (! XFS_IS_QUOTA_ON(mp))
1202		- return XFS_ERROR(ESRCH);
1203		-
1204		- xfs_log_force(mp, XFS_LOG_SYNC);
1205		- XFS_bflush(mp->m_ddev_targp);
1206		- xfs_log_force(mp, XFS_LOG_SYNC);
1207		- XFS_bflush(mp->m_ddev_targp);
1208		-
1209		- mutex_lock(&qcheck_lock);
1210		- /* There should be absolutely no quota activity while this
1211		- is going on. */
1212		- qmtest_udqtab = kmem_zalloc(qmtest_hashmask *
1213		- sizeof(xfs_dqhash_t), KM_SLEEP);
1214		- qmtest_gdqtab = kmem_zalloc(qmtest_hashmask *
1215		- sizeof(xfs_dqhash_t), KM_SLEEP);
1216		- do {
1217		- /*
1218		- * Iterate thru all the inodes in the file system,
1219		- * adjusting the corresponding dquot counters
1220		- */
1221		- error = xfs_bulkstat(mp, &lastino, &count,
1222		- xfs_qm_internalqcheck_adjust,
1223		- 0, NULL, &done);
1224		- if (error) {
1225		- xfs_debug(mp, "Bulkstat returned error 0x%x", error);
1226		- break;
1227		- }
1228		- } while (!done);
1229		-
1230		- xfs_debug(mp, "Checking results against system dquots");
1231		- for (i = 0; i < qmtest_hashmask; i++) {
1232		- xfs_dqtest_t d, n;
1233		- xfs_dqhash_t *h;
1234		-
1235		- h = &qmtest_udqtab[i];
1236		- list_for_each_entry_safe(d, n, &h->qh_list, q_hashlist) {
1237		- xfs_dqtest_cmp(d);
1238		- kmem_free(d);
1239		- }
1240		- h = &qmtest_gdqtab[i];
1241		- list_for_each_entry_safe(d, n, &h->qh_list, q_hashlist) {
1242		- xfs_dqtest_cmp(d);
1243		- kmem_free(d);
1244		- }
1245		- }
1246		-
1247		- if (qmtest_nfails) {
1248		- xfs_debug(mp, "****** quotacheck failed ******");
1249		- xfs_debug(mp, "failures = %d", qmtest_nfails);
1250		- } else {
1251		- xfs_debug(mp, "****** quotacheck successful! ******");
1252		- }
1253		- kmem_free(qmtest_udqtab);
1254		- kmem_free(qmtest_gdqtab);
1255		- mutex_unlock(&qcheck_lock);
1256		- return (qmtest_nfails);
1257		-}
1258		-
1259		-#endif /* DEBUG */
...	...	@@ -387,18 +387,18 @@
387	387	qtrx->qt_delbcnt_delta;
388	388	totalrtbdelta = qtrx->qt_rtbcount_delta +
389	389	qtrx->qt_delrtb_delta;
390		-#ifdef QUOTADEBUG
	390	+#ifdef DEBUG
391	391	if (totalbdelta < 0)
392	392	ASSERT(be64_to_cpu(d->d_bcount) >=
393		- (xfs_qcnt_t) -totalbdelta);
	393	+ -totalbdelta);
394	394
395	395	if (totalrtbdelta < 0)
396	396	ASSERT(be64_to_cpu(d->d_rtbcount) >=
397		- (xfs_qcnt_t) -totalrtbdelta);
	397	+ -totalrtbdelta);
398	398
399	399	if (qtrx->qt_icount_delta < 0)
400	400	ASSERT(be64_to_cpu(d->d_icount) >=
401		- (xfs_qcnt_t) -qtrx->qt_icount_delta);
	401	+ -qtrx->qt_icount_delta);
402	402	#endif
403	403	if (totalbdelta)
404	404	be64_add_cpu(&d->d_bcount, (xfs_qcnt_t)totalbdelta);
...	...	@@ -642,11 +642,6 @@
642	642	((XFS_IS_UQUOTA_ENFORCED(dqp->q_mount) && XFS_QM_ISUDQ(dqp)) \|\|
643	643	(XFS_IS_OQUOTA_ENFORCED(dqp->q_mount) &&
644	644	(XFS_QM_ISPDQ(dqp) \|\| XFS_QM_ISGDQ(dqp))))) {
645		-#ifdef QUOTADEBUG
646		- xfs_debug(mp,
647		- "BLK Res: nblks=%ld + resbcount=%Ld > hardlimit=%Ld?",
648		- nblks, *resbcountp, hardlimit);
649		-#endif
650	645	if (nblks > 0) {
651	646	/*
652	647	* dquot is locked already. See if we'd go over the
...	...	@@ -22,7 +22,6 @@
22	22	#define STATIC
23	23	#define DEBUG 1
24	24	#define XFS_BUF_LOCK_TRACKING 1
25		-/* #define QUOTADEBUG 1 */
26	25	#endif
27	26
28	27	#include <linux-2.6/xfs_linux.h>
...	...	@@ -1089,10 +1089,6 @@
1089	1089	if (mp->m_flags & XFS_MOUNT_RDONLY)
1090	1090	return 0;
1091	1091
1092		-#ifdef QUOTADEBUG
1093		- xfs_notice(mp, "Writing superblock quota changes");
1094		-#endif
1095		-
1096	1092	tp = xfs_trans_alloc(mp, XFS_TRANS_QM_SBCHANGE);
1097	1093	error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
1098	1094	XFS_DEFAULT_LOG_COUNT);