rdma/utils.c

   1 /*
   2  * utils.c      RDMA tool
   3  *
   4  *              This program is free software; you can redistribute it and/or
   5  *              modify it under the terms of the GNU General Public License
   6  *              as published by the Free Software Foundation; either version
   7  *              2 of the License, or (at your option) any later version.
   8  *
   9  * Authors:     Leon Romanovsky <leonro@mellanox.com>
  10  */
  11
  12 #include "rdma.h"
  13
  14 static int rd_argc(struct rd *rd)
  15 {
  16         return rd->argc;
  17 }
  18
  19 char *rd_argv(struct rd *rd)
  20 {
  21         if (!rd_argc(rd))
  22                 return NULL;
  23         return *rd->argv;
  24 }
  25
  26 static int strcmpx(const char *str1, const char *str2)
  27 {
  28         if (strlen(str1) > strlen(str2))
  29                 return -1;
  30         return strncmp(str1, str2, strlen(str1));
  31 }
  32
  33 static bool rd_argv_match(struct rd *rd, const char *pattern)
  34 {
  35         if (!rd_argc(rd))
  36                 return false;
  37         return strcmpx(rd_argv(rd), pattern) == 0;
  38 }
  39
  40 void rd_arg_inc(struct rd *rd)
  41 {
  42         if (!rd_argc(rd))
  43                 return;
  44         rd->argc--;
  45         rd->argv++;
  46 }
  47
  48 bool rd_no_arg(struct rd *rd)
  49 {
  50         return rd_argc(rd) == 0;
  51 }
  52
  53 uint32_t get_port_from_argv(struct rd *rd)
  54 {
  55         char *slash;
  56
  57         slash = strchr(rd_argv(rd), '/');
  58         /* if no port found, return 0 */
  59         return slash ? atoi(slash + 1) : 0;
  60 }
  61
  62 static struct dev_map *dev_map_alloc(const char *dev_name)
  63 {
  64         struct dev_map *dev_map;
  65
  66         dev_map = calloc(1, sizeof(*dev_map));
  67         if (!dev_map)
  68                 return NULL;
  69         dev_map->dev_name = strdup(dev_name);
  70
  71         return dev_map;
  72 }
  73
  74 static void dev_map_cleanup(struct rd *rd)
  75 {
  76         struct dev_map *dev_map, *tmp;
  77
  78         list_for_each_entry_safe(dev_map, tmp,
  79                                  &rd->dev_map_list, list) {
  80                 list_del(&dev_map->list);
  81                 free(dev_map->dev_name);
  82                 free(dev_map);
  83         }
  84 }
  85
  86 static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
  87         [RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32,
  88         [RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
  89         [RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32,
  90         [RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64,
  91         [RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING,
  92         [RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64,
  93         [RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64,
  94         [RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32,
  95         [RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32,
  96         [RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8,
  97         [RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8,
  98         [RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8,
  99         [RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8,
 100 };
 101
 102 int rd_attr_cb(const struct nlattr *attr, void *data)
 103 {
 104         const struct nlattr **tb = data;
 105         int type;
 106
 107         if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0)
 108                 return MNL_CB_ERROR;
 109
 110         type = mnl_attr_get_type(attr);
 111
 112         if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
 113                 return MNL_CB_ERROR;
 114
 115         tb[type] = attr;
 116         return MNL_CB_OK;
 117 }
 118
 119 int rd_dev_init_cb(const struct nlmsghdr *nlh, void *data)
 120 {
 121         struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
 122         struct dev_map *dev_map;
 123         struct rd *rd = data;
 124         const char *dev_name;
 125
 126         mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
 127         if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
 128                 return MNL_CB_ERROR;
 129         if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
 130                 pr_err("This tool doesn't support switches yet\n");
 131                 return MNL_CB_ERROR;
 132         }
 133
 134         dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
 135
 136         dev_map = dev_map_alloc(dev_name);
 137         if (!dev_map)
 138                 /* The main function will cleanup the allocations */
 139                 return MNL_CB_ERROR;
 140         list_add_tail(&dev_map->list, &rd->dev_map_list);
 141
 142         dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
 143         dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
 144         return MNL_CB_OK;
 145 }
 146
 147 void rd_free_devmap(struct rd *rd)
 148 {
 149         if (!rd)
 150                 return;
 151         dev_map_cleanup(rd);
 152 }
 153
 154 int rd_exec_dev(struct rd *rd, int (*cb)(struct rd *rd))
 155 {
 156         struct dev_map *dev_map;
 157         int ret = 0;
 158
 159         if (rd->json_output)
 160                 jsonw_start_array(rd->jw);
 161         if (rd_no_arg(rd)) {
 162                 list_for_each_entry(dev_map, &rd->dev_map_list, list) {
 163                         rd->dev_idx = dev_map->idx;
 164                         ret = cb(rd);
 165                         if (ret)
 166                                 goto out;
 167                 }
 168         } else {
 169                 dev_map = dev_map_lookup(rd, false);
 170                 if (!dev_map) {
 171                         pr_err("Wrong device name - %s\n", rd_argv(rd));
 172                         ret = -ENOENT;
 173                         goto out;
 174                 }
 175                 rd_arg_inc(rd);
 176                 rd->dev_idx = dev_map->idx;
 177                 ret = cb(rd);
 178         }
 179 out:
 180         if (rd->json_output)
 181                 jsonw_end_array(rd->jw);
 182         return ret;
 183 }
 184
 185 int rd_exec_cmd(struct rd *rd, const struct rd_cmd *cmds, const char *str)
 186 {
 187         const struct rd_cmd *c;
 188
 189         /* First argument in objs table is default variant */
 190         if (rd_no_arg(rd))
 191                 return cmds->func(rd);
 192
 193         for (c = cmds + 1; c->cmd; ++c) {
 194                 if (rd_argv_match(rd, c->cmd)) {
 195                         /* Move to next argument */
 196                         rd_arg_inc(rd);
 197                         return c->func(rd);
 198                 }
 199         }
 200
 201         pr_err("Unknown %s '%s'.\n", str, rd_argv(rd));
 202         return 0;
 203 }
 204
 205 void rd_prepare_msg(struct rd *rd, uint32_t cmd, uint32_t *seq, uint16_t flags)
 206 {
 207         *seq = time(NULL);
 208
 209         rd->nlh = mnl_nlmsg_put_header(rd->buff);
 210         rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd);
 211         rd->nlh->nlmsg_seq = *seq;
 212         rd->nlh->nlmsg_flags = flags;
 213 }
 214
 215 int rd_send_msg(struct rd *rd)
 216 {
 217         int ret;
 218
 219         rd->nl = mnl_socket_open(NETLINK_RDMA);
 220         if (!rd->nl) {
 221                 pr_err("Failed to open NETLINK_RDMA socket\n");
 222                 return -ENODEV;
 223         }
 224
 225         ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID);
 226         if (ret < 0) {
 227                 pr_err("Failed to bind socket with err %d\n", ret);
 228                 goto err;
 229         }
 230
 231         ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len);
 232         if (ret < 0) {
 233                 pr_err("Failed to send to socket with err %d\n", ret);
 234                 goto err;
 235         }
 236         return 0;
 237
 238 err:
 239         mnl_socket_close(rd->nl);
 240         return ret;
 241 }
 242
 243 int rd_recv_msg(struct rd *rd, mnl_cb_t callback, void *data, unsigned int seq)
 244 {
 245         int ret;
 246         unsigned int portid;
 247         char buf[MNL_SOCKET_BUFFER_SIZE];
 248
 249         portid = mnl_socket_get_portid(rd->nl);
 250         do {
 251                 ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf));
 252                 if (ret <= 0)
 253                         break;
 254
 255                 ret = mnl_cb_run(buf, ret, seq, portid, callback, data);
 256         } while (ret > 0);
 257
 258         mnl_socket_close(rd->nl);
 259         return ret;
 260 }
 261
 262 static struct dev_map *_dev_map_lookup(struct rd *rd, const char *dev_name)
 263 {
 264         struct dev_map *dev_map;
 265
 266         list_for_each_entry(dev_map, &rd->dev_map_list, list)
 267                 if (strcmp(dev_name, dev_map->dev_name) == 0)
 268                         return dev_map;
 269
 270         return NULL;
 271 }
 272
 273 struct dev_map *dev_map_lookup(struct rd *rd, bool allow_port_index)
 274 {
 275         struct dev_map *dev_map;
 276         char *dev_name;
 277         char *slash;
 278
 279         if (rd_no_arg(rd))
 280                 return NULL;
 281
 282         dev_name = strdup(rd_argv(rd));
 283         if (allow_port_index) {
 284                 slash = strrchr(dev_name, '/');
 285                 if (slash)
 286                         *slash = '\0';
 287         }
 288
 289         dev_map = _dev_map_lookup(rd, dev_name);
 290         free(dev_name);
 291         return dev_map;
 292 }