1 files changed, 111 insertions, 59 deletions

diff --git a/fs/xfs/libxfs/xfs_inode_buf.c b/fs/xfs/libxfs/xfs_inode_buf.c
index 1aabfda669b0..9d9559eb2835 100644
--- a/fs/xfs/libxfs/xfs_inode_buf.c
+++ b/fs/xfs/libxfs/xfs_inode_buf.c
@@ -195,28 +195,50 @@ xfs_imap_to_bp(
 }
 
 void
-xfs_dinode_from_disk(
-        xfs_icdinode_t          *to,
-        xfs_dinode_t            *from)
+xfs_inode_from_disk(
+        struct xfs_inode        *ip,
+        struct xfs_dinode       *from)
 {
-        to->di_magic = be16_to_cpu(from->di_magic);
-        to->di_mode = be16_to_cpu(from->di_mode);
-        to->di_version = from ->di_version;
+        struct xfs_icdinode     *to = &ip->i_d;
+        struct inode            *inode = VFS_I(ip);
+
+
+        /*
+         * Convert v1 inodes immediately to v2 inode format as this is the
+         * minimum inode version format we support in the rest of the code.
+         */
+        to->di_version = from->di_version;
+        if (to->di_version == 1) {
+                set_nlink(inode, be16_to_cpu(from->di_onlink));
+                to->di_projid_lo = 0;
+                to->di_projid_hi = 0;
+                to->di_version = 2;
+        } else {
+                set_nlink(inode, be32_to_cpu(from->di_nlink));
+                to->di_projid_lo = be16_to_cpu(from->di_projid_lo);
+                to->di_projid_hi = be16_to_cpu(from->di_projid_hi);
+        }
+
         to->di_format = from->di_format;
-        to->di_onlink = be16_to_cpu(from->di_onlink);
         to->di_uid = be32_to_cpu(from->di_uid);
         to->di_gid = be32_to_cpu(from->di_gid);
-        to->di_nlink = be32_to_cpu(from->di_nlink);
-        to->di_projid_lo = be16_to_cpu(from->di_projid_lo);
-        to->di_projid_hi = be16_to_cpu(from->di_projid_hi);
-        memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
         to->di_flushiter = be16_to_cpu(from->di_flushiter);
-        to->di_atime.t_sec = be32_to_cpu(from->di_atime.t_sec);
-        to->di_atime.t_nsec = be32_to_cpu(from->di_atime.t_nsec);
-        to->di_mtime.t_sec = be32_to_cpu(from->di_mtime.t_sec);
-        to->di_mtime.t_nsec = be32_to_cpu(from->di_mtime.t_nsec);
-        to->di_ctime.t_sec = be32_to_cpu(from->di_ctime.t_sec);
-        to->di_ctime.t_nsec = be32_to_cpu(from->di_ctime.t_nsec);
+
+        /*
+         * Time is signed, so need to convert to signed 32 bit before
+         * storing in inode timestamp which may be 64 bit. Otherwise
+         * a time before epoch is converted to a time long after epoch
+         * on 64 bit systems.
+         */
+        inode->i_atime.tv_sec = (int)be32_to_cpu(from->di_atime.t_sec);
+        inode->i_atime.tv_nsec = (int)be32_to_cpu(from->di_atime.t_nsec);
+        inode->i_mtime.tv_sec = (int)be32_to_cpu(from->di_mtime.t_sec);
+        inode->i_mtime.tv_nsec = (int)be32_to_cpu(from->di_mtime.t_nsec);
+        inode->i_ctime.tv_sec = (int)be32_to_cpu(from->di_ctime.t_sec);
+        inode->i_ctime.tv_nsec = (int)be32_to_cpu(from->di_ctime.t_nsec);
+        inode->i_generation = be32_to_cpu(from->di_gen);
+        inode->i_mode = be16_to_cpu(from->di_mode);
+
         to->di_size = be64_to_cpu(from->di_size);
         to->di_nblocks = be64_to_cpu(from->di_nblocks);
         to->di_extsize = be32_to_cpu(from->di_extsize);
@@ -227,42 +249,96 @@ xfs_dinode_from_disk(
         to->di_dmevmask = be32_to_cpu(from->di_dmevmask);
         to->di_dmstate  = be16_to_cpu(from->di_dmstate);
         to->di_flags    = be16_to_cpu(from->di_flags);
-        to->di_gen      = be32_to_cpu(from->di_gen);
 
         if (to->di_version == 3) {
-                to->di_changecount = be64_to_cpu(from->di_changecount);
+                inode->i_version = be64_to_cpu(from->di_changecount);
                 to->di_crtime.t_sec = be32_to_cpu(from->di_crtime.t_sec);
                 to->di_crtime.t_nsec = be32_to_cpu(from->di_crtime.t_nsec);
                 to->di_flags2 = be64_to_cpu(from->di_flags2);
-                to->di_ino = be64_to_cpu(from->di_ino);
-                to->di_lsn = be64_to_cpu(from->di_lsn);
-                memcpy(to->di_pad2, from->di_pad2, sizeof(to->di_pad2));
-                uuid_copy(&to->di_uuid, &from->di_uuid);
         }
 }
 
 void
-xfs_dinode_to_disk(
-        xfs_dinode_t            *to,
-        xfs_icdinode_t          *from)
+xfs_inode_to_disk(
+        struct xfs_inode        *ip,
+        struct xfs_dinode       *to,
+        xfs_lsn_t               lsn)
+{
+        struct xfs_icdinode     *from = &ip->i_d;
+        struct inode            *inode = VFS_I(ip);
+
+        to->di_magic = cpu_to_be16(XFS_DINODE_MAGIC);
+        to->di_onlink = 0;
+
+        to->di_version = from->di_version;
+        to->di_format = from->di_format;
+        to->di_uid = cpu_to_be32(from->di_uid);
+        to->di_gid = cpu_to_be32(from->di_gid);
+        to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
+        to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
+
+        memset(to->di_pad, 0, sizeof(to->di_pad));
+        to->di_atime.t_sec = cpu_to_be32(inode->i_atime.tv_sec);
+        to->di_atime.t_nsec = cpu_to_be32(inode->i_atime.tv_nsec);
+        to->di_mtime.t_sec = cpu_to_be32(inode->i_mtime.tv_sec);
+        to->di_mtime.t_nsec = cpu_to_be32(inode->i_mtime.tv_nsec);
+        to->di_ctime.t_sec = cpu_to_be32(inode->i_ctime.tv_sec);
+        to->di_ctime.t_nsec = cpu_to_be32(inode->i_ctime.tv_nsec);
+        to->di_nlink = cpu_to_be32(inode->i_nlink);
+        to->di_gen = cpu_to_be32(inode->i_generation);
+        to->di_mode = cpu_to_be16(inode->i_mode);
+
+        to->di_size = cpu_to_be64(from->di_size);
+        to->di_nblocks = cpu_to_be64(from->di_nblocks);
+        to->di_extsize = cpu_to_be32(from->di_extsize);
+        to->di_nextents = cpu_to_be32(from->di_nextents);
+        to->di_anextents = cpu_to_be16(from->di_anextents);
+        to->di_forkoff = from->di_forkoff;
+        to->di_aformat = from->di_aformat;
+        to->di_dmevmask = cpu_to_be32(from->di_dmevmask);
+        to->di_dmstate = cpu_to_be16(from->di_dmstate);
+        to->di_flags = cpu_to_be16(from->di_flags);
+
+        if (from->di_version == 3) {
+                to->di_changecount = cpu_to_be64(inode->i_version);
+                to->di_crtime.t_sec = cpu_to_be32(from->di_crtime.t_sec);
+                to->di_crtime.t_nsec = cpu_to_be32(from->di_crtime.t_nsec);
+                to->di_flags2 = cpu_to_be64(from->di_flags2);
+
+                to->di_ino = cpu_to_be64(ip->i_ino);
+                to->di_lsn = cpu_to_be64(lsn);
+                memset(to->di_pad2, 0, sizeof(to->di_pad2));
+                uuid_copy(&to->di_uuid, &ip->i_mount->m_sb.sb_meta_uuid);
+                to->di_flushiter = 0;
+        } else {
+                to->di_flushiter = cpu_to_be16(from->di_flushiter);
+        }
+}
+
+void
+xfs_log_dinode_to_disk(
+        struct xfs_log_dinode   *from,
+        struct xfs_dinode       *to)
 {
         to->di_magic = cpu_to_be16(from->di_magic);
         to->di_mode = cpu_to_be16(from->di_mode);
-        to->di_version = from ->di_version;
+        to->di_version = from->di_version;
         to->di_format = from->di_format;
-        to->di_onlink = cpu_to_be16(from->di_onlink);
+        to->di_onlink = 0;
         to->di_uid = cpu_to_be32(from->di_uid);
         to->di_gid = cpu_to_be32(from->di_gid);
         to->di_nlink = cpu_to_be32(from->di_nlink);
         to->di_projid_lo = cpu_to_be16(from->di_projid_lo);
         to->di_projid_hi = cpu_to_be16(from->di_projid_hi);
         memcpy(to->di_pad, from->di_pad, sizeof(to->di_pad));
+
         to->di_atime.t_sec = cpu_to_be32(from->di_atime.t_sec);
         to->di_atime.t_nsec = cpu_to_be32(from->di_atime.t_nsec);
         to->di_mtime.t_sec = cpu_to_be32(from->di_mtime.t_sec);
         to->di_mtime.t_nsec = cpu_to_be32(from->di_mtime.t_nsec);
         to->di_ctime.t_sec = cpu_to_be32(from->di_ctime.t_sec);
         to->di_ctime.t_nsec = cpu_to_be32(from->di_ctime.t_nsec);
+
         to->di_size = cpu_to_be64(from->di_size);
         to->di_nblocks = cpu_to_be64(from->di_nblocks);
         to->di_extsize = cpu_to_be32(from->di_extsize);
@@ -367,13 +443,10 @@ xfs_iread(
             !(mp->m_flags & XFS_MOUNT_IKEEP)) {
                 /* initialise the on-disk inode core */
                 memset(&ip->i_d, 0, sizeof(ip->i_d));
-                ip->i_d.di_magic = XFS_DINODE_MAGIC;
-                ip->i_d.di_gen = prandom_u32();
-                if (xfs_sb_version_hascrc(&mp->m_sb)) {
+                VFS_I(ip)->i_generation = prandom_u32();
+                if (xfs_sb_version_hascrc(&mp->m_sb))
                         ip->i_d.di_version = 3;
-                        ip->i_d.di_ino = ip->i_ino;
-                        uuid_copy(&ip->i_d.di_uuid, &mp->m_sb.sb_meta_uuid);
-                } else
+                else
                         ip->i_d.di_version = 2;
                 return 0;
         }
@@ -403,7 +476,7 @@ xfs_iread(
          * Otherwise, just get the truly permanent information.
          */
         if (dip->di_mode) {
-                xfs_dinode_from_disk(&ip->i_d, dip);
+                xfs_inode_from_disk(ip, dip);
                 error = xfs_iformat_fork(ip, dip);
                 if (error)  {
 #ifdef DEBUG
@@ -417,16 +490,10 @@ xfs_iread(
                  * Partial initialisation of the in-core inode. Just the bits
                  * that xfs_ialloc won't overwrite or relies on being correct.
                  */
-                ip->i_d.di_magic = be16_to_cpu(dip->di_magic);
                 ip->i_d.di_version = dip->di_version;
-                ip->i_d.di_gen = be32_to_cpu(dip->di_gen);
+                VFS_I(ip)->i_generation = be32_to_cpu(dip->di_gen);
                 ip->i_d.di_flushiter = be16_to_cpu(dip->di_flushiter);
 
-                if (dip->di_version == 3) {
-                        ip->i_d.di_ino = be64_to_cpu(dip->di_ino);
-                        uuid_copy(&ip->i_d.di_uuid, &dip->di_uuid);
-                }
-
                 /*
                  * Make sure to pull in the mode here as well in
                  * case the inode is released without being used.
@@ -434,25 +501,10 @@ xfs_iread(
                  * the inode is already free and not try to mess
                  * with the uninitialized part of it.
                  */
-                ip->i_d.di_mode = 0;
-        }
-
-        /*
-         * Automatically convert version 1 inode formats in memory to version 2
-         * inode format. If the inode is modified, it will get logged and
-         * rewritten as a version 2 inode. We can do this because we set the
-         * superblock feature bit for v2 inodes unconditionally during mount
-         * and it means the reast of the code can assume the inode version is 2
-         * or higher.
-         */
-        if (ip->i_d.di_version == 1) {
-                ip->i_d.di_version = 2;
-                memset(&(ip->i_d.di_pad[0]), 0, sizeof(ip->i_d.di_pad));
-                ip->i_d.di_nlink = ip->i_d.di_onlink;
-                ip->i_d.di_onlink = 0;
-                xfs_set_projid(ip, 0);
+                VFS_I(ip)->i_mode = 0;
         }
 
+        ASSERT(ip->i_d.di_version >= 2);
         ip->i_delayed_blks = 0;
 
         /*