lustre/include/lustre_update.h

   1 /*
   2  * GPL HEADER START
   3  *
   4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License version 2 only,
   8  * as published by the Free Software Foundation.
   9  *
  10  * This program is distributed in the hope that it will be useful, but
  11  * WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * General Public License version 2 for more details (a copy is included
  14  * in the LICENSE file that accompanied this code).
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * version 2 along with this program; If not, see
  18  * http://www.gnu.org/licenses/gpl-2.0.htm
  19  *
  20  * GPL HEADER END
  21  */
  22 /*
  23  * Copyright (c) 2013, Intel Corporation.
  24  */
  25 /*
  26  * lustre/include/lustre_update.h
  27  *
  28  * Author: Di Wang <di.wang@intel.com>
  29  */
  30
  31 #ifndef _LUSTRE_UPDATE_H
  32 #define _LUSTRE_UPDATE_H
  33
  34 #define UPDATE_BUFFER_SIZE      4096
  35 struct update_request {
  36         struct dt_device        *ur_dt;
  37         cfs_list_t              ur_list;    /* attached itself to thandle */
  38         int                     ur_flags;
  39         int                     ur_rc;      /* request result */
  40         int                     ur_batchid; /* Current batch(trans) id */
  41         struct update_buf       *ur_buf;   /* Holding the update req */
  42 };
  43
  44 static inline unsigned long update_size(struct update *update)
  45 {
  46         unsigned long size;
  47         int        i;
  48
  49         size = cfs_size_round(offsetof(struct update, u_bufs[0]));
  50         for (i = 0; i < UPDATE_BUF_COUNT; i++)
  51                 size += cfs_size_round(update->u_lens[i]);
  52
  53         return size;
  54 }
  55
  56 static inline void *update_param_buf(struct update *update, int index,
  57                                      int *size)
  58 {
  59         int     i;
  60         void    *ptr;
  61
  62         if (index >= UPDATE_BUF_COUNT)
  63                 return NULL;
  64
  65         ptr = (char *)update + cfs_size_round(offsetof(struct update,
  66                                                        u_bufs[0]));
  67         for (i = 0; i < index; i++) {
  68                 LASSERT(update->u_lens[i] > 0);
  69                 ptr += cfs_size_round(update->u_lens[i]);
  70         }
  71
  72         if (size != NULL)
  73                 *size = update->u_lens[index];
  74
  75         return ptr;
  76 }
  77
  78 static inline unsigned long update_buf_size(struct update_buf *buf)
  79 {
  80         unsigned long size;
  81         int        i = 0;
  82
  83         size = cfs_size_round(offsetof(struct update_buf, ub_bufs[0]));
  84         for (i = 0; i < buf->ub_count; i++) {
  85                 struct update *update;
  86
  87                 update = (struct update *)((char *)buf + size);
  88                 size += update_size(update);
  89         }
  90         LASSERT(size <= UPDATE_BUFFER_SIZE);
  91         return size;
  92 }
  93
  94 static inline void *update_buf_get(struct update_buf *buf, int index, int *size)
  95 {
  96         int     count = buf->ub_count;
  97         void    *ptr;
  98         int     i = 0;
  99
 100         if (index >= count)
 101                 return NULL;
 102
 103         ptr = (char *)buf + cfs_size_round(offsetof(struct update_buf,
 104                                                     ub_bufs[0]));
 105         for (i = 0; i < index; i++)
 106                 ptr += update_size((struct update *)ptr);
 107
 108         if (size != NULL)
 109                 *size = update_size((struct update *)ptr);
 110
 111         return ptr;
 112 }
 113
 114 static inline void update_init_reply_buf(struct update_reply *reply, int count)
 115 {
 116         reply->ur_version = UPDATE_REPLY_V1;
 117         reply->ur_count = count;
 118 }
 119
 120 static inline void *update_get_buf_internal(struct update_reply *reply,
 121                                             int index, int *size)
 122 {
 123         char *ptr;
 124         int count = reply->ur_count;
 125         int i;
 126
 127         if (index >= count)
 128                 return NULL;
 129
 130         ptr = (char *)reply + cfs_size_round(offsetof(struct update_reply,
 131                                              ur_lens[count]));
 132         for (i = 0; i < index; i++) {
 133                 LASSERT(reply->ur_lens[i] > 0);
 134                 ptr += cfs_size_round(reply->ur_lens[i]);
 135         }
 136
 137         if (size != NULL)
 138                 *size = reply->ur_lens[index];
 139
 140         return ptr;
 141 }
 142
 143 static inline void update_insert_reply(struct update_reply *reply, void *data,
 144                                        int data_len, int index, int rc)
 145 {
 146         char *ptr;
 147
 148         ptr = update_get_buf_internal(reply, index, NULL);
 149         LASSERT(ptr != NULL);
 150
 151         *(int *)ptr = cpu_to_le32(rc);
 152         ptr += sizeof(int);
 153         if (data_len > 0) {
 154                 LASSERT(data != NULL);
 155                 memcpy(ptr, data, data_len);
 156         }
 157         reply->ur_lens[index] = data_len + sizeof(int);
 158 }
 159
 160 static inline int update_get_reply_buf(struct update_reply *reply, void **buf,
 161                                        int index)
 162 {
 163         char *ptr;
 164         int  size = 0;
 165         int  result;
 166
 167         ptr = update_get_buf_internal(reply, index, &size);
 168         result = *(int *)ptr;
 169
 170         if (result < 0)
 171                 return result;
 172
 173         LASSERT((ptr != NULL && size >= sizeof(int)));
 174         *buf = ptr + sizeof(int);
 175         return size - sizeof(int);
 176 }
 177
 178 static inline int update_get_reply_result(struct update_reply *reply,
 179                                           void **buf, int index)
 180 {
 181         void *ptr;
 182         int  size;
 183
 184         ptr = update_get_buf_internal(reply, index, &size);
 185         LASSERT(ptr != NULL && size > sizeof(int));
 186         return *(int *)ptr;
 187 }
 188
 189 #endif
 190
 191