e7fd41792f
This is the core of the distributed lock manager which is required to use GFS2 as a cluster filesystem. It is also used by CLVM and can be used as a standalone lock manager independantly of either of these two projects. It implements VAX-style locking modes. Signed-off-by: David Teigland <teigland@redhat.com> Signed-off-by: Steve Whitehouse <swhiteho@redhat.com>
141 lines
3.8 KiB
C
141 lines
3.8 KiB
C
/******************************************************************************
|
|
*******************************************************************************
|
|
**
|
|
** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
|
|
** Copyright (C) 2004-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.
|
|
**
|
|
*******************************************************************************
|
|
******************************************************************************/
|
|
|
|
/*
|
|
* midcomms.c
|
|
*
|
|
* This is the appallingly named "mid-level" comms layer.
|
|
*
|
|
* Its purpose is to take packets from the "real" comms layer,
|
|
* split them up into packets and pass them to the interested
|
|
* part of the locking mechanism.
|
|
*
|
|
* It also takes messages from the locking layer, formats them
|
|
* into packets and sends them to the comms layer.
|
|
*/
|
|
|
|
#include "dlm_internal.h"
|
|
#include "lowcomms.h"
|
|
#include "config.h"
|
|
#include "rcom.h"
|
|
#include "lock.h"
|
|
#include "midcomms.h"
|
|
|
|
|
|
static void copy_from_cb(void *dst, const void *base, unsigned offset,
|
|
unsigned len, unsigned limit)
|
|
{
|
|
unsigned copy = len;
|
|
|
|
if ((copy + offset) > limit)
|
|
copy = limit - offset;
|
|
memcpy(dst, base + offset, copy);
|
|
len -= copy;
|
|
if (len)
|
|
memcpy(dst + copy, base, len);
|
|
}
|
|
|
|
/*
|
|
* Called from the low-level comms layer to process a buffer of
|
|
* commands.
|
|
*
|
|
* Only complete messages are processed here, any "spare" bytes from
|
|
* the end of a buffer are saved and tacked onto the front of the next
|
|
* message that comes in. I doubt this will happen very often but we
|
|
* need to be able to cope with it and I don't want the task to be waiting
|
|
* for packets to come in when there is useful work to be done.
|
|
*/
|
|
|
|
int dlm_process_incoming_buffer(int nodeid, const void *base,
|
|
unsigned offset, unsigned len, unsigned limit)
|
|
{
|
|
unsigned char __tmp[DLM_INBUF_LEN];
|
|
struct dlm_header *msg = (struct dlm_header *) __tmp;
|
|
int ret = 0;
|
|
int err = 0;
|
|
uint16_t msglen;
|
|
uint32_t lockspace;
|
|
|
|
while (len > sizeof(struct dlm_header)) {
|
|
|
|
/* Copy just the header to check the total length. The
|
|
message may wrap around the end of the buffer back to the
|
|
start, so we need to use a temp buffer and copy_from_cb. */
|
|
|
|
copy_from_cb(msg, base, offset, sizeof(struct dlm_header),
|
|
limit);
|
|
|
|
msglen = le16_to_cpu(msg->h_length);
|
|
lockspace = msg->h_lockspace;
|
|
|
|
err = -EINVAL;
|
|
if (msglen < sizeof(struct dlm_header))
|
|
break;
|
|
err = -E2BIG;
|
|
if (msglen > dlm_config.buffer_size) {
|
|
log_print("message size %d from %d too big, buf len %d",
|
|
msglen, nodeid, len);
|
|
break;
|
|
}
|
|
err = 0;
|
|
|
|
/* If only part of the full message is contained in this
|
|
buffer, then do nothing and wait for lowcomms to call
|
|
us again later with more data. We return 0 meaning
|
|
we've consumed none of the input buffer. */
|
|
|
|
if (msglen > len)
|
|
break;
|
|
|
|
/* Allocate a larger temp buffer if the full message won't fit
|
|
in the buffer on the stack (which should work for most
|
|
ordinary messages). */
|
|
|
|
if (msglen > sizeof(__tmp) &&
|
|
msg == (struct dlm_header *) __tmp) {
|
|
msg = kmalloc(dlm_config.buffer_size, GFP_KERNEL);
|
|
if (msg == NULL)
|
|
return ret;
|
|
}
|
|
|
|
copy_from_cb(msg, base, offset, msglen, limit);
|
|
|
|
BUG_ON(lockspace != msg->h_lockspace);
|
|
|
|
ret += msglen;
|
|
offset += msglen;
|
|
offset &= (limit - 1);
|
|
len -= msglen;
|
|
|
|
switch (msg->h_cmd) {
|
|
case DLM_MSG:
|
|
dlm_receive_message(msg, nodeid, FALSE);
|
|
break;
|
|
|
|
case DLM_RCOM:
|
|
dlm_receive_rcom(msg, nodeid);
|
|
break;
|
|
|
|
default:
|
|
log_print("unknown msg type %x from %u: %u %u %u %u",
|
|
msg->h_cmd, nodeid, msglen, len, offset, ret);
|
|
}
|
|
}
|
|
|
|
if (msg != (struct dlm_header *) __tmp)
|
|
kfree(msg);
|
|
|
|
return err ? err : ret;
|
|
}
|
|
|