]>
Commit | Line | Data |
---|---|---|
e7fd4179 DT |
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 | ||
35 | static 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 | ||
59 | int 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.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.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: | |
90135925 | 122 | dlm_receive_message(msg, nodeid, 0); |
e7fd4179 DT |
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 |