xfs: add size update tracepoint to IO completion

[pandora-kernel.git] / fs / xfs / xfs_mount.c

diff --git a/fs/xfs/xfs_mount.c b/fs/xfs/xfs_mount.c
index b49b823..7f25245 100644 (file)
--- a/fs/xfs/xfs_mount.c
+++ b/fs/xfs/xfs_mount.c
@@ -348,7 +348,7 @@ xfs_mount_validate_sb(
        }
 
        /*
-        * More sanity checking. These were stolen directly from
+        * More sanity checking.  Most of these were stolen directly from
         * xfs_repair.
         */
        if (unlikely(
@@ -371,23 +371,13 @@ xfs_mount_validate_sb(
            (sbp->sb_blocklog - sbp->sb_inodelog != sbp->sb_inopblog)   ||
            (sbp->sb_rextsize * sbp->sb_blocksize > XFS_MAX_RTEXTSIZE)  ||
            (sbp->sb_rextsize * sbp->sb_blocksize < XFS_MIN_RTEXTSIZE)  ||
-           (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */))) {
+           (sbp->sb_imax_pct > 100 /* zero sb_imax_pct is valid */)    ||
+           sbp->sb_dblocks == 0                                        ||
+           sbp->sb_dblocks > XFS_MAX_DBLOCKS(sbp)                      ||
+           sbp->sb_dblocks < XFS_MIN_DBLOCKS(sbp))) {
                if (loud)
-                       xfs_warn(mp, "SB sanity check 1 failed");
-               return XFS_ERROR(EFSCORRUPTED);
-       }
-
-       /*
-        * Sanity check AG count, size fields against data size field
-        */
-       if (unlikely(
-           sbp->sb_dblocks == 0 ||
-           sbp->sb_dblocks >
-            (xfs_drfsbno_t)sbp->sb_agcount * sbp->sb_agblocks ||
-           sbp->sb_dblocks < (xfs_drfsbno_t)(sbp->sb_agcount - 1) *
-                             sbp->sb_agblocks + XFS_MIN_AG_BLOCKS)) {
-               if (loud)
-                       xfs_warn(mp, "SB sanity check 2 failed");
+                       XFS_CORRUPTION_ERROR("SB sanity check failed",
+                               XFS_ERRLEVEL_LOW, mp, sbp);
                return XFS_ERROR(EFSCORRUPTED);
        }
 
@@ -864,7 +854,8 @@ xfs_update_alignment(xfs_mount_t *mp)
                if ((BBTOB(mp->m_dalign) & mp->m_blockmask) ||
                    (BBTOB(mp->m_swidth) & mp->m_blockmask)) {
                        if (mp->m_flags & XFS_MOUNT_RETERR) {
-                               xfs_warn(mp, "alignment check 1 failed");
+                               xfs_warn(mp, "alignment check failed: "
+                                        "(sunit/swidth vs. blocksize)");
                                return XFS_ERROR(EINVAL);
                        }
                        mp->m_dalign = mp->m_swidth = 0;
@@ -875,6 +866,8 @@ xfs_update_alignment(xfs_mount_t *mp)
                        mp->m_dalign = XFS_BB_TO_FSBT(mp, mp->m_dalign);
                        if (mp->m_dalign && (sbp->sb_agblocks % mp->m_dalign)) {
                                if (mp->m_flags & XFS_MOUNT_RETERR) {
+                                       xfs_warn(mp, "alignment check failed: "
+                                                "(sunit/swidth vs. ag size)");
                                        return XFS_ERROR(EINVAL);
                                }
                                xfs_warn(mp,
@@ -889,8 +882,8 @@ xfs_update_alignment(xfs_mount_t *mp)
                                mp->m_swidth = XFS_BB_TO_FSBT(mp, mp->m_swidth);
                        } else {
                                if (mp->m_flags & XFS_MOUNT_RETERR) {
-                                       xfs_warn(mp,
-               "stripe alignment turned off: sunit(%d) less than bsize(%d)",
+                                       xfs_warn(mp, "alignment check failed: "
+                                               "sunit(%d) less than bsize(%d)",
                                                mp->m_dalign,
                                                mp->m_blockmask +1);
                                        return XFS_ERROR(EINVAL);
@@ -1096,10 +1089,6 @@ xfs_mount_reset_sbqflags(
        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);
@@ -1532,7 +1521,7 @@ xfs_unmountfs(
                xfs_warn(mp, "Unable to free reserved block pool. "
                                "Freespace may not be correct on next mount.");
 
-       error = xfs_log_sbcount(mp, 1);
+       error = xfs_log_sbcount(mp);
        if (error)
                xfs_warn(mp, "Unable to update superblock counters. "
                                "Freespace may not be correct on next mount.");
@@ -1568,18 +1557,14 @@ 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.
+ * Sync the superblock counters to disk.
  *
  * Note this code can be called during the process of freezing, so
- * we may need to use the transaction allocator which does not not
+ * we may need to use the transaction allocator which does not
  * block when the transaction subsystem is in its frozen state.
  */
 int
-xfs_log_sbcount(
-       xfs_mount_t     *mp,
-       uint            sync)
+xfs_log_sbcount(xfs_mount_t *mp)
 {
        xfs_trans_t     *tp;
        int             error;
@@ -1605,8 +1590,7 @@ xfs_log_sbcount(
        }
 
        xfs_mod_sb(tp, XFS_SB_IFREE | XFS_SB_ICOUNT | XFS_SB_FDBLOCKS);
-       if (sync)
-               xfs_trans_set_sync(tp);
+       xfs_trans_set_sync(tp);
        error = xfs_trans_commit(tp, 0);
        return error;
 }
@@ -1941,22 +1925,19 @@ unwind:
  * the superblock buffer if it can be locked without sleeping.
  * If it can't then we'll return NULL.
  */
-xfs_buf_t *
+struct xfs_buf *
 xfs_getsb(
-       xfs_mount_t     *mp,
-       int             flags)
+       struct xfs_mount        *mp,
+       int                     flags)
 {
-       xfs_buf_t       *bp;
+       struct xfs_buf          *bp = mp->m_sb_bp;
 
-       ASSERT(mp->m_sb_bp != NULL);
-       bp = mp->m_sb_bp;
-       if (flags & XBF_TRYLOCK) {
-               if (!XFS_BUF_CPSEMA(bp)) {
+       if (!xfs_buf_trylock(bp)) {
+               if (flags & XBF_TRYLOCK)
                        return NULL;
-               }
-       } else {
-               XFS_BUF_PSEMA(bp, PRIBIO);
+               xfs_buf_lock(bp);
        }
+
        XFS_BUF_HOLD(bp);
        ASSERT(XFS_BUF_ISDONE(bp));
        return bp;