1 files changed, 32 insertions, 46 deletions

diff --git a/fs/xfs/xfs_log.c b/fs/xfs/xfs_log.c
index 41d5b8f2bf9..3a8d4f66d70 100644
--- a/fs/xfs/xfs_log.c
+++ b/fs/xfs/xfs_log.c
@@ -871,20 +871,14 @@ xlog_space_left(
 void
 xlog_iodone(xfs_buf_t *bp)
 {
-        xlog_in_core_t  *iclog;
-        xlog_t          *l;
-        int             aborted;
-
-        iclog = XFS_BUF_FSPRIVATE(bp, xlog_in_core_t *);
-        ASSERT(XFS_BUF_FSPRIVATE2(bp, unsigned long) == (unsigned long) 2);
-        XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
-        aborted = 0;
-        l = iclog->ic_log;
+        xlog_in_core_t  *iclog = bp->b_fspriv;
+        xlog_t          *l = iclog->ic_log;
+        int             aborted = 0;
 
         /*
          * Race to shutdown the filesystem if we see an error.
          */
-        if (XFS_TEST_ERROR((XFS_BUF_GETERROR(bp)), l->l_mp,
+        if (XFS_TEST_ERROR((xfs_buf_geterror(bp)), l->l_mp,
                         XFS_ERRTAG_IODONE_IOERR, XFS_RANDOM_IODONE_IOERR)) {
                 xfs_ioerror_alert("xlog_iodone", l->l_mp, bp, XFS_BUF_ADDR(bp));
                 XFS_BUF_STALE(bp);
@@ -1056,10 +1050,8 @@ xlog_alloc_log(xfs_mount_t	*mp,
         bp = xfs_buf_get_empty(log->l_iclog_size, mp->m_logdev_targp);
         if (!bp)
                 goto out_free_log;
-        XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
-        XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
-        ASSERT(XFS_BUF_ISBUSY(bp));
-        ASSERT(XFS_BUF_VALUSEMA(bp) <= 0);
+        bp->b_iodone = xlog_iodone;
+        ASSERT(xfs_buf_islocked(bp));
         log->l_xbuf = bp;
 
         spin_lock_init(&log->l_icloglock);
@@ -1090,10 +1082,8 @@ xlog_alloc_log(xfs_mount_t	*mp,
                                                 log->l_iclog_size, 0);
                 if (!bp)
                         goto out_free_iclog;
-                if (!XFS_BUF_CPSEMA(bp))
-                        ASSERT(0);
-                XFS_BUF_SET_IODONE_FUNC(bp, xlog_iodone);
-                XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)1);
+
+                bp->b_iodone = xlog_iodone;
                 iclog->ic_bp = bp;
                 iclog->ic_data = bp->b_addr;
 #ifdef DEBUG
@@ -1117,8 +1107,7 @@ xlog_alloc_log(xfs_mount_t	*mp,
                 iclog->ic_callback_tail = &(iclog->ic_callback);
                 iclog->ic_datap = (char *)iclog->ic_data + log->l_iclog_hsize;
 
-                ASSERT(XFS_BUF_ISBUSY(iclog->ic_bp));
-                ASSERT(XFS_BUF_VALUSEMA(iclog->ic_bp) <= 0);
+                ASSERT(xfs_buf_islocked(iclog->ic_bp));
                 init_waitqueue_head(&iclog->ic_force_wait);
                 init_waitqueue_head(&iclog->ic_write_wait);
 
@@ -1254,11 +1243,10 @@ STATIC int
 xlog_bdstrat(
         struct xfs_buf          *bp)
 {
-        struct xlog_in_core     *iclog;
+        struct xlog_in_core     *iclog = bp->b_fspriv;
 
-        iclog = XFS_BUF_FSPRIVATE(bp, xlog_in_core_t *);
         if (iclog->ic_state & XLOG_STATE_IOERROR) {
-                XFS_BUF_ERROR(bp, EIO);
+                xfs_buf_ioerror(bp, EIO);
                 XFS_BUF_STALE(bp);
                 xfs_buf_ioend(bp, 0);
                 /*
@@ -1269,7 +1257,6 @@ xlog_bdstrat(
                 return 0;
         }
 
-        bp->b_flags |= _XBF_RUN_QUEUES;
         xfs_buf_iorequest(bp);
         return 0;
 }
@@ -1351,8 +1338,6 @@ xlog_sync(xlog_t		*log,
         }
 
         bp = iclog->ic_bp;
-        ASSERT(XFS_BUF_FSPRIVATE2(bp, unsigned long) == (unsigned long)1);
-        XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)2);
         XFS_BUF_SET_ADDR(bp, BLOCK_LSN(be64_to_cpu(iclog->ic_header.h_lsn)));
 
         XFS_STATS_ADD(xs_log_blocks, BTOBB(count));
@@ -1366,22 +1351,27 @@ xlog_sync(xlog_t		*log,
                 iclog->ic_bwritecnt = 1;
         }
         XFS_BUF_SET_COUNT(bp, count);
-        XFS_BUF_SET_FSPRIVATE(bp, iclog);       /* save for later */
+        bp->b_fspriv = iclog;
         XFS_BUF_ZEROFLAGS(bp);
-        XFS_BUF_BUSY(bp);
         XFS_BUF_ASYNC(bp);
-        bp->b_flags |= XBF_LOG_BUFFER;
+        bp->b_flags |= XBF_SYNCIO;
 
         if (log->l_mp->m_flags & XFS_MOUNT_BARRIER) {
+                bp->b_flags |= XBF_FUA;
+
                 /*
-                 * If we have an external log device, flush the data device
-                 * before flushing the log to make sure all meta data
-                 * written back from the AIL actually made it to disk
-                 * before writing out the new log tail LSN in the log buffer.
+                 * Flush the data device before flushing the log to make
+                 * sure all meta data written back from the AIL actually made
+                 * it to disk before stamping the new log tail LSN into the
+                 * log buffer.  For an external log we need to issue the
+                 * flush explicitly, and unfortunately synchronously here;
+                 * for an internal log we can simply use the block layer
+                 * state machine for preflushes.
                  */
                 if (log->l_mp->m_logdev_targp != log->l_mp->m_ddev_targp)
                         xfs_blkdev_issue_flush(log->l_mp->m_ddev_targp);
-                XFS_BUF_ORDERED(bp);
+                else
+                        bp->b_flags |= XBF_FLUSH;
         }
 
         ASSERT(XFS_BUF_ADDR(bp) <= log->l_logBBsize-1);
@@ -1404,20 +1394,16 @@ xlog_sync(xlog_t		*log,
         }
         if (split) {
                 bp = iclog->ic_log->l_xbuf;
-                ASSERT(XFS_BUF_FSPRIVATE2(bp, unsigned long) ==
-                                                        (unsigned long)1);
-                XFS_BUF_SET_FSPRIVATE2(bp, (unsigned long)2);
                 XFS_BUF_SET_ADDR(bp, 0);             /* logical 0 */
-                XFS_BUF_SET_PTR(bp, (xfs_caddr_t)((__psint_t)&(iclog->ic_header)+
-                                            (__psint_t)count), split);
-                XFS_BUF_SET_FSPRIVATE(bp, iclog);
+                xfs_buf_associate_memory(bp,
+                                (char *)&iclog->ic_header + count, split);
+                bp->b_fspriv = iclog;
                 XFS_BUF_ZEROFLAGS(bp);
-                XFS_BUF_BUSY(bp);
                 XFS_BUF_ASYNC(bp);
-                bp->b_flags |= XBF_LOG_BUFFER;
+                bp->b_flags |= XBF_SYNCIO;
                 if (log->l_mp->m_flags & XFS_MOUNT_BARRIER)
-                        XFS_BUF_ORDERED(bp);
-                dptr = XFS_BUF_PTR(bp);
+                        bp->b_flags |= XBF_FUA;
+                dptr = bp->b_addr;
                 /*
                  * Bump the cycle numbers at the start of each block
                  * since this part of the buffer is at the start of
@@ -3521,13 +3507,13 @@ xlog_verify_iclog(xlog_t	 *log,
         spin_unlock(&log->l_icloglock);
 
         /* check log magic numbers */
-        if (be32_to_cpu(iclog->ic_header.h_magicno) != XLOG_HEADER_MAGIC_NUM)
+        if (iclog->ic_header.h_magicno != cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
                 xfs_emerg(log->l_mp, "%s: invalid magic num", __func__);
 
         ptr = (xfs_caddr_t) &iclog->ic_header;
         for (ptr += BBSIZE; ptr < ((xfs_caddr_t)&iclog->ic_header) + count;
              ptr += BBSIZE) {
-                if (be32_to_cpu(*(__be32 *)ptr) == XLOG_HEADER_MAGIC_NUM)
+                if (*(__be32 *)ptr == cpu_to_be32(XLOG_HEADER_MAGIC_NUM))
                         xfs_emerg(log->l_mp, "%s: unexpected magic num",
                                 __func__);
         }