GFS2: Introduce new gfs2_log_header_v2

This patch adds a new structure called gfs2_log_header_v2 which is used
to store expanded fields into previously unused areas of the log headers
(i.e., this change is backwards compatible).  Some of these are used for
debug purposes so we can backtrack when problems occur.  Others are
reserved for future expansion.

This patch is based on a prototype from Steve Whitehouse.

Signed-off-by: Bob Peterson <rpeterso@redhat.com>
Signed-off-by: Andreas Gruenbacher <agruenba@redhat.com>

diff --git a/fs/gfs2/Kconfig b/fs/gfs2/Kconfig
index 43c827a7cce50dd998cb8f1da2b3fd0bc62afbbb..c0225d4b543539eeff078f23befbe4fed84dbb08 100644 (file)
--- a/fs/gfs2/Kconfig
+++ b/fs/gfs2/Kconfig
@@ -3,6 +3,8 @@ config GFS2_FS
        depends on (64BIT || LBDAF)
        select FS_POSIX_ACL
        select CRC32
+       select CRYPTO
+       select CRYPTO_CRC32C
        select QUOTACTL
        select FS_IOMAP
        help

diff --git a/fs/gfs2/aops.c b/fs/gfs2/aops.c
index ac4a1e89da1e67d60f2d2784efdc4147783415d2..462c3fd55929171c421c3c4740124905f10d674d 100644 (file)
--- a/fs/gfs2/aops.c
+++ b/fs/gfs2/aops.c
@@ -448,7 +448,7 @@ static int gfs2_jdata_writepages(struct address_space *mapping,
 
        ret = gfs2_write_cache_jdata(mapping, wbc);
        if (ret == 0 && wbc->sync_mode == WB_SYNC_ALL) {
-               gfs2_log_flush(sdp, ip->i_gl, NORMAL_FLUSH);
+               gfs2_log_flush(sdp, ip->i_gl, GFS2_LOG_HEAD_FLUSH_NORMAL);
                ret = gfs2_write_cache_jdata(mapping, wbc);
        }
        return ret;

diff --git a/fs/gfs2/file.c b/fs/gfs2/file.c
index bd60dc682676d2914c3b1edcefe7edf2c6e4540d..7a02b4e6e9f38d21c9437244b8ed19bcef5d9d95 100644 (file)
--- a/fs/gfs2/file.c
+++ b/fs/gfs2/file.c
@@ -246,7 +246,8 @@ static int do_gfs2_set_flags(struct file *filp, u32 reqflags, u32 mask)
        }
        if ((flags ^ new_flags) & GFS2_DIF_JDATA) {
                if (new_flags & GFS2_DIF_JDATA)
-                       gfs2_log_flush(sdp, ip->i_gl, NORMAL_FLUSH);
+                       gfs2_log_flush(sdp, ip->i_gl,
+                                      GFS2_LOG_HEAD_FLUSH_NORMAL);
                error = filemap_fdatawrite(inode->i_mapping);
                if (error)
                        goto out;

diff --git a/fs/gfs2/glops.c b/fs/gfs2/glops.c
index cdd1c5f06f452f70d6704c86ed87d4548ab7d315..2daab13a9e0b49d7359c6786846f330148d43669 100644 (file)
--- a/fs/gfs2/glops.c
+++ b/fs/gfs2/glops.c
@@ -107,7 +107,7 @@ static void gfs2_ail_empty_gl(struct gfs2_glock *gl)
        __gfs2_ail_flush(gl, 0, tr.tr_revokes);
 
        gfs2_trans_end(sdp);
-       gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
+       gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL);
 }
 
 void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
@@ -128,7 +128,7 @@ void gfs2_ail_flush(struct gfs2_glock *gl, bool fsync)
                return;
        __gfs2_ail_flush(gl, fsync, max_revokes);
        gfs2_trans_end(sdp);
