lustre/ptlrpc/pack_generic.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  Copyright (C) 2001 Cluster File Systems, Inc. <braam@clusterfs.com>
   5  *
   6  *   This file is part of Lustre, http://www.lustre.org.
   7  *
   8  *   Lustre is free software; you can redistribute it and/or
   9  *   modify it under the terms of version 2 of the GNU General Public
  10  *   License as published by the Free Software Foundation.
  11  *
  12  *   Lustre is distributed in the hope that it will be useful,
  13  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  *   GNU General Public License for more details.
  16  *
  17  *   You should have received a copy of the GNU General Public License
  18  *   along with Lustre; if not, write to the Free Software
  19  *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20  *
  21  * (Un)packing of OST requests
  22  *
  23  */
  24
  25 #define EXPORT_SYMTAB
  26
  27 #define DEBUG_SUBSYSTEM S_CLASS
  28
  29 #include <linux/lustre_net.h>
  30
  31 int lustre_pack_msg(int count, int *lens, char **bufs, int *len,
  32                     struct lustre_msg **msg)
  33 {
  34         char *ptr;
  35         struct lustre_msg *m;
  36         int size = 0, i;
  37
  38         for (i = 0; i < count; i++)
  39                 size += size_round(lens[i]);
  40
  41         *len = sizeof(*m) + count * sizeof(__u32) + size;
  42
  43         OBD_ALLOC(*msg, *len);
  44         if (!*msg)
  45                 RETURN(-ENOMEM);
  46
  47         m = *msg;
  48         m->bufcount = HTON__u32(count);
  49         for (i = 0; i < count; i++)
  50                 m->buflens[i] = HTON__u32(lens[i]);
  51
  52         ptr = (char *)m + sizeof(*m) + sizeof(__u32) * count;
  53         for (i = 0; i < count; i++) {
  54                 char *tmp = NULL;
  55                 if (bufs)
  56                         tmp = bufs[i];
  57                 LOGL(tmp, lens[i], ptr);
  58         }
  59
  60         return 0;
  61 }
  62
  63 /* This returns the size of the buffer that is required to hold a lustre_msg
  64  * with the given sub-buffer lengths. */
  65 int lustre_msg_size(int count, int *lengths)
  66 {
  67         int size = sizeof(struct lustre_msg), i;
  68
  69         for (i = 0; i < count; i++)
  70                 size += size_round(lengths[i]);
  71
  72         size += count * sizeof(__u32);
  73
  74         return size;
  75 }
  76
  77 int lustre_unpack_msg(struct lustre_msg *m, int len)
  78 {
  79         int required_len, i;
  80
  81         required_len = sizeof(*m);
  82         if (len < required_len)
  83                 RETURN(-EINVAL);
  84
  85         m->opc = NTOH__u32(m->opc);
  86         m->xid = NTOH__u32(m->xid);
  87         m->status = NTOH__u32(m->status);
  88         m->type = NTOH__u32(m->type);
  89         m->connid = NTOH__u32(m->connid);
  90         m->bufcount = NTOH__u32(m->bufcount);
  91         m->last_rcvd = NTOH__u64(m->last_rcvd);
  92         m->last_committed = NTOH__u64(m->last_committed);
  93
  94         required_len += m->bufcount * sizeof(__u32);
  95         if (len < required_len)
  96                 RETURN(-EINVAL);
  97
  98         for (i = 0; i < m->bufcount; i++) {
  99                 m->buflens[i] = NTOH__u32(m->buflens[i]);
 100                 required_len += size_round(m->buflens[i]);
 101         }
 102
 103         if (len < required_len) {
 104                 CERROR("len: %d, required_len %d\n", len, required_len);
 105                 RETURN(-EINVAL);
 106         }
 107
 108         RETURN(0);
 109 }
 110
 111 void *lustre_msg_buf(struct lustre_msg *m, int n)
 112 {
 113         int i, offset;
 114
 115         if (n < 0 || n >= m->bufcount) {
 116                 CERROR("referencing bad sub buffer!\n");
 117                 LBUG();
 118                 return NULL;
 119         }
 120
 121         if (m->buflens[n] == 0)
 122                 return NULL;
 123
 124         offset = sizeof(*m) + m->bufcount * sizeof(__u32);
 125
 126         for (i = 0; i < n; i++)
 127                 offset += size_round(m->buflens[i]);
 128
 129         return (char *)m + offset;
 130 }