861e2369e9
Some errno values differ across platforms. So if we return things like -EINPROGRESS from one node it can get misinterpreted or rejected on another one. This patch fixes up the errno values passed on the wire so that they match the x86 ones (so as not to break the protocol), and re-instates the platform-specific ones at the other end. Many thanks to Fabio for testing this patch. Initial patch from Patrick. Signed-off-by: Patrick Caulfield <pcaulfie@redhat.com> Signed-off-by: Fabio M. Di Nitto <fabbione@ubuntu.com> Signed-off-by: David Teigland <teigland@redhat.com>
222 lines
6.5 KiB
C
222 lines
6.5 KiB
C
/******************************************************************************
|
|
*******************************************************************************
|
|
**
|
|
** 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 "rcom.h"
|
|
#include "util.h"
|
|
|
|
#define DLM_ERRNO_EDEADLK 35
|
|
#define DLM_ERRNO_EBADR 53
|
|
#define DLM_ERRNO_EBADSLT 57
|
|
#define DLM_ERRNO_EPROTO 71
|
|
#define DLM_ERRNO_EOPNOTSUPP 95
|
|
#define DLM_ERRNO_ETIMEDOUT 110
|
|
#define DLM_ERRNO_EINPROGRESS 115
|
|
|
|
static void header_out(struct dlm_header *hd)
|
|
{
|
|
hd->h_version = cpu_to_le32(hd->h_version);
|
|
hd->h_lockspace = cpu_to_le32(hd->h_lockspace);
|
|
hd->h_nodeid = cpu_to_le32(hd->h_nodeid);
|
|
hd->h_length = cpu_to_le16(hd->h_length);
|
|
}
|
|
|
|
static void header_in(struct dlm_header *hd)
|
|
{
|
|
hd->h_version = le32_to_cpu(hd->h_version);
|
|
hd->h_lockspace = le32_to_cpu(hd->h_lockspace);
|
|
hd->h_nodeid = le32_to_cpu(hd->h_nodeid);
|
|
hd->h_length = le16_to_cpu(hd->h_length);
|
|
}
|
|
|
|
/* higher errno values are inconsistent across architectures, so select
|
|
one set of values for on the wire */
|
|
|
|
static int to_dlm_errno(int err)
|
|
{
|
|
switch (err) {
|
|
case -EDEADLK:
|
|
return -DLM_ERRNO_EDEADLK;
|
|
case -EBADR:
|
|
return -DLM_ERRNO_EBADR;
|
|
case -EBADSLT:
|
|
return -DLM_ERRNO_EBADSLT;
|
|
case -EPROTO:
|
|
return -DLM_ERRNO_EPROTO;
|
|
case -EOPNOTSUPP:
|
|
return -DLM_ERRNO_EOPNOTSUPP;
|
|
case -ETIMEDOUT:
|
|
return -DLM_ERRNO_ETIMEDOUT;
|
|
case -EINPROGRESS:
|
|
return -DLM_ERRNO_EINPROGRESS;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
static int from_dlm_errno(int err)
|
|
{
|
|
switch (err) {
|
|
case -DLM_ERRNO_EDEADLK:
|
|
return -EDEADLK;
|
|
case -DLM_ERRNO_EBADR:
|
|
return -EBADR;
|
|
case -DLM_ERRNO_EBADSLT:
|
|
return -EBADSLT;
|
|
case -DLM_ERRNO_EPROTO:
|
|
return -EPROTO;
|
|
case -DLM_ERRNO_EOPNOTSUPP:
|
|
return -EOPNOTSUPP;
|
|
case -DLM_ERRNO_ETIMEDOUT:
|
|
return -ETIMEDOUT;
|
|
case -DLM_ERRNO_EINPROGRESS:
|
|
return -EINPROGRESS;
|
|
}
|
|
return err;
|
|
}
|
|
|
|
void dlm_message_out(struct dlm_message *ms)
|
|
{
|
|
struct dlm_header *hd = (struct dlm_header *) ms;
|
|
|
|
header_out(hd);
|
|
|
|
ms->m_type = cpu_to_le32(ms->m_type);
|
|
ms->m_nodeid = cpu_to_le32(ms->m_nodeid);
|
|
ms->m_pid = cpu_to_le32(ms->m_pid);
|
|
ms->m_lkid = cpu_to_le32(ms->m_lkid);
|
|
ms->m_remid = cpu_to_le32(ms->m_remid);
|
|
ms->m_parent_lkid = cpu_to_le32(ms->m_parent_lkid);
|
|
ms->m_parent_remid = cpu_to_le32(ms->m_parent_remid);
|
|
ms->m_exflags = cpu_to_le32(ms->m_exflags);
|
|
ms->m_sbflags = cpu_to_le32(ms->m_sbflags);
|
|
ms->m_flags = cpu_to_le32(ms->m_flags);
|
|
ms->m_lvbseq = cpu_to_le32(ms->m_lvbseq);
|
|
ms->m_hash = cpu_to_le32(ms->m_hash);
|
|
ms->m_status = cpu_to_le32(ms->m_status);
|
|
ms->m_grmode = cpu_to_le32(ms->m_grmode);
|
|
ms->m_rqmode = cpu_to_le32(ms->m_rqmode);
|
|
ms->m_bastmode = cpu_to_le32(ms->m_bastmode);
|
|
ms->m_asts = cpu_to_le32(ms->m_asts);
|
|
ms->m_result = cpu_to_le32(to_dlm_errno(ms->m_result));
|
|
}
|
|
|
|
void dlm_message_in(struct dlm_message *ms)
|
|
{
|
|
struct dlm_header *hd = (struct dlm_header *) ms;
|
|
|
|
header_in(hd);
|
|
|
|
ms->m_type = le32_to_cpu(ms->m_type);
|
|
ms->m_nodeid = le32_to_cpu(ms->m_nodeid);
|
|
ms->m_pid = le32_to_cpu(ms->m_pid);
|
|
ms->m_lkid = le32_to_cpu(ms->m_lkid);
|
|
ms->m_remid = le32_to_cpu(ms->m_remid);
|
|
ms->m_parent_lkid = le32_to_cpu(ms->m_parent_lkid);
|
|
ms->m_parent_remid = le32_to_cpu(ms->m_parent_remid);
|
|
ms->m_exflags = le32_to_cpu(ms->m_exflags);
|
|
ms->m_sbflags = le32_to_cpu(ms->m_sbflags);
|
|
ms->m_flags = le32_to_cpu(ms->m_flags);
|
|
ms->m_lvbseq = le32_to_cpu(ms->m_lvbseq);
|
|
ms->m_hash = le32_to_cpu(ms->m_hash);
|
|
ms->m_status = le32_to_cpu(ms->m_status);
|
|
ms->m_grmode = le32_to_cpu(ms->m_grmode);
|
|
ms->m_rqmode = le32_to_cpu(ms->m_rqmode);
|
|
ms->m_bastmode = le32_to_cpu(ms->m_bastmode);
|
|
ms->m_asts = le32_to_cpu(ms->m_asts);
|
|
ms->m_result = from_dlm_errno(le32_to_cpu(ms->m_result));
|
|
}
|
|
|
|
static void rcom_lock_out(struct rcom_lock *rl)
|
|
{
|
|
rl->rl_ownpid = cpu_to_le32(rl->rl_ownpid);
|
|
rl->rl_lkid = cpu_to_le32(rl->rl_lkid);
|
|
rl->rl_remid = cpu_to_le32(rl->rl_remid);
|
|
rl->rl_parent_lkid = cpu_to_le32(rl->rl_parent_lkid);
|
|
rl->rl_parent_remid = cpu_to_le32(rl->rl_parent_remid);
|
|
rl->rl_exflags = cpu_to_le32(rl->rl_exflags);
|
|
rl->rl_flags = cpu_to_le32(rl->rl_flags);
|
|
rl->rl_lvbseq = cpu_to_le32(rl->rl_lvbseq);
|
|
rl->rl_result = cpu_to_le32(rl->rl_result);
|
|
rl->rl_wait_type = cpu_to_le16(rl->rl_wait_type);
|
|
rl->rl_namelen = cpu_to_le16(rl->rl_namelen);
|
|
}
|
|
|
|
static void rcom_lock_in(struct rcom_lock *rl)
|
|
{
|
|
rl->rl_ownpid = le32_to_cpu(rl->rl_ownpid);
|
|
rl->rl_lkid = le32_to_cpu(rl->rl_lkid);
|
|
rl->rl_remid = le32_to_cpu(rl->rl_remid);
|
|
rl->rl_parent_lkid = le32_to_cpu(rl->rl_parent_lkid);
|
|
rl->rl_parent_remid = le32_to_cpu(rl->rl_parent_remid);
|
|
rl->rl_exflags = le32_to_cpu(rl->rl_exflags);
|
|
rl->rl_flags = le32_to_cpu(rl->rl_flags);
|
|
rl->rl_lvbseq = le32_to_cpu(rl->rl_lvbseq);
|
|
rl->rl_result = le32_to_cpu(rl->rl_result);
|
|
rl->rl_wait_type = le16_to_cpu(rl->rl_wait_type);
|
|
rl->rl_namelen = le16_to_cpu(rl->rl_namelen);
|
|
}
|
|
|
|
static void rcom_config_out(struct rcom_config *rf)
|
|
{
|
|
rf->rf_lvblen = cpu_to_le32(rf->rf_lvblen);
|
|
rf->rf_lsflags = cpu_to_le32(rf->rf_lsflags);
|
|
}
|
|
|
|
static void rcom_config_in(struct rcom_config *rf)
|
|
{
|
|
rf->rf_lvblen = le32_to_cpu(rf->rf_lvblen);
|
|
rf->rf_lsflags = le32_to_cpu(rf->rf_lsflags);
|
|
}
|
|
|
|
void dlm_rcom_out(struct dlm_rcom *rc)
|
|
{
|
|
struct dlm_header *hd = (struct dlm_header *) rc;
|
|
int type = rc->rc_type;
|
|
|
|
header_out(hd);
|
|
|
|
rc->rc_type = cpu_to_le32(rc->rc_type);
|
|
rc->rc_result = cpu_to_le32(rc->rc_result);
|
|
rc->rc_id = cpu_to_le64(rc->rc_id);
|
|
rc->rc_seq = cpu_to_le64(rc->rc_seq);
|
|
rc->rc_seq_reply = cpu_to_le64(rc->rc_seq_reply);
|
|
|
|
if ((type == DLM_RCOM_LOCK) || (type == DLM_RCOM_LOCK_REPLY))
|
|
rcom_lock_out((struct rcom_lock *) rc->rc_buf);
|
|
|
|
else if (type == DLM_RCOM_STATUS_REPLY)
|
|
rcom_config_out((struct rcom_config *) rc->rc_buf);
|
|
}
|
|
|
|
void dlm_rcom_in(struct dlm_rcom *rc)
|
|
{
|
|
struct dlm_header *hd = (struct dlm_header *) rc;
|
|
int type;
|
|
|
|
header_in(hd);
|
|
|
|
rc->rc_type = le32_to_cpu(rc->rc_type);
|
|
rc->rc_result = le32_to_cpu(rc->rc_result);
|
|
rc->rc_id = le64_to_cpu(rc->rc_id);
|
|
rc->rc_seq = le64_to_cpu(rc->rc_seq);
|
|
rc->rc_seq_reply = le64_to_cpu(rc->rc_seq_reply);
|
|
|
|
type = rc->rc_type;
|
|
|
|
if ((type == DLM_RCOM_LOCK) || (type == DLM_RCOM_LOCK_REPLY))
|
|
rcom_lock_in((struct rcom_lock *) rc->rc_buf);
|
|
|
|
else if (type == DLM_RCOM_STATUS_REPLY)
|
|
rcom_config_in((struct rcom_config *) rc->rc_buf);
|
|
}
|
|
|