LXR linux/fs/dlm/midcomms.c

   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
 138