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 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 { 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