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