1/******************************************************************************
2*******************************************************************************
3**
4**  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
5**  Copyright (C) 2004-2005 Red Hat, Inc.  All rights reserved.
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"
30#include "rcom.h"
31#include "lock.h"
32#include "midcomms.h"
33
34
35static void copy_from_cb(void *dst, const void *base, unsigned offset,
36			 unsigned len, unsigned limit)
37{
38	unsigned copy = len;
39
40	if ((copy + offset) > limit)
41		copy = limit - offset;
42	memcpy(dst, base + offset, copy);
43	len -= copy;
44	if (len)
45		memcpy(dst + copy, base, len);
46}
47
48/*
49 * Called from the low-level comms layer to process a buffer of
50 * commands.
51 *
52 * Only complete messages are processed here, any "spare" bytes from
53 * the end of a buffer are saved and tacked onto the front of the next
54 * message that comes in. I doubt this will happen very often but we
55 * need to be able to cope with it and I don't want the task to be waiting
56 * for packets to come in when there is useful work to be done.
57 */
58
59int dlm_process_incoming_buffer(int nodeid, const void *base,
60				unsigned offset, unsigned len, unsigned limit)
61{
62	unsigned char __tmp[DLM_INBUF_LEN];
63	struct dlm_header *msg = (struct dlm_header *) __tmp;
64	int ret = 0;
65	int err = 0;
66	uint16_t msglen;
67	uint32_t lockspace;
68
69	while (len > sizeof(struct dlm_header)) {
70
71		/* Copy just the header to check the total length.  The
72		   message may wrap around the end of the buffer back to the
73		   start, so we need to use a temp buffer and copy_from_cb. */
74
75		copy_from_cb(msg, base, offset, sizeof(struct dlm_header),
76			     limit);
77
78		msglen = le16_to_cpu(msg->h_length);
79		lockspace = msg->h_lockspace;
80
81		err = -EINVAL;
82		if (msglen < sizeof(struct dlm_header))
83			break;
84		err = -E2BIG;
85		if (msglen > dlm_config.ci_buffer_size) {
86			log_print("message size %d from %d too big, buf len %d",
87				  msglen, nodeid, len);
88			break;
89		}
90		err = 0;
91
92		/* If only part of the full message is contained in this
93		   buffer, then do nothing and wait for lowcomms to call
94		   us again later with more data.  We return 0 meaning
95		   we've consumed none of the input buffer. */
96
97		if (msglen > len)
98			break;
99
100		/* Allocate a larger temp buffer if the full message won't fit
101		   in the buffer on the stack (which should work for most
102		   ordinary messages). */
103
104		if (msglen > sizeof(__tmp) &&
105		    msg == (struct dlm_header *) __tmp) {
106			msg = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL);
107			if (msg == NULL)
108				return ret;
109		}
110
111		copy_from_cb(msg, base, offset, msglen, limit);
112
113		BUG_ON(lockspace != msg->h_lockspace);
114
115		ret += msglen;
116		offset += msglen;
117		offset &= (limit - 1);
118		len -= msglen;
119
120		switch (msg->h_cmd) {
121		case DLM_MSG:
122			dlm_receive_message(msg, nodeid, 0);
123			break;
124
125		case DLM_RCOM:
126			dlm_receive_rcom(msg, nodeid);
127			break;
128
129		default:
130			log_print("unknown msg type %x from %u: %u %u %u %u",
131				  msg->h_cmd, nodeid, msglen, len, offset, ret);
132		}
133	}
134
135	if (msg != (struct dlm_header *) __tmp)
136		kfree(msg);
137
138	return err ? err : ret;
139}
140