src/delta_lease.c src/direct.c src/ondisk.c src/ondisk.h src/paxos_lease.c src/paxos_lease.h src/resource.c

[David Teigland]

 src/delta_lease.c |   76 +++++++++++++++++++++++++-----
 src/direct.c      |   17 ++++++
 src/ondisk.c      |   28 +----------
 src/ondisk.h      |   25 ++++++++++
 src/paxos_lease.c |  135 ++++++++++++++++++++++++++++++++++++++----------------
 src/paxos_lease.h |    1 
 src/resource.c    |    5 +-
 7 files changed, 210 insertions(+), 77 deletions(-)

New commits:
commit 7212272149f2ff43f6057c43cf70b17b70d60796
Author: David Teigland <teigland(a)redhat.com&gt;
Date:   Thu Oct 30 13:32:14 2014 -0500

    sanlock: fix checksum endian handling
    
    checksums must be computed while the data is in the
    ondisk format (little endian).
    
    When writing a structure:
    - byte swap the structure data from host format to ondisk format
    - compute the host format checksum value from the ondisk data
    - byte swap the checksum value from host format to ondisk format
    - write the ondisk format checksum into the structure
    
    When reading a structure:
    - compute the host format checksum from the ondisk data
    - byte swap the structure data from ondisk format to host format
    - verify the computed host format checksum matches the
      checksum in the host format structure
    
    Signed-off-by: David Teigland <teigland(a)redhat.com&gt;