-       gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
+       gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL);
 }
 
 /**
@@ -157,7 +157,7 @@ static void rgrp_go_sync(struct gfs2_glock *gl)
                return;
        GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_EXCLUSIVE);
 
-       gfs2_log_flush(sdp, gl, NORMAL_FLUSH);
+       gfs2_log_flush(sdp, gl, GFS2_LOG_HEAD_FLUSH_NORMAL);
        filemap_fdatawrite_range(mapping, gl->gl_vm.start, gl->gl_vm.end);
        error = filemap_fdatawait_range(mapping, gl->gl_vm.start, gl->gl_vm.end);
        mapping_set_error(mapping, error);
@@ -252,7 +252,7 @@ static void inode_go_sync(struct gfs2_glock *gl)
 
        GLOCK_BUG_ON(gl, gl->gl_state != LM_ST_EXCLUSIVE);
 
-       gfs2_log_flush(gl->gl_name.ln_sbd, gl, NORMAL_FLUSH);
+       gfs2_log_flush(gl->gl_name.ln_sbd, gl, GFS2_LOG_HEAD_FLUSH_NORMAL);
        filemap_fdatawrite(metamapping);
        if (isreg) {
                struct address_space *mapping = ip->i_inode.i_mapping;
@@ -303,7 +303,8 @@ static void inode_go_inval(struct gfs2_glock *gl, int flags)
        }
 
        if (ip == GFS2_I(gl->gl_name.ln_sbd->sd_rindex)) {
-               gfs2_log_flush(gl->gl_name.ln_sbd, NULL, NORMAL_FLUSH);
+               gfs2_log_flush(gl->gl_name.ln_sbd, NULL,
+                              GFS2_LOG_HEAD_FLUSH_NORMAL);
                gl->gl_name.ln_sbd->sd_rindex_uptodate = 0;
        }
        if (ip && S_ISREG(ip->i_inode.i_mode))
@@ -495,7 +496,7 @@ static void freeze_go_sync(struct gfs2_glock *gl)
                        gfs2_assert_withdraw(sdp, 0);
                }
                queue_work(gfs2_freeze_wq, &sdp->sd_freeze_work);
-               gfs2_log_flush(sdp, NULL, FREEZE_FLUSH);
+               gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_FREEZE);
        }
 }
 

diff --git a/fs/gfs2/log.c b/fs/gfs2/log.c
index c27cbcebfe889717755195b0c0ff83e840fff16c..a2eb13c045917bf17874388b43c69d1105f8c472 100644 (file)
--- a/fs/gfs2/log.c
+++ b/fs/gfs2/log.c
@@ -14,6 +14,7 @@
 #include <linux/buffer_head.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
+#include <linux/crc32c.h>
 #include <linux/delay.h>
 #include <linux/kthread.h>
 #include <linux/freezer.h>
@@ -653,20 +654,25 @@ out_of_blocks:
 /**
  * write_log_header - Write a journal log header buffer at sd_log_flush_head
  * @sdp: The GFS2 superblock
+ * @jd: journal descriptor of the journal to which we are writing
  * @seq: sequence number
  * @tail: tail of the log
- * @flags: log header flags
+ * @flags: log header flags GFS2_LOG_HEAD_*
  * @op_flags: flags to pass to the bio
  *
  * Returns: the initialized log buffer descriptor
  */
 
