1 /******************************************************************************
2 *******************************************************************************
3 **
4 **  Copyright (C) Sistina Software, Inc.  1997-2003  All rights reserved.
5 **  Copyright (C) 2004-2008 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 "lock.h"
31 #include "midcomms.h"
32 
33 
copy_from_cb(void * dst,const void * base,unsigned offset,unsigned len,unsigned limit)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 
dlm_process_incoming_buffer(int nodeid,const void * base,unsigned offset,unsigned len,unsigned limit)58 int dlm_process_incoming_buffer(int nodeid, const void *base,
59 				unsigned offset, unsigned len, unsigned limit)
60 {
61 	union {
62 		unsigned char __buf[DLM_INBUF_LEN];
63 		/* this is to force proper alignment on some arches */
64 		union dlm_packet p;
65 	} __tmp;
66 	union dlm_packet *p = &__tmp.p;
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 
78 		copy_from_cb(p, base, offset, sizeof(struct dlm_header),
79 			     limit);
80 
81 		msglen = le16_to_cpu(p->header.h_length);
82 		lockspace = p->header.h_lockspace;
83 
84 		err = -EINVAL;
85 		if (msglen < sizeof(struct dlm_header))
86 			break;
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 		}
94 		err = -E2BIG;
95 		if (msglen > dlm_config.ci_buffer_size) {
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 
114 		if (msglen > sizeof(__tmp) && p == &__tmp.p) {
115 			p = kmalloc(dlm_config.ci_buffer_size, GFP_NOFS);
116 			if (p == NULL)
117 				return ret;
118 		}
119 
120 		copy_from_cb(p, base, offset, msglen, limit);
121 
122 		BUG_ON(lockspace != p->header.h_lockspace);
123 
124 		ret += msglen;
125 		offset += msglen;
126 		offset &= (limit - 1);
127 		len -= msglen;
128 
129 		dlm_receive_buffer(p, nodeid);
130 	}
131 
132 	if (p != &__tmp.p)
133 		kfree(p);
134 
135 	return err ? err : ret;
136 }
137 
138