Revert "xfs: fix filesystsem freeze race in xfs_trans_alloc"

This reverts commit 7a249cf8.

That commit created a situation that could lead to a filesystem
hang.  As Dave Chinner pointed out, xfs_trans_alloc() could hold a
reference to m_active_trans (i.e., keep it non-zero) and then wait
for SB_FREEZE_TRANS to complete.  Meanwhile a filesystem freeze
request could set SB_FREEZE_TRANS and then wait for m_active_trans
to drop to zero.  Nobody benefits from this sequence of events...
Signed-off-by: NChristoph Hellwig <hch@lst.de>
Signed-off-by: NAlex Elder <aelder@sgi.com>

fs/xfs/xfs_fsops.c

@@ -626,7 +626,7 @@ xfs_fs_log_dummy(
 	xfs_trans_t	*tp;
 	int		error;
 
-	tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP, false);
+	tp = _xfs_trans_alloc(mp, XFS_TRANS_DUMMY1, KM_SLEEP);
 	error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
 					XFS_DEFAULT_LOG_COUNT);
 	if (error) {

fs/xfs/xfs_iomap.c

@@ -688,7 +688,8 @@ xfs_iomap_write_unwritten(
 		 * the same inode that we complete here and might deadlock
 		 * on the iolock.
 		 */
-		tp = _xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE, KM_NOFS, true);
+		xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
+		tp = _xfs_trans_alloc(mp, XFS_TRANS_STRAT_WRITE, KM_NOFS);
 		tp->t_flags |= XFS_TRANS_RESERVE;
 		error = xfs_trans_reserve(tp, resblks,
 				XFS_WRITE_LOG_RES(mp), 0,

fs/xfs/xfs_mount.c

@@ -1559,9 +1559,15 @@ xfs_fs_writable(xfs_mount_t *mp)
 }
 
 /*
+ * xfs_log_sbcount
+ *
  * Called either periodically to keep the on disk superblock values
  * roughly up to date or from unmount to make sure the values are
  * correct on a clean unmount.
+ *
+ * Note this code can be called during the process of freezing, so
+ * we may need to use the transaction allocator which does not not
+ * block when the transaction subsystem is in its frozen state.
  */
 int
 xfs_log_sbcount(
@@ -1583,13 +1589,7 @@ xfs_log_sbcount(
 	if (!xfs_sb_version_haslazysbcount(&mp->m_sb))
 		return 0;
 
-	/*
-	 * We can be called during the process of freezing, so make sure
-	 * we go ahead even if the frozen for new transactions.  We will
-	 * always use a sync transaction in the freeze path to make sure
-	 * the transaction has completed by the time we return.
-	 */
-	tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP, false);
+	tp = _xfs_trans_alloc(mp, XFS_TRANS_SB_COUNT, KM_SLEEP);
 	error = xfs_trans_reserve(tp, 0, mp->m_sb.sb_sectsize + 128, 0, 0,
 					XFS_DEFAULT_LOG_COUNT);
 	if (error) {

fs/xfs/xfs_trans.c

@@ -566,24 +566,31 @@ xfs_trans_init(
 
 /*
  * This routine is called to allocate a transaction structure.
- *
  * The type parameter indicates the type of the transaction.  These
  * are enumerated in xfs_trans.h.
+ *
+ * Dynamically allocate the transaction structure from the transaction
+ * zone, initialize it, and return it to the caller.
  */
-struct xfs_trans *
+xfs_trans_t *
+xfs_trans_alloc(
+	xfs_mount_t	*mp,
+	uint		type)
+{
+	xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
+	return _xfs_trans_alloc(mp, type, KM_SLEEP);
+}
+
+xfs_trans_t *
 _xfs_trans_alloc(
-	struct xfs_mount	*mp,
-	uint			type,
-	uint			memflags,
-	bool			wait_for_freeze)
+	xfs_mount_t	*mp,
+	uint		type,
+	uint		memflags)
 {
-	struct xfs_trans	*tp;
+	xfs_trans_t	*tp;
 
 	atomic_inc(&mp->m_active_trans);
 
-	if (wait_for_freeze)
-		xfs_wait_for_freeze(mp, SB_FREEZE_TRANS);
-
 	tp = kmem_zone_zalloc(xfs_trans_zone, memflags);
 	tp->t_magic = XFS_TRANS_MAGIC;
 	tp->t_type = type;

fs/xfs/xfs_trans.h

@@ -447,14 +447,8 @@ typedef struct xfs_trans {
 /*
  * XFS transaction mechanism exported interfaces.
  */
-xfs_trans_t	*_xfs_trans_alloc(struct xfs_mount *, uint, uint, bool);
-
-static inline struct xfs_trans *
-xfs_trans_alloc(struct xfs_mount *mp, uint type)
-{
-	return _xfs_trans_alloc(mp, type, KM_SLEEP, true);
-}
-
+xfs_trans_t	*xfs_trans_alloc(struct xfs_mount *, uint);
+xfs_trans_t	*_xfs_trans_alloc(struct xfs_mount *, uint, uint);
 xfs_trans_t	*xfs_trans_dup(xfs_trans_t *);
 int		xfs_trans_reserve(xfs_trans_t *, uint, uint, uint,
 				  uint, uint);