-void gfs2_write_log_header(struct gfs2_sbd *sdp, u64 seq, u32 tail,
-                          u32 flags, int op_flags)
+void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
+                          u64 seq, u32 tail, u32 flags, int op_flags)
 {
        struct gfs2_log_header *lh;
-       u32 hash;
+       u32 hash, crc;
        struct page *page = mempool_alloc(gfs2_page_pool, GFP_NOIO);
+       struct gfs2_statfs_change_host *l_sc = &sdp->sd_statfs_local;
+       struct timespec64 tv;
+       struct super_block *sb = sdp->sd_vfs;
+       u64 addr;
 
        lh = page_address(page);
        clear_page(lh);
@@ -680,10 +686,39 @@ void gfs2_write_log_header(struct gfs2_sbd *sdp, u64 seq, u32 tail,
        lh->lh_flags = cpu_to_be32(flags);
        lh->lh_tail = cpu_to_be32(tail);
        lh->lh_blkno = cpu_to_be32(sdp->sd_log_flush_head);
-       hash = ~crc32(~0, lh, sizeof(*lh));
+       hash = ~crc32(~0, lh, LH_V1_SIZE);
        lh->lh_hash = cpu_to_be32(hash);
 
-       gfs2_log_write_page(sdp, page);
+       tv = current_kernel_time64();
+       lh->lh_nsec = cpu_to_be32(tv.tv_nsec);
+       lh->lh_sec = cpu_to_be64(tv.tv_sec);
+       addr = gfs2_log_bmap(sdp);
+       lh->lh_addr = cpu_to_be64(addr);
+       lh->lh_jinode = cpu_to_be64(GFS2_I(jd->jd_inode)->i_no_addr);
+
+       /* We may only write local statfs, quota, etc., when writing to our
+          own journal. The values are left 0 when recovering a journal
+          different from our own. */
+       if (!(flags & GFS2_LOG_HEAD_RECOVERY)) {
+               lh->lh_statfs_addr =
+                       cpu_to_be64(GFS2_I(sdp->sd_sc_inode)->i_no_addr);
+               lh->lh_quota_addr =
+                       cpu_to_be64(GFS2_I(sdp->sd_qc_inode)->i_no_addr);
+
+               spin_lock(&sdp->sd_statfs_spin);
+               lh->lh_local_total = cpu_to_be64(l_sc->sc_total);
+               lh->lh_local_free = cpu_to_be64(l_sc->sc_free);
+               lh->lh_local_dinodes = cpu_to_be64(l_sc->sc_dinodes);
+               spin_unlock(&sdp->sd_statfs_spin);
+       }
+
+       BUILD_BUG_ON(offsetof(struct gfs2_log_header, lh_crc) != LH_V1_SIZE);
+
+       crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4,
+                    sb->s_blocksize - LH_V1_SIZE - 4);
+       lh->lh_crc = cpu_to_be32(crc);
+
+       gfs2_log_write(sdp, page, sb->s_blocksize, 0, addr);
        gfs2_log_flush_bio(sdp, REQ_OP_WRITE, op_flags);
        log_flush_wait(sdp);
 }
@@ -691,6 +726,7 @@ void gfs2_write_log_header(struct gfs2_sbd *sdp, u64 seq, u32 tail,
 /**
  * log_write_header - Get and initialize a journal header buffer
  * @sdp: The GFS2 superblock
+ * @flags: The log header flags, including log header origin
  *
  * Returns: the initialized log buffer descriptor
  */
@@ -710,8 +746,8 @@ static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
                op_flags = REQ_SYNC | REQ_META | REQ_PRIO;
        }
        sdp->sd_log_idle = (tail == sdp->sd_log_flush_head);
-       gfs2_write_log_header(sdp, sdp->sd_log_sequence++, tail, flags,
-                             op_flags);
+       gfs2_write_log_header(sdp, sdp->sd_jdesc, sdp->sd_log_sequence++, tail,
+                             flags, op_flags);
 
        if (sdp->sd_log_tail != tail)
                log_pull_tail(sdp, tail);
@@ -721,11 +757,11 @@ static void log_write_header(struct gfs2_sbd *sdp, u32 flags)
  * gfs2_log_flush - flush incore transaction(s)
  * @sdp: the filesystem
  * @gl: The glock structure to flush.  If NULL, flush the whole incore log
+ * @flags: The log header flags: GFS2_LOG_HEAD_FLUSH_*
  *
  */
 
-void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
-                   enum gfs2_flush_type type)
+void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl, u32 flags)
 {
        struct gfs2_trans *tr;
        enum gfs2_freeze_state state = atomic_read(&sdp->sd_freeze_state);
@@ -739,7 +775,7 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
        }
        trace_gfs2_log_flush(sdp, 1);
 
