fs/dlm/midcomms.c

   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.ci_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.ci_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:
 122                         dlm_receive_message(msg, nodeid, 0);
 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