lustre/include/lustre_cfg.h

   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  */
  22
  23 #ifndef _LUSTRE_CFG_H
  24 #define _LUSTRE_CFG_H
  25
  26 /*
  27  * 1cf6
  28  * lcfG
  29  */
  30 #define LUSTRE_CFG_VERSION 0x1cf60001
  31 #define LUSTRE_CFG_MAX_BUFCOUNT 8
  32
  33 #define LCFG_HDR_SIZE(count) \
  34     size_round(offsetof (struct lustre_cfg, lcfg_buflens[(count)]))
  35
  36 /* If not LCFG_REQUIRED, we can ignore this cmd and go on. */
  37 #define LCFG_REQUIRED         0x0001000
  38
  39 enum lcfg_command_type {
  40         LCFG_ATTACH         = 0x00cf001,
  41         LCFG_DETACH         = 0x00cf002,
  42         LCFG_SETUP          = 0x00cf003,
  43         LCFG_CLEANUP        = 0x00cf004,
  44         LCFG_ADD_UUID       = 0x00cf005,
  45         LCFG_DEL_UUID       = 0x00cf006,
  46         LCFG_MOUNTOPT       = 0x00cf007,
  47         LCFG_DEL_MOUNTOPT   = 0x00cf008,
  48         LCFG_SET_TIMEOUT    = 0x00cf009,
  49         LCFG_SET_UPCALL     = 0x00cf00a,
  50         LCFG_ADD_CONN       = 0x00cf00b,
  51         LCFG_DEL_CONN       = 0x00cf00c,
  52         LCFG_LOV_ADD_OBD    = 0x00cf00d,
  53         LCFG_LOV_DEL_OBD    = 0x00cf00e,
  54         LCFG_PARAM          = 0x00cf00f,
  55         LCFG_MARKER         = 0x00cf010,
  56         LCFG_LOG_START      = 0x00ce011,
  57         LCFG_LOG_END        = 0x00ce012,
  58         LCFG_LOV_ADD_INA    = 0x00ce013,
  59 };
  60
  61 struct lustre_cfg_bufs {
  62         void    *lcfg_buf[LUSTRE_CFG_MAX_BUFCOUNT];
  63         uint32_t lcfg_buflen[LUSTRE_CFG_MAX_BUFCOUNT];
  64         uint32_t lcfg_bufcount;
  65 };
  66
  67 /* Mountconf transitional hack, should go away after 1.6 */
  68 #define LCFG_FLG_MOUNTCONF 0x400
  69
  70 struct lustre_cfg {
  71         uint32_t lcfg_version;
  72         uint32_t lcfg_command;
  73
  74         uint32_t lcfg_num;
  75         uint32_t lcfg_flags;
  76         uint64_t lcfg_nid;
  77         uint32_t lcfg_nal;                      /* not used any more */
  78
  79         uint32_t lcfg_bufcount;
  80         uint32_t lcfg_buflens[0];
  81 };
  82
  83 #define LUSTRE_CFG_BUFLEN(lcfg, idx)            \
  84         ((lcfg)->lcfg_bufcount <= (idx)         \
  85          ? 0                                    \
  86          : (lcfg)->lcfg_buflens[(idx)])
  87
  88 static inline void lustre_cfg_bufs_set(struct lustre_cfg_bufs *bufs,
  89                                        uint32_t                index,
  90                                        void                   *buf,
  91                                        uint32_t                buflen)
  92 {
  93         if (index >= LUSTRE_CFG_MAX_BUFCOUNT)
  94                 return;
  95         if (bufs == NULL)
  96                 return;
  97
  98         if (bufs->lcfg_bufcount <= index)
  99                 bufs->lcfg_bufcount = index + 1;
 100
 101         bufs->lcfg_buf[index]    = buf;
 102         bufs->lcfg_buflen[index] = buflen;
 103 }
 104
 105 static inline void lustre_cfg_bufs_set_string(struct lustre_cfg_bufs *bufs,
 106                                               uint32_t index,
 107                                               char *str)
 108 {
 109         lustre_cfg_bufs_set(bufs, index, str, str ? strlen(str) + 1 : 0);
 110 }
 111
 112 static inline void lustre_cfg_bufs_reset(struct lustre_cfg_bufs *bufs, char *name)
 113 {
 114         memset((bufs), 0, sizeof(*bufs));
 115         if (name)
 116                 lustre_cfg_bufs_set_string(bufs, 0, name);
 117 }
 118
 119 static inline void *lustre_cfg_buf(struct lustre_cfg *lcfg, int index)
 120 {
 121         int i;
 122         int offset;
 123         int bufcount;
 124         LASSERT (lcfg != NULL);
 125         LASSERT (index >= 0);
 126
 127         bufcount = lcfg->lcfg_bufcount;
 128         if (index >= bufcount)
 129                 return NULL;
 130
 131         offset = LCFG_HDR_SIZE(lcfg->lcfg_bufcount);
 132         for (i = 0; i < index; i++)
 133                 offset += size_round(lcfg->lcfg_buflens[i]);
 134         return (char *)lcfg + offset;
 135 }
 136
 137 static inline void lustre_cfg_bufs_init(struct lustre_cfg_bufs *bufs,
 138                                         struct lustre_cfg *lcfg)
 139 {
 140         int i;
 141         bufs->lcfg_bufcount = lcfg->lcfg_bufcount;
 142         for (i = 0; i < bufs->lcfg_bufcount; i++) {
 143                 bufs->lcfg_buflen[i] = lcfg->lcfg_buflens[i];
 144                 bufs->lcfg_buf[i] = lustre_cfg_buf(lcfg, i);
 145         }
 146 }
 147
 148 static inline char *lustre_cfg_string(struct lustre_cfg *lcfg, int index)
 149 {
 150         char *s;
 151
 152         if (!lcfg->lcfg_buflens[index])
 153                 return NULL;
 154
 155         s = lustre_cfg_buf(lcfg, index);
 156         if (!s)
 157                 return NULL;
 158
 159         /* make sure it's NULL terminated, even if this kills a char
 160          * of data.  Try to use the padding first though.
 161          */
 162         if (s[lcfg->lcfg_buflens[index] - 1] != '\0') {
 163                 int last = min((int)lcfg->lcfg_buflens[index],
 164                                size_round(lcfg->lcfg_buflens[index]) - 1);
 165                 char lost = s[last];
 166                 s[last] = '\0';
 167                 if (lost != '\0') {
 168                         CWARN("Truncated buf %d to '%s' (lost '%c'...)\n",
 169                               index, s, lost);
 170                 }
 171         }
 172         return s;
 173 }
 174
 175 static inline int lustre_cfg_len(uint32_t bufcount, uint32_t *buflens)
 176 {
 177         int i;
 178         int len;
 179         ENTRY;
 180
 181         len = LCFG_HDR_SIZE(bufcount);
 182         for (i = 0; i < bufcount; i++)
 183                 len += size_round(buflens[i]);
 184
 185         RETURN(size_round(len));
 186 }
 187
 188
 189 #include <obd_support.h>
 190
 191 static inline struct lustre_cfg *lustre_cfg_new(int cmd,
 192                                                 struct lustre_cfg_bufs *bufs)
 193 {
 194         struct lustre_cfg *lcfg;
 195         char *ptr;
 196         int i;
 197
 198         ENTRY;
 199
 200         OBD_ALLOC(lcfg, lustre_cfg_len(bufs->lcfg_bufcount,
 201                                        bufs->lcfg_buflen));
 202         if (!lcfg)
 203                 RETURN(lcfg);
 204
 205         lcfg->lcfg_version = LUSTRE_CFG_VERSION;
 206         lcfg->lcfg_command = cmd;
 207         lcfg->lcfg_bufcount = bufs->lcfg_bufcount;
 208
 209         ptr = (char *)lcfg + LCFG_HDR_SIZE(lcfg->lcfg_bufcount);
 210         for (i = 0; i < lcfg->lcfg_bufcount; i++) {
 211                 lcfg->lcfg_buflens[i] = bufs->lcfg_buflen[i];
 212                 LOGL((char *)bufs->lcfg_buf[i], bufs->lcfg_buflen[i], ptr);
 213         }
 214         RETURN(lcfg);
 215 }
 216
 217 static inline void lustre_cfg_free(struct lustre_cfg *lcfg)
 218 {
 219         int len;
 220
 221         len = lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens);
 222
 223         OBD_FREE(lcfg, len);
 224         EXIT;
 225         return;
 226 }
 227
 228 static inline int lustre_cfg_sanity_check(void *buf, int len)
 229 {
 230         struct lustre_cfg *lcfg = (struct lustre_cfg *)buf;
 231         ENTRY;
 232         if (!lcfg)
 233                 RETURN(-EINVAL);
 234
 235         /* check that the first bits of the struct are valid */
 236         if (len < LCFG_HDR_SIZE(0))
 237                 RETURN(-EINVAL);
 238
 239         if (lcfg->lcfg_version != LUSTRE_CFG_VERSION)
 240                 RETURN(-EINVAL);
 241
 242         if (lcfg->lcfg_bufcount >= LUSTRE_CFG_MAX_BUFCOUNT)
 243                 RETURN(-EINVAL);
 244
 245         /* check that the buflens are valid */
 246         if (len < LCFG_HDR_SIZE(lcfg->lcfg_bufcount))
 247                 RETURN(-EINVAL);
 248
 249         /* make sure all the pointers point inside the data */
 250         if (len < lustre_cfg_len(lcfg->lcfg_bufcount, lcfg->lcfg_buflens))
 251                 RETURN(-EINVAL);
 252
 253         RETURN(0);
 254 }
 255
 256 #endif // _LUSTRE_CFG_H