-       if (type == SHUTDOWN_FLUSH)
+       if (flags & GFS2_LOG_HEAD_FLUSH_SHUTDOWN)
                clear_bit(SDF_JOURNAL_LIVE, &sdp->sd_flags);
 
        sdp->sd_log_flush_head = sdp->sd_log_head;
@@ -764,11 +800,11 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
 
        if (sdp->sd_log_head != sdp->sd_log_flush_head) {
                log_flush_wait(sdp);
-               log_write_header(sdp, 0);
+               log_write_header(sdp, flags);
        } else if (sdp->sd_log_tail != current_tail(sdp) && !sdp->sd_log_idle){
                atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
                trace_gfs2_log_blocks(sdp, -1);
-               log_write_header(sdp, 0);
+               log_write_header(sdp, flags);
        }
        lops_after_commit(sdp, tr);
 
@@ -785,7 +821,7 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
        spin_unlock(&sdp->sd_ail_lock);
        gfs2_log_unlock(sdp);
 
-       if (type != NORMAL_FLUSH) {
+       if (!(flags & GFS2_LOG_HEAD_FLUSH_NORMAL)) {
                if (!sdp->sd_log_idle) {
                        for (;;) {
                                gfs2_ail1_start(sdp);
@@ -795,12 +831,13 @@ void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
                        }
                        atomic_dec(&sdp->sd_log_blks_free); /* Adjust for unreserved buffer */
                        trace_gfs2_log_blocks(sdp, -1);
-                       log_write_header(sdp, 0);
+                       log_write_header(sdp, flags);
                        sdp->sd_log_head = sdp->sd_log_flush_head;
                }
-               if (type == SHUTDOWN_FLUSH || type == FREEZE_FLUSH)
+               if (flags & (GFS2_LOG_HEAD_FLUSH_SHUTDOWN |
+                            GFS2_LOG_HEAD_FLUSH_FREEZE))
                        gfs2_log_shutdown(sdp);
-               if (type == FREEZE_FLUSH)
+               if (flags & GFS2_LOG_HEAD_FLUSH_FREEZE)
                        atomic_set(&sdp->sd_freeze_state, SFS_FROZEN);
        }
 
@@ -956,7 +993,7 @@ int gfs2_logd(void *data)
                did_flush = false;
                if (gfs2_jrnl_flush_reqd(sdp) || t == 0) {
                        gfs2_ail1_empty(sdp);
-                       gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
+                       gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL);
                        did_flush = true;
                }
 
@@ -964,7 +1001,7 @@ int gfs2_logd(void *data)
                        gfs2_ail1_start(sdp);
                        gfs2_ail1_wait(sdp);
                        gfs2_ail1_empty(sdp);
-                       gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
+                       gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL);
                        did_flush = true;
                }
 

diff --git a/fs/gfs2/log.h b/fs/gfs2/log.h
index 619de9a1ff4f79c34d70c2aa0481a58b7e00c657..93b52ac1ca1f1af9e626fd2833f50d8d2e3e9e4d 100644 (file)
--- a/fs/gfs2/log.h
+++ b/fs/gfs2/log.h
@@ -65,16 +65,10 @@ extern unsigned int gfs2_struct2blk(struct gfs2_sbd *sdp, unsigned int nstruct,
 
 extern void gfs2_log_release(struct gfs2_sbd *sdp, unsigned int blks);
 extern int gfs2_log_reserve(struct gfs2_sbd *sdp, unsigned int blks);
-enum gfs2_flush_type {
-       NORMAL_FLUSH = 0,
-       SYNC_FLUSH,
-       SHUTDOWN_FLUSH,
-       FREEZE_FLUSH
-};
-extern void gfs2_write_log_header(struct gfs2_sbd *sdp, u64 seq, u32 tail,
-                                 u32 flags, int op_flags);
+extern void gfs2_write_log_header(struct gfs2_sbd *sdp, struct gfs2_jdesc *jd,
+                                 u64 seq, u32 tail, u32 flags, int op_flags);
 extern void gfs2_log_flush(struct gfs2_sbd *sdp, struct gfs2_glock *gl,
-                          enum gfs2_flush_type type);
+                          u32 type);
 extern void gfs2_log_commit(struct gfs2_sbd *sdp, struct gfs2_trans *trans);
 extern void gfs2_remove_from_ail(struct gfs2_bufdata *bd);
 extern void gfs2_ail1_flush(struct gfs2_sbd *sdp, struct writeback_control *wbc);

