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@redhat.com 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@redhat.com

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;