diff --git a/src/delta_lease.c b/src/delta_lease.c
index 5b6dc9f..ef1cb3c 100644
--- a/src/delta_lease.c
+++ b/src/delta_lease.c
@@ -81,9 +81,9 @@ static int verify_leader(struct sync_disk *disk,
 			 char *space_name,
 			 uint64_t host_id,
 			 struct leader_record *lr,
+			 uint32_t checksum,
 			 const char *caller)
 {
-	uint32_t sum;
 	int result;
 
 	if (lr->magic != DELTA_DISK_MAGIC) {
@@ -118,12 +118,10 @@ static int verify_leader(struct sync_disk *disk,
 		goto fail;
 	}
 
-	sum = leader_checksum(lr);
-
-	if (lr->checksum != sum) {
+	if (lr->checksum != checksum) {
 		log_error("verify_leader %llu wrong checksum %x %x %s",
 			  (unsigned long long)host_id,
-			  lr->checksum, sum, disk->path);
+			  lr->checksum, checksum, disk->path);
 		result = SANLK_LEADER_CHECKSUM;
 		goto fail;
 	}
@@ -164,6 +162,7 @@ int delta_read_lockspace(struct task *task,
 {
 	struct leader_record leader_end;
 	struct leader_record leader;
+	uint32_t checksum;
 	char *space_name;
 	int rv, error;
 
@@ -176,6 +175,9 @@ int delta_read_lockspace(struct task *task,
 	if (rv < 0)
 		return rv;
 
+	/* N.B. compute checksum before byte swapping */
+	checksum = leader_checksum(&leader_end);
+
 	leader_record_in(&leader_end, &leader);
 
 	if (!ls->name[0])
@@ -183,7 +185,7 @@ int delta_read_lockspace(struct task *task,
 	else
 		space_name = ls->name;
 
-	error = verify_leader(disk, space_name, host_id, &leader,
"read_lockspace");
+	error = verify_leader(disk, space_name, host_id, &leader, checksum,
"read_lockspace");
 
 	if (error == SANLK_OK) {
 		memcpy(ls->name, leader.space_name, SANLK_NAME_LEN);
@@ -203,6 +205,7 @@ int delta_lease_leader_read(struct task *task, int io_timeout,
 {
 	struct leader_record leader_end;
 	struct leader_record leader;
+	uint32_t checksum;
 	int rv, error;
 
 	/* host_id N is block offset N-1 */
@@ -215,9 +218,12 @@ int delta_lease_leader_read(struct task *task, int io_timeout,
 	if (rv < 0)
 		return rv;
 
+	/* N.B. compute checksum before byte swapping */
+	checksum = leader_checksum(&leader_end);
+
 	leader_record_in(&leader_end, &leader);
 
-	error = verify_leader(disk, space_name, host_id, &leader, caller);
+	error = verify_leader(disk, space_name, host_id, &leader, checksum, caller);
 
 	memcpy(leader_ret, &leader, sizeof(struct leader_record));
 	return error;
@@ -274,6 +280,7 @@ int delta_lease_acquire(struct task *task,
 	struct leader_record leader1;
 	struct leader_record leader_end;
 	uint64_t new_ts;
+	uint32_t checksum;
 	int other_io_timeout, other_host_dead_seconds, other_id_renewal_seconds;
 	int i, error, rv, delay, delta_large_delay;
 
@@ -385,7 +392,7 @@ int delta_lease_acquire(struct task *task,
 	leader.owner_id = host_id;
 	leader.owner_generation++;
 	snprintf(leader.resource_name, NAME_ID_SIZE, "%s", our_host_name);
-	leader.checksum = leader_checksum(&leader);
+	leader.checksum = 0; /* set below */
 
 	log_space(sp, "delta_acquire write %llu %llu %llu %.48s",
 		  (unsigned long long)leader.owner_id,
@@ -395,6 +402,13 @@ int delta_lease_acquire(struct task *task,
 
 	leader_record_out(&leader, &leader_end);
 
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = leader_checksum(&leader_end);
+	leader.checksum = checksum;
+	leader_end.checksum = cpu_to_le32(checksum);
+
 	rv = write_sector(disk, host_id - 1, (char *)&leader_end, sizeof(struct
leader_record),
 			  task, sp->io_timeout, "delta_leader");
 	if (rv < 0) {
@@ -458,6 +472,7 @@ int delta_lease_renew(struct task *task,
 	char **p_iobuf;
 	char **p_wbuf;
 	char *wbuf;
+	uint32_t checksum;
 	uint64_t host_id, id_offset, new_ts;
 	int rv, iobuf_len, sector_size;
 
@@ -568,9 +583,13 @@ int delta_lease_renew(struct task *task,
  read_done:
 	*read_result = SANLK_OK;
 	memcpy(&leader_end, task->iobuf+id_offset, sizeof(struct leader_record));
+
+	/* N.B. compute checksum before byte swapping */
+	checksum = leader_checksum(&leader_end);
+
 	leader_record_in(&leader_end, &leader);
 
-	rv = verify_leader(disk, space_name, host_id, &leader, "delta_renew");
+	rv = verify_leader(disk, space_name, host_id, &leader, checksum,
"delta_renew");
 	if (rv < 0) {
 		log_erros(sp, "delta_renew verify_leader error %d", rv);
 		return rv;
@@ -611,7 +630,7 @@ int delta_lease_renew(struct task *task,
 	}
 
 	leader.timestamp = new_ts;
-	leader.checksum = leader_checksum(&leader);
+	leader.checksum = 0; /* set below */
 
 	/* TODO: rename the leader fields */
 	if (extra) {
@@ -630,6 +649,13 @@ int delta_lease_renew(struct task *task,
 
 	leader_record_out(&leader, &leader_end);
 
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = leader_checksum(&leader_end);
+	leader.checksum = checksum;
+	leader_end.checksum = cpu_to_le32(checksum);
+
 	memcpy(wbuf, &leader_end, sizeof(struct leader_record));
 	memcpy(wbuf+LEADER_RECORD_MAX, bitmap, HOSTID_BITMAP_SIZE);
 
@@ -666,6 +692,7 @@ int delta_lease_release(struct task *task,
 	struct leader_record leader;
 	struct leader_record leader_end;
 	uint64_t host_id;
+	uint32_t checksum;
 	int rv;
 
 	if (!leader_last)
@@ -678,10 +705,17 @@ int delta_lease_release(struct task *task,
 
 	memcpy(&leader, leader_last, sizeof(struct leader_record));
 	leader.timestamp = LEASE_FREE;
-	leader.checksum = leader_checksum(&leader);
+	leader.checksum = 0; /* set below */
 
 	leader_record_out(&leader, &leader_end);
 
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = leader_checksum(&leader_end);
+	leader.checksum = checksum;
+	leader_end.checksum = cpu_to_le32(checksum);
+
 	rv = write_sector(disk, host_id - 1, (char *)&leader_end, sizeof(struct
leader_record),
 			  task, sp->io_timeout, "delta_leader");
 	if (rv < 0) {
@@ -714,6 +748,7 @@ int delta_lease_init(struct task *task,
 	int iobuf_len;
 	int align_size;
 	int i, rv;
+	uint32_t checksum;
 
 	if (!max_hosts)
 		max_hosts = DEFAULT_MAX_HOSTS;
@@ -752,7 +787,7 @@ int delta_lease_init(struct task *task,
 		leader.timestamp = LEASE_FREE;
 		leader.io_timeout = io_timeout;
 		strncpy(leader.space_name, space_name, NAME_ID_SIZE);
-		leader.checksum = leader_checksum(&leader);
+		leader.checksum = 0; /* set below */
 
 		/* make the first record invalid so we can do a single atomic
 		   write below to commit the whole thing */
@@ -763,6 +798,13 @@ int delta_lease_init(struct task *task,
 
 		leader_record_out(&leader, &leader_end);
 
+		/*
+		 * N.B. must compute checksum after the data has been byte swapped.
+		 */
+		checksum = leader_checksum(&leader_end);
+		leader.checksum = checksum;
+		leader_end.checksum = cpu_to_le32(checksum);
+
 		memcpy(iobuf + (i * disk->sector_size), &leader_end, sizeof(struct
leader_record));
 	}
 
@@ -773,7 +815,17 @@ int delta_lease_init(struct task *task,
 	/* commit the whole lockspace by making the first record valid */
 
 	leader_first.magic = DELTA_DISK_MAGIC;
+	leader_first.checksum = 0; /* set below */
+
 	leader_record_out(&leader_first, &leader_end);
+
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = leader_checksum(&leader_end);
+	leader_first.checksum = checksum;
+	leader_end.checksum = cpu_to_le32(checksum);
+
 	memcpy(iobuf, &leader_end, sizeof(struct leader_record));
 
 	rv = write_iobuf(disk->fd, disk->offset, iobuf, disk->sector_size, task,
io_timeout);
diff --git a/src/direct.c b/src/direct.c
index 8813b2f..2dbb098 100644
--- a/src/direct.c
+++ b/src/direct.c
@@ -400,6 +400,7 @@ int direct_dump(struct task *task, char *dump_path, int force_mode)
 	struct request_record rr;
 	struct mode_block mb;
 	struct sync_disk sd;
+	struct paxos_dblock dblock;
 	char sname[NAME_ID_SIZE+1];
 	char rname[NAME_ID_SIZE+1];
 	uint64_t sector_nr;
@@ -522,6 +523,22 @@ int direct_dump(struct task *task, char *dump_path, int force_mode)
 				char *pd_end = data + ((2 + i) * sd.sector_size);
 				struct mode_block *mb_end = (struct mode_block *)(pd_end + MBLOCK_OFFSET);
 
+				if (force_mode > 1) {
+					paxos_dblock_in((struct paxos_dblock *)pd_end, &dblock);
+
+					if (dblock.mbal || dblock.inp || dblock.lver) {
+						printf("dblock[%04d] mbal %llu bal %llu inp %llu inp2 %llu inp3 %llu lver %llu
sum %x\n",
+						       i,
+						       (unsigned long long)dblock.mbal,
+					               (unsigned long long)dblock.bal,
+					               (unsigned long long)dblock.inp,
+					               (unsigned long long)dblock.inp2,
+					               (unsigned long long)dblock.inp3,
+					               (unsigned long long)dblock.lver,
+					               dblock.checksum);
+					}
+				}
+
 				mode_block_in(mb_end, &mb);
 
 				if (!(mb.flags & MBLOCK_SHARED))
diff --git a/src/ondisk.c b/src/ondisk.c
index 6af8eff..c161f8b 100644
--- a/src/ondisk.c
+++ b/src/ondisk.c
@@ -16,28 +16,6 @@
 #include "ondisk.h"
 
 /*
- * sanlock ondisk format is little endian.
- */
-
-#if __BYTE_ORDER == __BIG_ENDIAN
-#define le16_to_cpu(x) (bswap_16((x)))
-#define le32_to_cpu(x) (bswap_32((x)))
-#define le64_to_cpu(x) (bswap_64((x)))
-#define cpu_to_le16(x) (bswap_16((x)))
-#define cpu_to_le32(x) (bswap_32((x)))
-#define cpu_to_le64(x) (bswap_64((x)))
-#endif
-
-#if __BYTE_ORDER == __LITTLE_ENDIAN
-#define le16_to_cpu(x) (x)
-#define le32_to_cpu(x) (x)
-#define le64_to_cpu(x) (x)
-#define cpu_to_le16(x) (x)
-#define cpu_to_le32(x) (x)
-#define cpu_to_le64(x) (x)
-#endif
-
-/*
  * "end" variables point to ondisk format (endian converted) structures.
  */
 
@@ -79,7 +57,8 @@ void leader_record_out(struct leader_record *lr, struct leader_record
*end)
 	memcpy(end->resource_name, lr->resource_name, NAME_ID_SIZE);
 	end->timestamp        = cpu_to_le64(lr->timestamp);
 	end->unused1          = cpu_to_le64(lr->unused1);
-	end->checksum         = cpu_to_le32(lr->checksum);
+	/* N.B. the checksum must be computed after the byte swapping */
+	/* leader_record_out(lr, end); checksum = compute(end); end->checksum =
cpu_to_le32(checksum); */
 	end->unused2          = cpu_to_le16(lr->unused2);
 	end->io_timeout       = cpu_to_le16(lr->io_timeout);
 	end->write_id         = cpu_to_le64(lr->write_id);
@@ -122,7 +101,8 @@ void paxos_dblock_out(struct paxos_dblock *pd, struct paxos_dblock
*end)
 	end->inp2     = cpu_to_le64(pd->inp2);
 	end->inp3     = cpu_to_le64(pd->inp3);
 	end->lver     = cpu_to_le64(pd->lver);
-	end->checksum = cpu_to_le32(pd->checksum);
+	/* N.B. the checksum must be computed after the byte swapping */
+	/* paxos_dblock_out(pd, end); checksum = compute(end), end->checksum =
cpu_to_le32(checksum); */
 }
 
 void mode_block_in(struct mode_block *end, struct mode_block *mb)
diff --git a/src/ondisk.h b/src/ondisk.h
index 2c62c88..3ae4833 100644
--- a/src/ondisk.h
+++ b/src/ondisk.h
@@ -10,6 +10,31 @@
 #ifndef __ONDISK_H__
 #define __ONDISK_H__
 
+#include <endian.h>
+#include <byteswap.h>
+
+/*
+ * sanlock ondisk format is little endian.
+ */
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+#define le16_to_cpu(x) (bswap_16((x)))
+#define le32_to_cpu(x) (bswap_32((x)))
+#define le64_to_cpu(x) (bswap_64((x)))
+#define cpu_to_le16(x) (bswap_16((x)))
+#define cpu_to_le32(x) (bswap_32((x)))
+#define cpu_to_le64(x) (bswap_64((x)))
+#endif
+
+#if __BYTE_ORDER == __LITTLE_ENDIAN
+#define le16_to_cpu(x) (x)
+#define le32_to_cpu(x) (x)
+#define le64_to_cpu(x) (x)
+#define cpu_to_le16(x) (x)
+#define cpu_to_le32(x) (x)
+#define cpu_to_le64(x) (x)
+#endif
+
 void leader_record_in(struct leader_record *end, struct leader_record *lr);
 void leader_record_out(struct leader_record *lr, struct leader_record *end);
 void request_record_in(struct request_record *end, struct request_record *rr);
diff --git a/src/paxos_lease.c b/src/paxos_lease.c
index 7b8e95a..3e9c306 100644
--- a/src/paxos_lease.c
+++ b/src/paxos_lease.c
@@ -47,6 +47,16 @@ static uint32_t roundup_power_of_two(uint32_t val)
 	return val;
 }
 
+uint32_t leader_checksum(struct leader_record *lr)
+{
+	return crc32c((uint32_t)~1, (uint8_t *)lr, LEADER_CHECKSUM_LEN);
+}
+
+static uint32_t dblock_checksum(struct paxos_dblock *pd)
+{
+	return crc32c((uint32_t)~1, (uint8_t *)pd, DBLOCK_CHECKSUM_LEN);
+}
+
 int paxos_lease_request_read(struct task *task, struct token *token,
 			     struct request_record *rr)
 {
@@ -138,6 +148,7 @@ static int write_dblock_mblock_sh(struct task *task,
 	struct mode_block mb_end;
 	char *iobuf, **p_iobuf;
 	uint64_t offset;
+	uint32_t checksum;
 	int iobuf_len, rv;
 
 	memset(&mb, 0, sizeof(mb));
@@ -157,6 +168,14 @@ static int write_dblock_mblock_sh(struct task *task,
 	offset = disk->offset + ((2 + host_id - 1) * disk->sector_size);
 
 	paxos_dblock_out(pd, &pd_end);
+
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = dblock_checksum(&pd_end);
+	pd->checksum = checksum;
+	pd_end.checksum = cpu_to_le32(checksum);
+
 	mode_block_out(&mb, &mb_end);
 
 	memcpy(iobuf, (char *)&pd_end, sizeof(struct paxos_dblock));
@@ -183,6 +202,7 @@ static int write_dblock(struct task *task,
 			struct paxos_dblock *pd)
 {
 	struct paxos_dblock pd_end;
+	uint32_t checksum;
 	int rv;
 
 	if (token->flags & T_WRITE_DBLOCK_MBLOCK_SH) {
@@ -195,6 +215,13 @@ static int write_dblock(struct task *task,
 
 	paxos_dblock_out(pd, &pd_end);
 
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = dblock_checksum(&pd_end);
+	pd->checksum = checksum;
+	pd_end.checksum = cpu_to_le32(checksum);
+
 	rv = write_sector(disk, 2 + host_id - 1, (char *)&pd_end, sizeof(struct
paxos_dblock),
 			  task, token->io_timeout, "dblock");
 	return rv;
@@ -206,10 +233,18 @@ static int write_leader(struct task *task,
 			struct leader_record *lr)
 {
 	struct leader_record lr_end;
+	uint32_t checksum;
 	int rv;
 
 	leader_record_out(lr, &lr_end);
 
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = leader_checksum(&lr_end);
+	lr->checksum = checksum;
+	lr_end.checksum = cpu_to_le32(checksum);
+
 	rv = write_sector(disk, 0, (char *)&lr_end, sizeof(struct leader_record),
 			  task, token->io_timeout, "leader");
 	return rv;
@@ -227,10 +262,18 @@ int paxos_lease_leader_clobber(struct task *task,
 			       const char *caller)
 {
 	struct leader_record lr_end;
+	uint32_t checksum;
 	int rv;
 
 	leader_record_out(leader, &lr_end);
 
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = leader_checksum(&lr_end);
+	leader->checksum = checksum;
+	lr_end.checksum = cpu_to_le32(checksum);
+
 	rv = write_sector(&token->disks[0], 0, (char *)&lr_end, sizeof(struct
leader_record),
 			  task, token->io_timeout, caller);
 	return rv;
@@ -303,7 +346,8 @@ static int read_dblocks(struct task *task,
 static int read_leader(struct task *task,
 		       struct token *token,
 		       struct sync_disk *disk,
-		       struct leader_record *lr)
+		       struct leader_record *lr,
+		       uint32_t *checksum)
 {
 	struct leader_record lr_end;
 	int rv;
@@ -313,28 +357,22 @@ static int read_leader(struct task *task,
 	rv = read_sectors(disk, 0, 1, (char *)&lr_end, sizeof(struct leader_record),
 			  task, token->io_timeout, "leader");
 
+	/* N.B. checksum is computed while the data is in ondisk format. */
+	*checksum = leader_checksum(&lr_end);
+
 	leader_record_in(&lr_end, lr);
 
 	return rv;
 }
 
-static uint32_t dblock_checksum(struct paxos_dblock *pd)
-{
-	return crc32c((uint32_t)~1, (uint8_t *)pd, DBLOCK_CHECKSUM_LEN);
-}
-
-static int verify_dblock(struct token *token, struct paxos_dblock *pd)
+static int verify_dblock(struct token *token, struct paxos_dblock *pd, uint32_t
checksum)
 {
-	uint32_t sum;
-
 	if (!pd->checksum && !pd->mbal && !pd->bal &&
!pd->inp && !pd->lver)
 		return SANLK_OK;
 
-	sum = dblock_checksum(pd);
-
-	if (pd->checksum != sum) {
+	if (pd->checksum != checksum) {
 		log_errot(token, "verify_dblock wrong checksum %x %x",
-			  pd->checksum, sum);
+			  pd->checksum, checksum);
 		return SANLK_DBLOCK_CHECKSUM;
 	}
 
@@ -400,6 +438,7 @@ static int run_ballot(struct task *task, struct token *token, int
num_hosts,
 	struct sync_disk *disk;
 	char *iobuf[SANLK_MAX_DISKS];
 	char **p_iobuf[SANLK_MAX_DISKS];
+	uint32_t checksum;
 	int num_disks = token->r.num_disks;
 	int num_writes, num_reads;
 	int sector_size = token->disks[0].sector_size;
@@ -444,7 +483,7 @@ static int run_ballot(struct task *task, struct token *token, int
num_hosts,
 	memset(&dblock, 0, sizeof(struct paxos_dblock));
 	dblock.mbal = our_mbal;
 	dblock.lver = next_lver;
-	dblock.checksum = dblock_checksum(&dblock);
+	dblock.checksum = 0; /* set after paxos_dblock_out */
 
 	memset(&bk_max, 0, sizeof(struct paxos_dblock));
 
@@ -483,10 +522,12 @@ static int run_ballot(struct task *task, struct token *token, int
num_hosts,
 		for (q = 0; q < num_hosts; q++) {
 			bk_end = (struct paxos_dblock *)(iobuf[d] + ((2 + q)*sector_size));
 
+			checksum = dblock_checksum(bk_end);
+
 			paxos_dblock_in(bk_end, &bk_in);
 			bk = &bk_in;
 
-			rv = verify_dblock(token, bk);
+			rv = verify_dblock(token, bk, checksum);
 			if (rv < 0)
 				continue;
 
@@ -569,7 +610,7 @@ static int run_ballot(struct task *task, struct token *token, int
num_hosts,
 		dblock.inp3 = monotime();
 	}
 	dblock.bal = dblock.mbal;
-	dblock.checksum = dblock_checksum(&dblock);
+	dblock.checksum = 0; /* set after paxos_dblock_out */
 
 	if (bk_max.inp) {
 		/* not a problem, but interesting to see, so use log_error */
@@ -635,10 +676,12 @@ static int run_ballot(struct task *task, struct token *token, int
num_hosts,
 		for (q = 0; q < num_hosts; q++) {
 			bk_end = (struct paxos_dblock *)(iobuf[d] + ((2 + q)*sector_size));
 
+			checksum = dblock_checksum(bk_end);
+
 			paxos_dblock_in(bk_end, &bk_in);
 			bk = &bk_in;
 
-			rv = verify_dblock(token, bk);
+			rv = verify_dblock(token, bk, checksum);
 			if (rv < 0)
 				continue;
 
@@ -724,11 +767,6 @@ static int run_ballot(struct task *task, struct token *token, int
num_hosts,
 	return error;
 }
 
-uint32_t leader_checksum(struct leader_record *lr)
-{
-	return crc32c((uint32_t)~1, (uint8_t *)lr, LEADER_CHECKSUM_LEN);
-}
-
 static void log_leader_error(int result,
 			     struct token *token,
 			     struct sync_disk *disk,
@@ -771,11 +809,11 @@ static void log_leader_error(int result,
 static int verify_leader(struct token *token,
 			 struct sync_disk *disk,
 			 struct leader_record *lr,
+			 uint32_t checksum,
 			 const char *caller)
 {
 	struct leader_record leader_end;
 	struct leader_record leader_rr;
-	uint32_t sum;
 	int result, rv;
 
 	if (lr->magic != PAXOS_DISK_MAGIC) {
@@ -821,11 +859,9 @@ static int verify_leader(struct token *token,
 		goto fail;
 	}
 
-	sum = leader_checksum(lr);
-
-	if (lr->checksum != sum) {
+	if (lr->checksum != checksum) {
 		log_errot(token, "verify_leader wrong checksum %x %x %s",
-			  lr->checksum, sum, disk->path);
+			  lr->checksum, checksum, disk->path);
 		result = SANLK_LEADER_CHECKSUM;
 		goto fail;
 	}
@@ -851,9 +887,10 @@ static int verify_leader(struct token *token,
 int paxos_verify_leader(struct token *token,
 			 struct sync_disk *disk,
 			 struct leader_record *lr,
+			 uint32_t checksum,
 			 const char *caller)
 {
-	return verify_leader(token, disk, lr, caller);
+	return verify_leader(token, disk, lr, checksum, caller);
 }
 
 static int leaders_match(struct leader_record *a, struct leader_record *b)
@@ -870,11 +907,12 @@ int paxos_read_resource(struct task *task,
 			struct sanlk_resource *res)
 {
 	struct leader_record leader;
+	uint32_t checksum;
 	int rv;
 
 	memset(&leader, 0, sizeof(struct leader_record));
 
-	rv = read_leader(task, token, &token->disks[0], &leader);
+	rv = read_leader(task, token, &token->disks[0], &leader, &checksum);
 	if (rv < 0)
 		return rv;
 
@@ -884,7 +922,7 @@ int paxos_read_resource(struct task *task,
 	if (!res->name[0])
 		memcpy(token->r.name, leader.resource_name, NAME_ID_SIZE);
 
-	rv = verify_leader(token, &token->disks[0], &leader,
"read_resource");
+	rv = verify_leader(token, &token->disks[0], &leader, checksum,
"read_resource");
 
 	if (rv == SANLK_OK) {
 		memcpy(res->lockspace_name, leader.space_name, NAME_ID_SIZE);
@@ -928,15 +966,16 @@ static int _leader_read_one(struct task *task,
 			    const char *caller)
 {
 	struct leader_record leader;
+	uint32_t checksum;
 	int rv;
 
 	memset(&leader, 0, sizeof(struct leader_record));
 
-	rv = read_leader(task, token, &token->disks[0], &leader);
+	rv = read_leader(task, token, &token->disks[0], &leader, &checksum);
 	if (rv < 0)
 		return rv;
 
-	rv = verify_leader(token, &token->disks[0], &leader, caller);
+	rv = verify_leader(token, &token->disks[0], &leader, checksum, caller);
 
 	/* copy what we read even if verify finds a problem */
 
@@ -953,6 +992,7 @@ static int _leader_read_num(struct task *task,
 {
 	struct leader_record leader;
 	struct leader_record *leaders;
+	uint32_t checksum;
 	int *leader_reps;
 	int leaders_len, leader_reps_len;
 	int num_reads;
@@ -985,11 +1025,11 @@ static int _leader_read_num(struct task *task,
 	num_reads = 0;
 
 	for (d = 0; d < num_disks; d++) {
-		rv = read_leader(task, token, &token->disks[d], &leaders[d]);
+		rv = read_leader(task, token, &token->disks[d], &leaders[d],
&checksum);
 		if (rv < 0)
 			continue;
 
-		rv = verify_leader(token, &token->disks[d], &leaders[d], caller);
+		rv = verify_leader(token, &token->disks[d], &leaders[d], checksum, caller);
 		if (rv < 0)
 			continue;
 
@@ -1083,6 +1123,7 @@ static int _lease_read_one(struct task *task,
 	char *iobuf, **p_iobuf;
 	uint32_t host_id = token->host_id;
 	uint32_t sector_size = disk->sector_size;
+	uint32_t checksum;
 	struct paxos_dblock *bk_end;
 	uint64_t tmp_mbal = 0;
 	int q, tmp_q = -1, rv, iobuf_len;
@@ -1104,21 +1145,26 @@ static int _lease_read_one(struct task *task,
 		goto out;
 
 	memcpy(&leader_end, iobuf, sizeof(struct leader_record));
+
+	checksum = leader_checksum(&leader_end);
+
 	leader_record_in(&leader_end, leader_ret);
 
 	memcpy(&our_dblock_end, iobuf + ((host_id + 1) * sector_size), sizeof(struct
paxos_dblock));
 	paxos_dblock_in(&our_dblock_end, our_dblock);
 
-	rv = verify_leader(token, disk, leader_ret, caller);
+	rv = verify_leader(token, disk, leader_ret, checksum, caller);
 	if (rv < 0)
 		goto out;
 
 	for (q = 0; q < leader_ret->num_hosts; q++) {
 		bk_end = (struct paxos_dblock *)(iobuf + ((2 + q) * sector_size));
 
+		checksum = dblock_checksum(bk_end);
+
 		paxos_dblock_in(bk_end, &bk);
 
-		rv = verify_dblock(token, &bk);
+		rv = verify_dblock(token, &bk, checksum);
 		if (rv < 0)
 			goto out;
 
@@ -1773,7 +1819,7 @@ int paxos_lease_acquire(struct task *task,
 			new_leader.flags &= ~LFL_SHORT_HOLD;
 	}
 
-	new_leader.checksum = leader_checksum(&new_leader);
+	new_leader.checksum = 0; /* set after leader_record_out */
 
 	error = write_new_leader(task, token, &new_leader, "paxos_acquire");
 	if (error < 0) {
@@ -1843,7 +1889,7 @@ int paxos_lease_renew(struct task *task,
 	}
 
 	new_leader.timestamp = monotime();
-	new_leader.checksum = leader_checksum(&new_leader);
+	new_leader.checksum = 0; /* set after leader_record_out */
 
 	error = write_new_leader(task, token, &new_leader);
 	if (error < 0)
@@ -1941,7 +1987,7 @@ int paxos_lease_release(struct task *task,
 	leader.write_generation = token->host_generation;
 	leader.write_timestamp = monotime();
 	leader.flags &= ~LFL_SHORT_HOLD;
-	leader.checksum = leader_checksum(&leader);
+	leader.checksum = 0; /* set after leader_record_out */
 
 	error = write_new_leader(task, token, &leader, "paxos_release");
 	if (error < 0)
@@ -1961,6 +2007,7 @@ int paxos_lease_init(struct task *task,
 	struct leader_record leader_end;
 	struct request_record rr;
 	struct request_record rr_end;
+	uint32_t checksum;
 	int iobuf_len;
 	int sector_size;
 	int align_size;
@@ -2009,13 +2056,21 @@ int paxos_lease_init(struct task *task,
 	leader.timestamp = LEASE_FREE;
 	strncpy(leader.space_name, token->r.lockspace_name, NAME_ID_SIZE);
 	strncpy(leader.resource_name, token->r.name, NAME_ID_SIZE);
-	leader.checksum = leader_checksum(&leader);
+	leader.checksum = 0; /* set after leader_record_out */
 
 	memset(&rr, 0, sizeof(rr));
 	rr.magic = REQ_DISK_MAGIC;
 	rr.version = REQ_DISK_VERSION_MAJOR | REQ_DISK_VERSION_MINOR;
 
 	leader_record_out(&leader, &leader_end);
+
+	/*
+	 * N.B. must compute checksum after the data has been byte swapped.
+	 */
+	checksum = leader_checksum(&leader_end);
+	leader.checksum = checksum;
+	leader_end.checksum = cpu_to_le32(checksum);
+
 	request_record_out(&rr, &rr_end);
 
 	memcpy(iobuf, &leader_end, sizeof(struct leader_record));
diff --git a/src/paxos_lease.h b/src/paxos_lease.h
index 84082f4..de5e095 100644
--- a/src/paxos_lease.h
+++ b/src/paxos_lease.h
@@ -54,6 +54,7 @@ int paxos_read_buf(struct task *task,
 int paxos_verify_leader(struct token *token,
                          struct sync_disk *disk,
                          struct leader_record *lr,
+			 uint32_t checksum,
                          const char *caller);
 
 int paxos_erase_dblock(struct task *task,
diff --git a/src/resource.c b/src/resource.c
index 9834a84..8e94a63 100644
--- a/src/resource.c
+++ b/src/resource.c
@@ -99,6 +99,7 @@ int read_resource_owners(struct task *task, struct token *token,
 	struct sanlk_host *host;
 	struct mode_block *mb_end;
 	uint64_t host_id;
+	uint32_t checksum;
 	char *lease_buf_dblock;
 	char *lease_buf = NULL;
 	char *hosts_buf = NULL;
@@ -120,9 +121,11 @@ int read_resource_owners(struct task *task, struct token *token,
 
 	memcpy(&leader_end, lease_buf, sizeof(struct leader_record));
 
+	checksum = leader_checksum(&leader_end);
+
 	leader_record_in(&leader_end, &leader);
 
-	rv = paxos_verify_leader(token, disk, &leader, "read_resource_owners");
+	rv = paxos_verify_leader(token, disk, &leader, checksum,
"read_resource_owners");
 	if (rv < 0)
 		goto out;