xfs: add version 3 inode format with CRCs

Add a new inode version with a larger core.  The primary objective is
to allow for a crc of the inode, and location information (uuid and ino)
to verify it was written in the right place.  We also extend it by:

	a creation time (for Samba);
	a changecount (for NFSv4);
	a flush sequence (in LSN format for recovery);
	an additional inode flags field; and
	some additional padding.

These additional fields are not implemented yet, but already laid
out in the structure.

[dchinner@redhat.com] Added LSN and flags field, some factoring and rework to
capture all the necessary information in the crc calculation.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Ben Myers <bpm@sgi.com>
Signed-off-by: Ben Myers <bpm@sgi.com>

1 files changed, 41 insertions, 9 deletions

diff --git a/fs/xfs/xfs_ialloc.c b/fs/xfs/xfs_ialloc.c
index 6d0a4954aa8c..3039f829c96a 100644
--- a/fs/xfs/xfs_ialloc.c
+++ b/fs/xfs/xfs_ialloc.c
@@ -167,6 +167,7 @@ xfs_ialloc_inode_init(
         int                     version;
         int                     i, j;
         xfs_daddr_t             d;
+        xfs_ino_t               ino = 0;
 
         /*
          * Loop over the new block(s), filling in the inodes.
@@ -185,13 +186,29 @@ xfs_ialloc_inode_init(
         }
 
         /*
-         * Figure out what version number to use in the inodes we create.
-         * If the superblock version has caught up to the one that supports
-         * the new inode format, then use the new inode version.  Otherwise
-         * use the old version so that old kernels will continue to be
-         * able to use the file system.
+         * Figure out what version number to use in the inodes we create.  If
+         * the superblock version has caught up to the one that supports the new
+         * inode format, then use the new inode version.  Otherwise use the old
+         * version so that old kernels will continue to be able to use the file
+         * system.
+         *
+         * For v3 inodes, we also need to write the inode number into the inode,
+         * so calculate the first inode number of the chunk here as
+         * XFS_OFFBNO_TO_AGINO() only works within a filesystem block, not
+         * across multiple filesystem blocks (such as a cluster) and so cannot
+         * be used in the cluster buffer loop below.
+         *
+         * Further, because we are writing the inode directly into the buffer
+         * and calculating a CRC on the entire inode, we have ot log the entire
+         * inode so that the entire range the CRC covers is present in the log.
+         * That means for v3 inode we log the entire buffer rather than just the
+         * inode cores.
          */
-        if (xfs_sb_version_hasnlink(&mp->m_sb))
+        if (xfs_sb_version_hascrc(&mp->m_sb)) {
+                version = 3;
+                ino = XFS_AGINO_TO_INO(mp, agno,
+                                       XFS_OFFBNO_TO_AGINO(mp, agbno, 0));
+        } else if (xfs_sb_version_hasnlink(&mp->m_sb))
                 version = 2;
         else
                 version = 1;
@@ -214,17 +231,32 @@ xfs_ialloc_inode_init(
                  *      individual transactions causing a lot of log traffic.
                  */
                 fbuf->b_ops = &xfs_inode_buf_ops;
-                xfs_buf_zero(fbuf, 0, ninodes << mp->m_sb.sb_inodelog);
+                xfs_buf_zero(fbuf, 0, BBTOB(fbuf->b_length));
                 for (i = 0; i < ninodes; i++) {
                         int     ioffset = i << mp->m_sb.sb_inodelog;
-                        uint    isize = sizeof(struct xfs_dinode);
+                        uint    isize = xfs_dinode_size(version);
 
                         free = xfs_make_iptr(mp, fbuf, i);
                         free->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
                         free->di_version = version;
                         free->di_gen = cpu_to_be32(gen);
                         free->di_next_unlinked = cpu_to_be32(NULLAGINO);
-                        xfs_trans_log_buf(tp, fbuf, ioffset, ioffset + isize - 1);
+
+                        if (version == 3) {
+                                free->di_ino = cpu_to_be64(ino);
+                                ino++;
+                                uuid_copy(&free->di_uuid, &mp->m_sb.sb_uuid);
+                                xfs_dinode_calc_crc(mp, free);
+                        } else {
+                                /* just log the inode core */
+                                xfs_trans_log_buf(tp, fbuf, ioffset,
+                                                  ioffset + isize - 1);
+                        }
+                }
+                if (version == 3) {
+                        /* need to log the entire buffer */
+                        xfs_trans_log_buf(tp, fbuf, 0,
+                                          BBTOB(fbuf->b_length) - 1);
                 }
                 xfs_trans_inode_alloc_buf(tp, fbuf);
         }