Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c1696fb8 authored by Bob Peterson's avatar Bob Peterson
Browse files

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: default avatarBob Peterson <rpeterso@redhat.com>
Signed-off-by: default avatarAndreas Gruenbacher <agruenba@redhat.com>
parent 0ff5916a

fs/gfs2/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -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

fs/gfs2/aops.c

+1 −1
Original line number Diff line number Diff line
@@ -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;

fs/gfs2/file.c

+2 −1
Original line number Diff line number Diff line
@@ -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;

fs/gfs2/glops.c

+7 −6
Original line number Diff line number Diff line
@@ -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);

	}

}

fs/gfs2/log.c

+56 −19
Original line number Diff line number Diff line
@@ -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 @@ void gfs2_write_revokes(struct gfs2_sbd *sdp) 
/**

 * 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;

		}