mirror of
https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git
synced 2024-08-23 01:10:04 +00:00
![David Teigland](/assets/img/avatar_default.png)
A reply to a recovery message will often be received after the relevant recovery sequence has aborted and the next recovery sequence has begun. We need to ignore replies to these old messages from the previous recovery. There's already a way to do this for synchronous recovery requests using the rc_id number, but not for async. Each recovery sequence already has a locally unique sequence number associated with it. This patch adds a field to the rcom (recovery message) structure where this recovery sequence number can be placed, rc_seq. When a node sends a reply to a recovery request, it copies the rc_seq number it received into rc_seq_reply. When the first node receives the reply to its recovery message, it will check whether rc_seq_reply matches the current recovery sequence number, ls_recover_seq, and if not then it ignores the old reply. An old, inadequate approach to filtering out old replies (checking if the current stage of recovery has moved back to the start) has been removed from two spots. The protocol version number is changed to reflect the different rcom structures. Signed-off-by: David Teigland <teigland@redhat.com> Signed-off-by: Steven Whitehouse <swhiteho@redhat.com>
517 lines
13 KiB
C
517 lines
13 KiB
C
/******************************************************************************
|
|
*******************************************************************************
|
|
**
|
|
** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
|
** Copyright (C) 2005 Red Hat, Inc. All rights reserved.
|
|
**
|
|
** This copyrighted material is made available to anyone wishing to use,
|
|
** modify, copy, or redistribute it subject to the terms and conditions
|
|
** of the GNU General Public License v.2.
|
|
**
|
|
*******************************************************************************
|
|
******************************************************************************/
|
|
|
|
#include "dlm_internal.h"
|
|
#include "lockspace.h"
|
|
#include "member.h"
|
|
#include "lowcomms.h"
|
|
#include "midcomms.h"
|
|
#include "rcom.h"
|
|
#include "recover.h"
|
|
#include "dir.h"
|
|
#include "config.h"
|
|
#include "memory.h"
|
|
#include "lock.h"
|
|
#include "util.h"
|
|
|
|
|
|
static int rcom_response(struct dlm_ls *ls)
|
|
{
|
|
return test_bit(LSFL_RCOM_READY, &ls->ls_flags);
|
|
}
|
|
|
|
static int create_rcom(struct dlm_ls *ls, int to_nodeid, int type, int len,
|
|
struct dlm_rcom **rc_ret, struct dlm_mhandle **mh_ret)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
char *mb;
|
|
int mb_len = sizeof(struct dlm_rcom) + len;
|
|
|
|
mh = dlm_lowcomms_get_buffer(to_nodeid, mb_len, GFP_KERNEL, &mb);
|
|
if (!mh) {
|
|
log_print("create_rcom to %d type %d len %d ENOBUFS",
|
|
to_nodeid, type, len);
|
|
return -ENOBUFS;
|
|
}
|
|
memset(mb, 0, mb_len);
|
|
|
|
rc = (struct dlm_rcom *) mb;
|
|
|
|
rc->rc_header.h_version = (DLM_HEADER_MAJOR | DLM_HEADER_MINOR);
|
|
rc->rc_header.h_lockspace = ls->ls_global_id;
|
|
rc->rc_header.h_nodeid = dlm_our_nodeid();
|
|
rc->rc_header.h_length = mb_len;
|
|
rc->rc_header.h_cmd = DLM_RCOM;
|
|
|
|
rc->rc_type = type;
|
|
|
|
spin_lock(&ls->ls_recover_lock);
|
|
rc->rc_seq = ls->ls_recover_seq;
|
|
spin_unlock(&ls->ls_recover_lock);
|
|
|
|
*mh_ret = mh;
|
|
*rc_ret = rc;
|
|
return 0;
|
|
}
|
|
|
|
static void send_rcom(struct dlm_ls *ls, struct dlm_mhandle *mh,
|
|
struct dlm_rcom *rc)
|
|
{
|
|
dlm_rcom_out(rc);
|
|
dlm_lowcomms_commit_buffer(mh);
|
|
}
|
|
|
|
/* When replying to a status request, a node also sends back its
|
|
configuration values. The requesting node then checks that the remote
|
|
node is configured the same way as itself. */
|
|
|
|
static void make_config(struct dlm_ls *ls, struct rcom_config *rf)
|
|
{
|
|
rf->rf_lvblen = ls->ls_lvblen;
|
|
rf->rf_lsflags = ls->ls_exflags;
|
|
}
|
|
|
|
static int check_config(struct dlm_ls *ls, struct rcom_config *rf, int nodeid)
|
|
{
|
|
if (rf->rf_lvblen != ls->ls_lvblen ||
|
|
rf->rf_lsflags != ls->ls_exflags) {
|
|
log_error(ls, "config mismatch: %d,%x nodeid %d: %d,%x",
|
|
ls->ls_lvblen, ls->ls_exflags,
|
|
nodeid, rf->rf_lvblen, rf->rf_lsflags);
|
|
return -EINVAL;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
static void allow_sync_reply(struct dlm_ls *ls, uint64_t *new_seq)
|
|
{
|
|
spin_lock(&ls->ls_rcom_spin);
|
|
*new_seq = ++ls->ls_rcom_seq;
|
|
set_bit(LSFL_RCOM_WAIT, &ls->ls_flags);
|
|
spin_unlock(&ls->ls_rcom_spin);
|
|
}
|
|
|
|
static void disallow_sync_reply(struct dlm_ls *ls)
|
|
{
|
|
spin_lock(&ls->ls_rcom_spin);
|
|
clear_bit(LSFL_RCOM_WAIT, &ls->ls_flags);
|
|
clear_bit(LSFL_RCOM_READY, &ls->ls_flags);
|
|
spin_unlock(&ls->ls_rcom_spin);
|
|
}
|
|
|
|
int dlm_rcom_status(struct dlm_ls *ls, int nodeid)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
int error = 0;
|
|
|
|
ls->ls_recover_nodeid = nodeid;
|
|
|
|
if (nodeid == dlm_our_nodeid()) {
|
|
rc = (struct dlm_rcom *) ls->ls_recover_buf;
|
|
rc->rc_result = dlm_recover_status(ls);
|
|
goto out;
|
|
}
|
|
|
|
error = create_rcom(ls, nodeid, DLM_RCOM_STATUS, 0, &rc, &mh);
|
|
if (error)
|
|
goto out;
|
|
|
|
allow_sync_reply(ls, &rc->rc_id);
|
|
memset(ls->ls_recover_buf, 0, dlm_config.buffer_size);
|
|
|
|
send_rcom(ls, mh, rc);
|
|
|
|
error = dlm_wait_function(ls, &rcom_response);
|
|
disallow_sync_reply(ls);
|
|
if (error)
|
|
goto out;
|
|
|
|
rc = (struct dlm_rcom *) ls->ls_recover_buf;
|
|
|
|
if (rc->rc_result == -ESRCH) {
|
|
/* we pretend the remote lockspace exists with 0 status */
|
|
log_debug(ls, "remote node %d not ready", nodeid);
|
|
rc->rc_result = 0;
|
|
} else
|
|
error = check_config(ls, (struct rcom_config *) rc->rc_buf,
|
|
nodeid);
|
|
/* the caller looks at rc_result for the remote recovery status */
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static void receive_rcom_status(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
int error, nodeid = rc_in->rc_header.h_nodeid;
|
|
|
|
error = create_rcom(ls, nodeid, DLM_RCOM_STATUS_REPLY,
|
|
sizeof(struct rcom_config), &rc, &mh);
|
|
if (error)
|
|
return;
|
|
rc->rc_id = rc_in->rc_id;
|
|
rc->rc_seq_reply = rc_in->rc_seq;
|
|
rc->rc_result = dlm_recover_status(ls);
|
|
make_config(ls, (struct rcom_config *) rc->rc_buf);
|
|
|
|
send_rcom(ls, mh, rc);
|
|
}
|
|
|
|
static void receive_sync_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
spin_lock(&ls->ls_rcom_spin);
|
|
if (!test_bit(LSFL_RCOM_WAIT, &ls->ls_flags) ||
|
|
rc_in->rc_id != ls->ls_rcom_seq) {
|
|
log_debug(ls, "reject reply %d from %d seq %llx expect %llx",
|
|
rc_in->rc_type, rc_in->rc_header.h_nodeid,
|
|
(unsigned long long)rc_in->rc_id,
|
|
(unsigned long long)ls->ls_rcom_seq);
|
|
goto out;
|
|
}
|
|
memcpy(ls->ls_recover_buf, rc_in, rc_in->rc_header.h_length);
|
|
set_bit(LSFL_RCOM_READY, &ls->ls_flags);
|
|
clear_bit(LSFL_RCOM_WAIT, &ls->ls_flags);
|
|
wake_up(&ls->ls_wait_general);
|
|
out:
|
|
spin_unlock(&ls->ls_rcom_spin);
|
|
}
|
|
|
|
static void receive_rcom_status_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
receive_sync_reply(ls, rc_in);
|
|
}
|
|
|
|
int dlm_rcom_names(struct dlm_ls *ls, int nodeid, char *last_name, int last_len)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
int error = 0, len = sizeof(struct dlm_rcom);
|
|
|
|
ls->ls_recover_nodeid = nodeid;
|
|
|
|
if (nodeid == dlm_our_nodeid()) {
|
|
dlm_copy_master_names(ls, last_name, last_len,
|
|
ls->ls_recover_buf + len,
|
|
dlm_config.buffer_size - len, nodeid);
|
|
goto out;
|
|
}
|
|
|
|
error = create_rcom(ls, nodeid, DLM_RCOM_NAMES, last_len, &rc, &mh);
|
|
if (error)
|
|
goto out;
|
|
memcpy(rc->rc_buf, last_name, last_len);
|
|
|
|
allow_sync_reply(ls, &rc->rc_id);
|
|
memset(ls->ls_recover_buf, 0, dlm_config.buffer_size);
|
|
|
|
send_rcom(ls, mh, rc);
|
|
|
|
error = dlm_wait_function(ls, &rcom_response);
|
|
disallow_sync_reply(ls);
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static void receive_rcom_names(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
int error, inlen, outlen, nodeid;
|
|
|
|
nodeid = rc_in->rc_header.h_nodeid;
|
|
inlen = rc_in->rc_header.h_length - sizeof(struct dlm_rcom);
|
|
outlen = dlm_config.buffer_size - sizeof(struct dlm_rcom);
|
|
|
|
error = create_rcom(ls, nodeid, DLM_RCOM_NAMES_REPLY, outlen, &rc, &mh);
|
|
if (error)
|
|
return;
|
|
rc->rc_id = rc_in->rc_id;
|
|
rc->rc_seq_reply = rc_in->rc_seq;
|
|
|
|
dlm_copy_master_names(ls, rc_in->rc_buf, inlen, rc->rc_buf, outlen,
|
|
nodeid);
|
|
send_rcom(ls, mh, rc);
|
|
}
|
|
|
|
static void receive_rcom_names_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
receive_sync_reply(ls, rc_in);
|
|
}
|
|
|
|
int dlm_send_rcom_lookup(struct dlm_rsb *r, int dir_nodeid)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
struct dlm_ls *ls = r->res_ls;
|
|
int error;
|
|
|
|
error = create_rcom(ls, dir_nodeid, DLM_RCOM_LOOKUP, r->res_length,
|
|
&rc, &mh);
|
|
if (error)
|
|
goto out;
|
|
memcpy(rc->rc_buf, r->res_name, r->res_length);
|
|
rc->rc_id = (unsigned long) r;
|
|
|
|
send_rcom(ls, mh, rc);
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static void receive_rcom_lookup(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
int error, ret_nodeid, nodeid = rc_in->rc_header.h_nodeid;
|
|
int len = rc_in->rc_header.h_length - sizeof(struct dlm_rcom);
|
|
|
|
error = create_rcom(ls, nodeid, DLM_RCOM_LOOKUP_REPLY, 0, &rc, &mh);
|
|
if (error)
|
|
return;
|
|
|
|
error = dlm_dir_lookup(ls, nodeid, rc_in->rc_buf, len, &ret_nodeid);
|
|
if (error)
|
|
ret_nodeid = error;
|
|
rc->rc_result = ret_nodeid;
|
|
rc->rc_id = rc_in->rc_id;
|
|
rc->rc_seq_reply = rc_in->rc_seq;
|
|
|
|
send_rcom(ls, mh, rc);
|
|
}
|
|
|
|
static void receive_rcom_lookup_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
dlm_recover_master_reply(ls, rc_in);
|
|
}
|
|
|
|
static void pack_rcom_lock(struct dlm_rsb *r, struct dlm_lkb *lkb,
|
|
struct rcom_lock *rl)
|
|
{
|
|
memset(rl, 0, sizeof(*rl));
|
|
|
|
rl->rl_ownpid = lkb->lkb_ownpid;
|
|
rl->rl_lkid = lkb->lkb_id;
|
|
rl->rl_exflags = lkb->lkb_exflags;
|
|
rl->rl_flags = lkb->lkb_flags;
|
|
rl->rl_lvbseq = lkb->lkb_lvbseq;
|
|
rl->rl_rqmode = lkb->lkb_rqmode;
|
|
rl->rl_grmode = lkb->lkb_grmode;
|
|
rl->rl_status = lkb->lkb_status;
|
|
rl->rl_wait_type = lkb->lkb_wait_type;
|
|
|
|
if (lkb->lkb_bastaddr)
|
|
rl->rl_asts |= AST_BAST;
|
|
if (lkb->lkb_astaddr)
|
|
rl->rl_asts |= AST_COMP;
|
|
|
|
rl->rl_namelen = r->res_length;
|
|
memcpy(rl->rl_name, r->res_name, r->res_length);
|
|
|
|
/* FIXME: might we have an lvb without DLM_LKF_VALBLK set ?
|
|
If so, receive_rcom_lock_args() won't take this copy. */
|
|
|
|
if (lkb->lkb_lvbptr)
|
|
memcpy(rl->rl_lvb, lkb->lkb_lvbptr, r->res_ls->ls_lvblen);
|
|
}
|
|
|
|
int dlm_send_rcom_lock(struct dlm_rsb *r, struct dlm_lkb *lkb)
|
|
{
|
|
struct dlm_ls *ls = r->res_ls;
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
struct rcom_lock *rl;
|
|
int error, len = sizeof(struct rcom_lock);
|
|
|
|
if (lkb->lkb_lvbptr)
|
|
len += ls->ls_lvblen;
|
|
|
|
error = create_rcom(ls, r->res_nodeid, DLM_RCOM_LOCK, len, &rc, &mh);
|
|
if (error)
|
|
goto out;
|
|
|
|
rl = (struct rcom_lock *) rc->rc_buf;
|
|
pack_rcom_lock(r, lkb, rl);
|
|
rc->rc_id = (unsigned long) r;
|
|
|
|
send_rcom(ls, mh, rc);
|
|
out:
|
|
return error;
|
|
}
|
|
|
|
static void receive_rcom_lock(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct dlm_mhandle *mh;
|
|
int error, nodeid = rc_in->rc_header.h_nodeid;
|
|
|
|
dlm_recover_master_copy(ls, rc_in);
|
|
|
|
error = create_rcom(ls, nodeid, DLM_RCOM_LOCK_REPLY,
|
|
sizeof(struct rcom_lock), &rc, &mh);
|
|
if (error)
|
|
return;
|
|
|
|
/* We send back the same rcom_lock struct we received, but
|
|
dlm_recover_master_copy() has filled in rl_remid and rl_result */
|
|
|
|
memcpy(rc->rc_buf, rc_in->rc_buf, sizeof(struct rcom_lock));
|
|
rc->rc_id = rc_in->rc_id;
|
|
rc->rc_seq_reply = rc_in->rc_seq;
|
|
|
|
send_rcom(ls, mh, rc);
|
|
}
|
|
|
|
static void receive_rcom_lock_reply(struct dlm_ls *ls, struct dlm_rcom *rc_in)
|
|
{
|
|
dlm_recover_process_copy(ls, rc_in);
|
|
}
|
|
|
|
static int send_ls_not_ready(int nodeid, struct dlm_rcom *rc_in)
|
|
{
|
|
struct dlm_rcom *rc;
|
|
struct rcom_config *rf;
|
|
struct dlm_mhandle *mh;
|
|
char *mb;
|
|
int mb_len = sizeof(struct dlm_rcom) + sizeof(struct rcom_config);
|
|
|
|
mh = dlm_lowcomms_get_buffer(nodeid, mb_len, GFP_KERNEL, &mb);
|
|
if (!mh)
|
|
return -ENOBUFS;
|
|
memset(mb, 0, mb_len);
|
|
|
|
rc = (struct dlm_rcom *) mb;
|
|
|
|
rc->rc_header.h_version = (DLM_HEADER_MAJOR | DLM_HEADER_MINOR);
|
|
rc->rc_header.h_lockspace = rc_in->rc_header.h_lockspace;
|
|
rc->rc_header.h_nodeid = dlm_our_nodeid();
|
|
rc->rc_header.h_length = mb_len;
|
|
rc->rc_header.h_cmd = DLM_RCOM;
|
|
|
|
rc->rc_type = DLM_RCOM_STATUS_REPLY;
|
|
rc->rc_id = rc_in->rc_id;
|
|
rc->rc_seq_reply = rc_in->rc_seq;
|
|
rc->rc_result = -ESRCH;
|
|
|
|
rf = (struct rcom_config *) rc->rc_buf;
|
|
rf->rf_lvblen = -1;
|
|
|
|
dlm_rcom_out(rc);
|
|
dlm_lowcomms_commit_buffer(mh);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int is_old_reply(struct dlm_ls *ls, struct dlm_rcom *rc)
|
|
{
|
|
uint64_t seq;
|
|
int rv = 0;
|
|
|
|
switch (rc->rc_type) {
|
|
case DLM_RCOM_STATUS_REPLY:
|
|
case DLM_RCOM_NAMES_REPLY:
|
|
case DLM_RCOM_LOOKUP_REPLY:
|
|
case DLM_RCOM_LOCK_REPLY:
|
|
spin_lock(&ls->ls_recover_lock);
|
|
seq = ls->ls_recover_seq;
|
|
spin_unlock(&ls->ls_recover_lock);
|
|
if (rc->rc_seq_reply != seq) {
|
|
log_error(ls, "ignoring old reply %x from %d "
|
|
"seq_reply %llx expect %llx",
|
|
rc->rc_type, rc->rc_header.h_nodeid,
|
|
(unsigned long long)rc->rc_seq_reply,
|
|
(unsigned long long)seq);
|
|
rv = 1;
|
|
}
|
|
}
|
|
return rv;
|
|
}
|
|
|
|
/* Called by dlm_recvd; corresponds to dlm_receive_message() but special
|
|
recovery-only comms are sent through here. */
|
|
|
|
void dlm_receive_rcom(struct dlm_header *hd, int nodeid)
|
|
{
|
|
struct dlm_rcom *rc = (struct dlm_rcom *) hd;
|
|
struct dlm_ls *ls;
|
|
|
|
dlm_rcom_in(rc);
|
|
|
|
/* If the lockspace doesn't exist then still send a status message
|
|
back; it's possible that it just doesn't have its global_id yet. */
|
|
|
|
ls = dlm_find_lockspace_global(hd->h_lockspace);
|
|
if (!ls) {
|
|
log_print("lockspace %x from %d type %x not found",
|
|
hd->h_lockspace, nodeid, rc->rc_type);
|
|
if (rc->rc_type == DLM_RCOM_STATUS)
|
|
send_ls_not_ready(nodeid, rc);
|
|
return;
|
|
}
|
|
|
|
if (dlm_recovery_stopped(ls) && (rc->rc_type != DLM_RCOM_STATUS)) {
|
|
log_error(ls, "ignoring recovery message %x from %d",
|
|
rc->rc_type, nodeid);
|
|
goto out;
|
|
}
|
|
|
|
if (is_old_reply(ls, rc))
|
|
goto out;
|
|
|
|
if (nodeid != rc->rc_header.h_nodeid) {
|
|
log_error(ls, "bad rcom nodeid %d from %d",
|
|
rc->rc_header.h_nodeid, nodeid);
|
|
goto out;
|
|
}
|
|
|
|
switch (rc->rc_type) {
|
|
case DLM_RCOM_STATUS:
|
|
receive_rcom_status(ls, rc);
|
|
break;
|
|
|
|
case DLM_RCOM_NAMES:
|
|
receive_rcom_names(ls, rc);
|
|
break;
|
|
|
|
case DLM_RCOM_LOOKUP:
|
|
receive_rcom_lookup(ls, rc);
|
|
break;
|
|
|
|
case DLM_RCOM_LOCK:
|
|
receive_rcom_lock(ls, rc);
|
|
break;
|
|
|
|
case DLM_RCOM_STATUS_REPLY:
|
|
receive_rcom_status_reply(ls, rc);
|
|
break;
|
|
|
|
case DLM_RCOM_NAMES_REPLY:
|
|
receive_rcom_names_reply(ls, rc);
|
|
break;
|
|
|
|
case DLM_RCOM_LOOKUP_REPLY:
|
|
receive_rcom_lookup_reply(ls, rc);
|
|
break;
|
|
|
|
case DLM_RCOM_LOCK_REPLY:
|
|
receive_rcom_lock_reply(ls, rc);
|
|
break;
|
|
|
|
default:
|
|
DLM_ASSERT(0, printk("rc_type=%x\n", rc->rc_type););
|
|
}
|
|
out:
|
|
dlm_put_lockspace(ls);
|
|
}
|
|
|