diff --git a/fs/gfs2/lops.c b/fs/gfs2/lops.c
index c8ff7b7954f05d4b82160804ac1bed811bbb8b48..4a60221c678f455d9057099cca8bc58fade6ef7e 100644 (file)
--- a/fs/gfs2/lops.c
+++ b/fs/gfs2/lops.c
@@ -18,6 +18,7 @@
 #include <linux/fs.h>
 #include <linux/list_sort.h>
 
+#include "dir.h"
 #include "gfs2.h"
 #include "incore.h"
 #include "inode.h"
@@ -138,7 +139,7 @@ static void gfs2_log_incr_head(struct gfs2_sbd *sdp)
                sdp->sd_log_flush_head = 0;
 }
 
-static u64 gfs2_log_bmap(struct gfs2_sbd *sdp)
+u64 gfs2_log_bmap(struct gfs2_sbd *sdp)
 {
        unsigned int lbn = sdp->sd_log_flush_head;
        struct gfs2_journal_extent *je;
@@ -306,23 +307,22 @@ static struct bio *gfs2_log_get_bio(struct gfs2_sbd *sdp, u64 blkno)
        return gfs2_log_alloc_bio(sdp, blkno);
 }
 
-
 /**
  * gfs2_log_write - write to log
  * @sdp: the filesystem
  * @page: the page to write
  * @size: the size of the data to write
  * @offset: the offset within the page 
+ * @blkno: block number of the log entry
  *
  * Try and add the page segment to the current bio. If that fails,
  * submit the current bio to the device and create a new one, and
  * then add the page segment to that.
  */
 
