xfs
[Top] [All Lists]

[PATCH 6/9] xfs: add CRC checks for quota blocks

To: xfs@xxxxxxxxxxx
Subject: [PATCH 6/9] xfs: add CRC checks for quota blocks
From: Dave Chinner <david@xxxxxxxxxxxxx>
Date: Tue, 22 Jan 2013 00:25:57 +1100
Delivered-to: xfs@xxxxxxxxxxx
In-reply-to: <1358774760-21841-1-git-send-email-david@xxxxxxxxxxxxx>
References: <1358774760-21841-1-git-send-email-david@xxxxxxxxxxxxx>
From: Christoph Hellwig <hch@xxxxxx>

Use the reserved space in struct xfs_dqblk to store a UUID and a crc
for the quota blocks.

[dchinner@xxxxxxxxxx] Add a LSN field and update for current verifier
infrastructure.

Signed-off-by: Christoph Hellwig <hch@xxxxxx>
Signed-off-by: Dave Chinner <dchinner@xxxxxxxxxx>
---
 fs/xfs/xfs_dquot.c       |   87 +++++++++++++++++++++++++++++++++++++++-------
 fs/xfs/xfs_log_recover.c |    9 +++++
 fs/xfs/xfs_qm.c          |    4 +++
 fs/xfs/xfs_quota.h       |   11 +++++-
 4 files changed, 98 insertions(+), 13 deletions(-)

diff --git a/fs/xfs/xfs_dquot.c b/fs/xfs/xfs_dquot.c
index 9e1bf52..c83beee 100644
--- a/fs/xfs/xfs_dquot.c
+++ b/fs/xfs/xfs_dquot.c
@@ -36,6 +36,7 @@
 #include "xfs_trans_space.h"
 #include "xfs_trans_priv.h"
 #include "xfs_qm.h"
+#include "xfs_cksum.h"
 #include "xfs_trace.h"
 
 /*
@@ -239,6 +240,8 @@ xfs_qm_init_dquot_blk(
                d->dd_diskdq.d_version = XFS_DQUOT_VERSION;
                d->dd_diskdq.d_id = cpu_to_be32(curid);
                d->dd_diskdq.d_flags = type;
+               if (xfs_sb_version_hascrc(&mp->m_sb))
+                       uuid_copy(&d->dd_uuid, &mp->m_sb.sb_uuid);
        }
 
        xfs_trans_dquot_buf(tp, bp,
@@ -248,13 +251,51 @@ xfs_qm_init_dquot_blk(
        xfs_trans_log_buf(tp, bp, 0, BBTOB(q->qi_dqchunklen) - 1);
 }
 
-static void
+STATIC void
+xfs_dquot_buf_calc_crc(
+       struct xfs_mount        *mp,
+       struct xfs_buf          *bp)
+{
+       struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
+       int                     i;
+
+       if (!xfs_sb_version_hascrc(&mp->m_sb))
+               return;
+
+       for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++, d++) {
+               xfs_update_cksum((char *)d, sizeof(struct xfs_dqblk),
+                                offsetof(struct xfs_dqblk, dd_crc));
+       }
+}
+
+STATIC bool
+xfs_dquot_buf_verify_crc(
+       struct xfs_mount        *mp,
+       struct xfs_buf          *bp)
+{
+       struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
+       int                     i;
+
+       if (!xfs_sb_version_hascrc(&mp->m_sb))
+               return true;
+
+       for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++, d++) {
+               if (!xfs_verify_cksum((char *)d, sizeof(struct xfs_dqblk),
+                                offsetof(struct xfs_dqblk, dd_crc)))
+                       return false;
+               if (!uuid_equal(&d->dd_uuid, &mp->m_sb.sb_uuid))
+                       return false;
+       }
+
+       return true;
+}
+
+STATIC bool
 xfs_dquot_buf_verify(
+       struct xfs_mount        *mp,
        struct xfs_buf          *bp)
 {
-       struct xfs_mount        *mp = bp->b_target->bt_mount;
        struct xfs_dqblk        *d = (struct xfs_dqblk *)bp->b_addr;
-       struct xfs_disk_dquot   *ddq;
        xfs_dqid_t              id = 0;
        int                     i;
 
@@ -266,7 +307,8 @@ xfs_dquot_buf_verify(
         * buffer so corruptions could point to the wrong dquot in this case.
         */
        for (i = 0; i < mp->m_quotainfo->qi_dqperchunk; i++) {
-               int     error;
+               struct xfs_disk_dquot   *ddq;
+               int                     error;
 
                ddq = &d[i].dd_diskdq;
 
@@ -274,27 +316,37 @@ xfs_dquot_buf_verify(
                        id = be32_to_cpu(ddq->d_id);
 
                error = xfs_qm_dqcheck(mp, ddq, id + i, 0, XFS_QMOPT_DOWARN,
-                                       "xfs_dquot_read_verify");
-               if (error) {
-                       XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, d);
-                       xfs_buf_ioerror(bp, EFSCORRUPTED);
-                       break;
-               }
+                                      "xfs_dquot_buf_verify");
+               if (error)
+                       return false;
        }
