[net-next-2.6.git] / fs / dlm / midcomms.c

/******************************************************************************
*******************************************************************************
**
**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
**  Copyright (C) 2004-2008 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 "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)
{
	union {
		unsigned char __buf[DLM_INBUF_LEN];
		/* this is to force proper alignment on some arches */
		union dlm_packet p;
	} __tmp;
	union dlm_packet *p = &__tmp.p;
	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(p, base, offset, sizeof(struct dlm_header),
			     limit);

		msglen = le16_to_cpu(p->header.h_length);
		lockspace = p->header.h_lockspace;

		err = -EINVAL;
		if (msglen < sizeof(struct dlm_header))
			break;
		if (p->header.h_cmd == DLM_MSG) {
			if (msglen < sizeof(struct dlm_message))
				break;
		} else {
			if (msglen < sizeof(struct dlm_rcom))
				break;
		}
		err = -E2BIG;
		if (msglen > dlm_config.ci_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) && p == &__tmp.p) {
			p = kmalloc(dlm_config.ci_buffer_size, GFP_NOFS);
			if (p == NULL)
				return ret;
		}

		copy_from_cb(p, base, offset, msglen, limit);

		BUG_ON(lockspace != p->header.h_lockspace);

		ret += msglen;
		offset += msglen;
		offset &= (limit - 1);
		len -= msglen;

		dlm_receive_buffer(p, nodeid);
	}

	if (p != &__tmp.p)
		kfree(p);

	return err ? err : ret;
}
Commit	Line	Data
e7fd4179 DT	1	/******************************************************************************
	2	*******************************************************************************
	3	**
	4	** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved.
e7847d35	5	** Copyright (C) 2004-2008 Red Hat, Inc. All rights reserved.
e7fd4179 DT	6	**
	7	** This copyrighted material is made available to anyone wishing to use,
	8	** modify, copy, or redistribute it subject to the terms and conditions
	9	** of the GNU General Public License v.2.
	10	**
	11	*******************************************************************************
	12	******************************************************************************/
	13
	14	/*
	15	* midcomms.c
	16	*
	17	* This is the appallingly named "mid-level" comms layer.
	18	*
	19	* Its purpose is to take packets from the "real" comms layer,
	20	* split them up into packets and pass them to the interested
	21	* part of the locking mechanism.
	22	*
	23	* It also takes messages from the locking layer, formats them
	24	* into packets and sends them to the comms layer.
	25	*/
	26
	27	#include "dlm_internal.h"
	28	#include "lowcomms.h"
	29	#include "config.h"
e7fd4179 DT	30	#include "lock.h"
	31	#include "midcomms.h"
	32
	33
	34	static void copy_from_cb(void dst, const void base, unsigned offset,
	35	unsigned len, unsigned limit)
	36	{
	37	unsigned copy = len;
	38
	39	if ((copy + offset) > limit)
	40	copy = limit - offset;
	41	memcpy(dst, base + offset, copy);
	42	len -= copy;
	43	if (len)
	44	memcpy(dst + copy, base, len);
	45	}
	46
	47	/*
	48	* Called from the low-level comms layer to process a buffer of
	49	* commands.
	50	*
	51	* Only complete messages are processed here, any "spare" bytes from
	52	* the end of a buffer are saved and tacked onto the front of the next
	53	* message that comes in. I doubt this will happen very often but we
	54	* need to be able to cope with it and I don't want the task to be waiting
	55	* for packets to come in when there is useful work to be done.
	56	*/
	57
	58	int dlm_process_incoming_buffer(int nodeid, const void *base,
	59	unsigned offset, unsigned len, unsigned limit)
	60	{
e7847d35 FDN	61	union {
	62	unsigned char __buf[DLM_INBUF_LEN];
	63	/* this is to force proper alignment on some arches */
eef7d739	64	union dlm_packet p;
e7847d35	65	} __tmp;
eef7d739	66	union dlm_packet *p = &__tmp.p;
e7fd4179 DT	67	int ret = 0;
	68	int err = 0;
	69	uint16_t msglen;
	70	uint32_t lockspace;
	71
	72	while (len > sizeof(struct dlm_header)) {
	73
	74	/* Copy just the header to check the total length. The
	75	message may wrap around the end of the buffer back to the
	76	start, so we need to use a temp buffer and copy_from_cb. */
	77
eef7d739	78	copy_from_cb(p, base, offset, sizeof(struct dlm_header),
e7fd4179 DT	79	limit);
e7fd4179 DT	80
eef7d739 AV	81	msglen = le16_to_cpu(p->header.h_length);
eef7d739 AV	82	lockspace = p->header.h_lockspace;
e7fd4179 DT	83
	84	err = -EINVAL;
	85	if (msglen < sizeof(struct dlm_header))
	86	break;
eef7d739 AV	87	if (p->header.h_cmd == DLM_MSG) {
	88	if (msglen < sizeof(struct dlm_message))
	89	break;
	90	} else {
	91	if (msglen < sizeof(struct dlm_rcom))
	92	break;
	93	}
e7fd4179	94	err = -E2BIG;
68c817a1	95	if (msglen > dlm_config.ci_buffer_size) {
e7fd4179 DT	96	log_print("message size %d from %d too big, buf len %d",
	97	msglen, nodeid, len);
	98	break;
	99	}
	100	err = 0;
	101
	102	/* If only part of the full message is contained in this
	103	buffer, then do nothing and wait for lowcomms to call
	104	us again later with more data. We return 0 meaning
	105	we've consumed none of the input buffer. */
	106
	107	if (msglen > len)
	108	break;
	109
	110	/* Allocate a larger temp buffer if the full message won't fit
	111	in the buffer on the stack (which should work for most
	112	ordinary messages). */
	113
eef7d739	114	if (msglen > sizeof(__tmp) && p == &__tmp.p) {
d6d7b702	115	p = kmalloc(dlm_config.ci_buffer_size, GFP_NOFS);
eef7d739	116	if (p == NULL)
e7fd4179 DT	117	return ret;
	118	}
	119
eef7d739	120	copy_from_cb(p, base, offset, msglen, limit);
e7fd4179	121
eef7d739	122	BUG_ON(lockspace != p->header.h_lockspace);
e7fd4179 DT	123
	124	ret += msglen;
	125	offset += msglen;
	126	offset &= (limit - 1);
	127	len -= msglen;
	128
eef7d739	129	dlm_receive_buffer(p, nodeid);
e7fd4179 DT	130	}
e7fd4179 DT	131
eef7d739 AV	132	if (p != &__tmp.p)
eef7d739 AV	133	kfree(p);
e7fd4179 DT	134
	135	return err ? err : ret;
	136	}
	137