-static void gfs2_log_write(struct gfs2_sbd *sdp, struct page *page,
-                          unsigned size, unsigned offset)
+void gfs2_log_write(struct gfs2_sbd *sdp, struct page *page,
+                   unsigned size, unsigned offset, u64 blkno)
 {
-       u64 blkno = gfs2_log_bmap(sdp);
        struct bio *bio;
        int ret;
 
@@ -348,7 +348,8 @@ static void gfs2_log_write(struct gfs2_sbd *sdp, struct page *page,
 
 static void gfs2_log_write_bh(struct gfs2_sbd *sdp, struct buffer_head *bh)
 {
-       gfs2_log_write(sdp, bh->b_page, bh->b_size, bh_offset(bh));
+       gfs2_log_write(sdp, bh->b_page, bh->b_size, bh_offset(bh),
+                      gfs2_log_bmap(sdp));
 }
 
 /**
@@ -365,7 +366,8 @@ static void gfs2_log_write_bh(struct gfs2_sbd *sdp, struct buffer_head *bh)
 void gfs2_log_write_page(struct gfs2_sbd *sdp, struct page *page)
 {
        struct super_block *sb = sdp->sd_vfs;
-       gfs2_log_write(sdp, page, sb->s_blocksize, 0);
+       gfs2_log_write(sdp, page, sb->s_blocksize, 0,
+                      gfs2_log_bmap(sdp));
 }
 
 static struct page *gfs2_get_log_desc(struct gfs2_sbd *sdp, u32 ld_type,

diff --git a/fs/gfs2/lops.h b/fs/gfs2/lops.h
index e529f536c1179aea749e04cb8638ce1ad1f444ba..e4949394f05472070ea161e8f31bdfb943b824fb 100644 (file)
--- a/fs/gfs2/lops.h
+++ b/fs/gfs2/lops.h
@@ -26,6 +26,9 @@ extern const struct gfs2_log_operations gfs2_revoke_lops;
 extern const struct gfs2_log_operations gfs2_databuf_lops;
 
 extern const struct gfs2_log_operations *gfs2_log_ops[];
+extern u64 gfs2_log_bmap(struct gfs2_sbd *sdp);
+extern void gfs2_log_write(struct gfs2_sbd *sdp, struct page *page,
+                          unsigned size, unsigned offset, u64 blkno);
 extern void gfs2_log_write_page(struct gfs2_sbd *sdp, struct page *page);
 extern void gfs2_log_flush_bio(struct gfs2_sbd *sdp, int op, int op_flags);
 extern void gfs2_pin(struct gfs2_sbd *sdp, struct buffer_head *bh);

diff --git a/fs/gfs2/ops_fstype.c b/fs/gfs2/ops_fstype.c
index ad55eb86a2504bd048ddd6c674b78ec7c5e9df27..d6e620beb9db9e8e5366c18e6ff8ddaf77c3b36d 100644 (file)
--- a/fs/gfs2/ops_fstype.c
+++ b/fs/gfs2/ops_fstype.c
@@ -1382,7 +1382,7 @@ static void gfs2_kill_sb(struct super_block *sb)
                return;
        }
 
-       gfs2_log_flush(sdp, NULL, SYNC_FLUSH);
+       gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SYNC);
        dput(sdp->sd_root_dir);
        dput(sdp->sd_master_dir);
        sdp->sd_root_dir = NULL;

diff --git a/fs/gfs2/quota.c b/fs/gfs2/quota.c
index e700fb16266474e4a39708244ddecb26ebb23367..2092df19e43348aa44cadce9e290aed8fa0a2621 100644 (file)
--- a/fs/gfs2/quota.c
+++ b/fs/gfs2/quota.c
@@ -955,7 +955,8 @@ out:
                gfs2_glock_dq_uninit(&ghs[qx]);
        inode_unlock(&ip->i_inode);
        kfree(ghs);
-       gfs2_log_flush(ip->i_gl->gl_name.ln_sbd, ip->i_gl, NORMAL_FLUSH);
+       gfs2_log_flush(ip->i_gl->gl_name.ln_sbd, ip->i_gl,
+                      GFS2_LOG_HEAD_FLUSH_NORMAL);
        return error;
 }
 

diff --git a/fs/gfs2/recovery.c b/fs/gfs2/recovery.c
index 975f32166dfeffbe5605185b727f490002d49e17..b6b258998bcda40d15a9c601d5cd1d71dfe10528 100644 (file)
--- a/fs/gfs2/recovery.c
+++ b/fs/gfs2/recovery.c
@@ -14,6 +14,7 @@
 #include <linux/buffer_head.h>
 #include <linux/gfs2_ondisk.h>
 #include <linux/crc32.h>
+#include <linux/crc32c.h>
 
 #include "gfs2.h"
 #include "incore.h"
@@ -137,7 +138,7 @@ static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
 {
        struct gfs2_log_header *lh;
        struct buffer_head *bh;
-       u32 hash;
+       u32 hash, crc;
        int error;
 
        error = gfs2_replay_read_block(jd, blk, &bh);
@@ -145,13 +146,17 @@ static int get_log_header(struct gfs2_jdesc *jd, unsigned int blk,
                return error;
        lh = (void *)bh->b_data;
 
-       hash = crc32(~0, lh, sizeof(*lh) - 4);
+       hash = crc32(~0, lh, LH_V1_SIZE - 4);
        hash = ~crc32_le_shift(hash, 4);  /* assume lh_hash is zero */
 
+       crc = crc32c(~0, (void *)lh + LH_V1_SIZE + 4,
+                    bh->b_size - LH_V1_SIZE - 4);
+
        error = lh->lh_header.mh_magic != cpu_to_be32(GFS2_MAGIC) ||
                lh->lh_header.mh_type != cpu_to_be32(GFS2_METATYPE_LH) ||
                be32_to_cpu(lh->lh_blkno) != blk ||
-               be32_to_cpu(lh->lh_hash) != hash;
+               be32_to_cpu(lh->lh_hash) != hash ||
+               (lh->lh_crc != 0 && be32_to_cpu(lh->lh_crc) != crc);
 
        brelse(bh);
 
@@ -372,9 +377,9 @@ static void clean_journal(struct gfs2_jdesc *jd,
 
        sdp->sd_log_flush_head = head->lh_blkno;
        gfs2_replay_incr_blk(jd, &sdp->sd_log_flush_head);
-       gfs2_write_log_header(sdp, head->lh_sequence + 1, 0,
-                             GFS2_LOG_HEAD_UNMOUNT, REQ_PREFLUSH |
-                             REQ_FUA | REQ_META | REQ_SYNC);
+       gfs2_write_log_header(sdp, jd, head->lh_sequence + 1, 0,
+                             GFS2_LOG_HEAD_UNMOUNT | GFS2_LOG_HEAD_RECOVERY,
+                             REQ_PREFLUSH | REQ_FUA | REQ_META | REQ_SYNC);
 }
 
 

diff --git a/fs/gfs2/rgrp.c b/fs/gfs2/rgrp.c
index 6dea72f4931654b0496d1b450dc99a1fb20d4f38..00eab6c0525c8c0d0ccbdb320d6ccdc84c56cb5e 100644 (file)
--- a/fs/gfs2/rgrp.c
+++ b/fs/gfs2/rgrp.c
@@ -2093,7 +2093,7 @@ next_rgrp:
                }
                /* Flushing the log may release space */
                if (loops == 2)
-                       gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
+                       gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL);
        }
 
        return -ENOSPC;