+       return true;
 }
 
 static void
 xfs_dquot_buf_read_verify(
        struct xfs_buf  *bp)
 {
-       xfs_dquot_buf_verify(bp);
+       struct xfs_mount        *mp = bp->b_target->bt_mount;
+
+       if (!xfs_dquot_buf_verify_crc(mp, bp) || !xfs_dquot_buf_verify(mp, bp)) 
{
+               XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 
bp->b_addr);
+               xfs_buf_ioerror(bp, EFSCORRUPTED);
+       }
 }
 
 void
 xfs_dquot_buf_write_verify(
        struct xfs_buf  *bp)
 {
-       xfs_dquot_buf_verify(bp);
+       struct xfs_mount        *mp = bp->b_target->bt_mount;
+
+       if (!xfs_dquot_buf_verify(mp, bp)) {
+               XFS_CORRUPTION_ERROR(__func__, XFS_ERRLEVEL_LOW, mp, 
bp->b_addr);
+               xfs_buf_ioerror(bp, EFSCORRUPTED);
+               return;
+       }
+       xfs_dquot_buf_calc_crc(mp, bp);
 }
 
 const struct xfs_buf_ops xfs_dquot_buf_ops = {
@@ -1041,6 +1093,17 @@ xfs_qm_dqflush(
                                        &dqp->q_logitem.qli_item.li_lsn);
 
        /*
+        * copy the lsn into the on-disk dquot now while we have the in memory
+        * dquot here. This can't be done later in the write verifier as we
+        * can't get access to the log item at that point in time.
+        */
+       if (xfs_sb_version_hascrc(&mp->m_sb)) {
+               struct xfs_dqblk *dqb = (struct xfs_dqblk *)ddqp;
+
+               dqb->dd_lsn = cpu_to_be64(dqp->q_logitem.qli_item.li_lsn);
+       }
+
+       /*
         * Attach an iodone routine so that we can remove this dquot from the
         * AIL and release the flush lock once the dquot is synced to disk.
         */
diff --git a/fs/xfs/xfs_log_recover.c b/fs/xfs/xfs_log_recover.c
index 8df1ff8..5794875 100644
--- a/fs/xfs/xfs_log_recover.c
+++ b/fs/xfs/xfs_log_recover.c
@@ -1975,6 +1975,15 @@ xlog_recover_do_reg_buffer(
                }
                bp->b_ops = &xfs_agi_buf_ops;
                break;
+       case XFS_BLF_UDQUOT_BUF:
+       case XFS_BLF_PDQUOT_BUF:
+       case XFS_BLF_GDQUOT_BUF:
+               if (*(__be16 *)bp->b_addr != cpu_to_be16(XFS_DQUOT_MAGIC)) {
+                       xfs_warn(mp, "Bad DQUOT block magic!");
+                       ASSERT(0);
+               }
+               bp->b_ops = &xfs_dquot_buf_ops;
+               break;
        default:
                break;
        }
diff --git a/fs/xfs/xfs_qm.c b/fs/xfs/xfs_qm.c
index 60eff47..22f10c6 100644
--- a/fs/xfs/xfs_qm.c
+++ b/fs/xfs/xfs_qm.c
@@ -897,6 +897,10 @@ xfs_qm_dqiter_bufs(
                if (error)
                        break;
 
+               /*
+                * XXX(hch): need to figure out if it makes sense to validate
+                *           the CRC here.
+                */
                xfs_qm_reset_dqcounts(mp, bp, firstid, type);
                xfs_buf_delwri_queue(bp, buffer_list);
                xfs_buf_relse(bp);
diff --git a/fs/xfs/xfs_quota.h b/fs/xfs/xfs_quota.h
index b50ec5b..c61e31c 100644
--- a/fs/xfs/xfs_quota.h
+++ b/fs/xfs/xfs_quota.h
@@ -77,7 +77,14 @@ typedef struct       xfs_disk_dquot {
  */
 typedef struct xfs_dqblk {
        xfs_disk_dquot_t  dd_diskdq;    /* portion that lives incore as well */
-       char              dd_fill[32];  /* filling for posterity */
+       char              dd_fill[4];   /* filling for posterity */
+
+       /*
+        * These two are only present on filesystems with the CRC bits set.
+        */
+       __be32            dd_crc;       /* checksum */
+       __be64            dd_lsn;       /* last modification in log */
+       uuid_t            dd_uuid;      /* location information */
 } xfs_dqblk_t;
 
 /*
@@ -380,5 +387,7 @@ extern int xfs_qm_dqcheck(struct xfs_mount *, 
xfs_disk_dquot_t *,
                                xfs_dqid_t, uint, uint, char *);
 extern int xfs_mount_reset_sbqflags(struct xfs_mount *);
 
+extern const struct xfs_buf_ops xfs_dquot_buf_ops;
+
 #endif /* __KERNEL__ */
 #endif /* __XFS_QUOTA_H__ */
-- 
1.7.10

<Prev in Thread] Current Thread [Next in Thread>