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 struct dlm_header dlm; 65 } __tmp; 66 struct dlm_header *msg = &__tmp.dlm; 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(msg, base, offset, sizeof(struct dlm_header), 79 limit); 80 81 msglen = le16_to_cpu(msg->h_length); 82 lockspace = msg->h_lockspace; 83 84 err = -EINVAL; 85 if (msglen < sizeof(struct dlm_header)) 86 break; 87 err = -E2BIG; 88 if (msglen > dlm_config.ci_buffer_size) { 89 log_print("message size %d from %d too big, buf len %d", 90 msglen, nodeid, len); 91 break; 92 } 93 err = 0; 94 95 /* If only part of the full message is contained in this 96 buffer, then do nothing and wait for lowcomms to call 97 us again later with more data. We return 0 meaning 98 we've consumed none of the input buffer. */ 99 100 if (msglen > len) 101 break; 102 103 /* Allocate a larger temp buffer if the full message won't fit 104 in the buffer on the stack (which should work for most 105 ordinary messages). */ 106 107 if (msglen > DLM_INBUF_LEN && msg == &__tmp.dlm) { 108 msg = kmalloc(dlm_config.ci_buffer_size, GFP_KERNEL); 109 if (msg == NULL) 110 return ret; 111 } 112 113 copy_from_cb(msg, base, offset, msglen, limit); 114 115 BUG_ON(lockspace != msg->h_lockspace); 116 117 ret += msglen; 118 offset += msglen; 119 offset &= (limit - 1); 120 len -= msglen; 121 122 dlm_receive_buffer(msg, nodeid); 123 } 124 125 if (msg != &__tmp.dlm) 126 kfree(msg); 127 128 return err ? err : ret; 129 } 130 131