diff --git a/fs/gfs2/super.c b/fs/gfs2/super.c
index d81d46e19726445801a60feb65a0513cb190b59f..fa3a19eaf0ebf652cdd8808767005cc3f4b43251 100644 (file)
--- a/fs/gfs2/super.c
+++ b/fs/gfs2/super.c
@@ -757,7 +757,8 @@ static int gfs2_write_inode(struct inode *inode, struct writeback_control *wbc)
        bool flush_all = (wbc->sync_mode == WB_SYNC_ALL || gfs2_is_jdata(ip));
 
        if (flush_all)
-               gfs2_log_flush(GFS2_SB(inode), ip->i_gl, NORMAL_FLUSH);
+               gfs2_log_flush(GFS2_SB(inode), ip->i_gl,
+                              GFS2_LOG_HEAD_FLUSH_NORMAL);
        if (bdi->wb.dirty_exceeded)
                gfs2_ail1_flush(sdp, wbc);
        else
@@ -853,7 +854,7 @@ static int gfs2_make_fs_ro(struct gfs2_sbd *sdp)
        gfs2_quota_sync(sdp->sd_vfs, 0);
        gfs2_statfs_sync(sdp->sd_vfs, 0);
 
-       gfs2_log_flush(sdp, NULL, SHUTDOWN_FLUSH);
+       gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_SHUTDOWN);
        wait_event(sdp->sd_reserving_log_wait, atomic_read(&sdp->sd_reserving_log) == 0);
        gfs2_assert_warn(sdp, atomic_read(&sdp->sd_log_blks_free) == sdp->sd_jdesc->jd_blocks);
 
@@ -946,7 +947,7 @@ static int gfs2_sync_fs(struct super_block *sb, int wait)
 
        gfs2_quota_sync(sb, -1);
        if (wait)
-               gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
+               gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL);
        return sdp->sd_log_error;
 }
 
@@ -1650,7 +1651,7 @@ alloc_failed:
        goto out_unlock;
 
 out_truncate:
-       gfs2_log_flush(sdp, ip->i_gl, NORMAL_FLUSH);
+       gfs2_log_flush(sdp, ip->i_gl, GFS2_LOG_HEAD_FLUSH_NORMAL);
        metamapping = gfs2_glock2aspace(ip->i_gl);
        if (test_bit(GLF_DIRTY, &ip->i_gl->gl_flags)) {
                filemap_fdatawrite(metamapping);

diff --git a/fs/gfs2/trans.c b/fs/gfs2/trans.c
index b95ebd166cac13a57331bad58480ba79d7a945b2..7aec6d3434fa365fa612a382a17c4c405837aeea 100644 (file)
--- a/fs/gfs2/trans.c
+++ b/fs/gfs2/trans.c
@@ -117,7 +117,7 @@ void gfs2_trans_end(struct gfs2_sbd *sdp)
        up_read(&sdp->sd_log_flush_lock);
 
        if (sdp->sd_vfs->s_flags & SB_SYNCHRONOUS)
-               gfs2_log_flush(sdp, NULL, NORMAL_FLUSH);
+               gfs2_log_flush(sdp, NULL, GFS2_LOG_HEAD_FLUSH_NORMAL);
        if (alloced)
                sb_end_intwrite(sdp->sd_vfs);
 }

diff --git a/include/uapi/linux/gfs2_ondisk.h b/include/uapi/linux/gfs2_ondisk.h
index 09f0920f07e96c49aa1749499a4bcc3a41f5835b..9a81d520f54ac2531bcf498180e6bdcdaea69157 100644 (file)
--- a/include/uapi/linux/gfs2_ondisk.h
+++ b/include/uapi/linux/gfs2_ondisk.h
@@ -403,7 +403,15 @@ struct gfs2_ea_header {
  * Log header structure
  */
 
-#define GFS2_LOG_HEAD_UNMOUNT  0x00000001      /* log is clean */
+#define GFS2_LOG_HEAD_UNMOUNT          0x00000001 /* log is clean */
+#define GFS2_LOG_HEAD_FLUSH_NORMAL     0x00000002 /* normal log flush */
+#define GFS2_LOG_HEAD_FLUSH_SYNC       0x00000004 /* Sync log flush */
+#define GFS2_LOG_HEAD_FLUSH_SHUTDOWN   0x00000008 /* Shutdown log flush */
+#define GFS2_LOG_HEAD_FLUSH_FREEZE     0x00000010 /* Freeze flush */
+#define GFS2_LOG_HEAD_RECOVERY         0x00000020 /* Journal recovery */
+#define GFS2_LOG_HEAD_USERSPACE                0x80000000 /* Written by gfs2-utils */
+
+#define LH_V1_SIZE (offsetofend(struct gfs2_log_header, lh_hash))
 
 struct gfs2_log_header {
        struct gfs2_meta_header lh_header;
@@ -412,7 +420,21 @@ struct gfs2_log_header {
        __be32 lh_flags;        /* GFS2_LOG_HEAD_... */
        __be32 lh_tail;         /* Block number of log tail */
        __be32 lh_blkno;
-       __be32 lh_hash;
+       __be32 lh_hash;         /* crc up to here with this field 0 */
+
+       /* Version 2 additional fields start here */
+       __be32 lh_crc;          /* crc32c from lh_nsec to end of block */
+       __be32 lh_nsec;         /* Nanoseconds of timestamp */
+       __be64 lh_sec;          /* Seconds of timestamp */
+       __be64 lh_addr;         /* Block addr of this log header (absolute) */
+       __be64 lh_jinode;       /* Journal inode number */
+       __be64 lh_statfs_addr;  /* Local statfs inode number */
+       __be64 lh_quota_addr;   /* Local quota change inode number */
+
+       /* Statfs local changes (i.e. diff from global statfs) */
+       __be64 lh_local_total;
+       __be64 lh_local_free;
+       __be64 lh_local_dinodes;
 };
 
 /*