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_free(struct dev_map *dev_map)
  75 {
  76         if (!dev_map)
  77                 return;
  78
  79         free(dev_map->dev_name);
  80         free(dev_map);
  81 }
  82
  83 static void dev_map_cleanup(struct rd *rd)
  84 {
  85         struct dev_map *dev_map, *tmp;
  86
  87         list_for_each_entry_safe(dev_map, tmp,
  88                                  &rd->dev_map_list, list) {
  89                 list_del(&dev_map->list);
  90                 dev_map_free(dev_map);
  91         }
  92 }
  93
  94 static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
  95         [RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32,
  96         [RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
  97         [RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32,
  98         [RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64,
  99         [RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING,
 100         [RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64,
 101         [RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64,
 102         [RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32,
 103         [RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32,
 104         [RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8,
 105         [RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8,
 106         [RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8,
 107         [RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8,
 108 };
 109
 110 int rd_attr_cb(const struct nlattr *attr, void *data)
 111 {
 112         const struct nlattr **tb = data;
 113         int type;
 114
 115         if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0)
 116                 return MNL_CB_ERROR;
 117
 118         type = mnl_attr_get_type(attr);
 119
 120         if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
 121                 return MNL_CB_ERROR;
 122
 123         tb[type] = attr;
 124         return MNL_CB_OK;
 125 }
 126
 127 int rd_dev_init_cb(const struct nlmsghdr *nlh, void *data)
 128 {
 129         struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
 130         struct dev_map *dev_map;
 131         struct rd *rd = data;
 132         const char *dev_name;
 133
 134         mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
 135         if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
 136                 return MNL_CB_ERROR;
 137         if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
 138                 pr_err("This tool doesn't support switches yet\n");
 139                 return MNL_CB_ERROR;
 140         }
 141
 142         dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
 143
 144         dev_map = dev_map_alloc(dev_name);
 145         if (!dev_map)
 146                 /* The main function will cleanup the allocations */
 147                 return MNL_CB_ERROR;
 148         list_add_tail(&dev_map->list, &rd->dev_map_list);
 149
 150         dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
 151         dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
 152         return MNL_CB_OK;
 153 }
 154
 155 void rd_free_devmap(struct rd *rd)
 156 {
 157         if (!rd)
 158                 return;
 159         dev_map_cleanup(rd);
 160 }
 161
 162 int rd_exec_dev(struct rd *rd, int (*cb)(struct rd *rd))
 163 {
 164         struct dev_map *dev_map;
 165         int ret = 0;
 166
 167         if (rd->json_output)
 168                 jsonw_start_array(rd->jw);
 169         if (rd_no_arg(rd)) {
 170                 list_for_each_entry(dev_map, &rd->dev_map_list, list) {
 171                         rd->dev_idx = dev_map->idx;
 172                         ret = cb(rd);
 173                         if (ret)
 174                                 goto out;
 175                 }
 176         } else {
 177                 dev_map = dev_map_lookup(rd, false);
 178                 if (!dev_map) {
 179                         pr_err("Wrong device name\n");
 180                         ret = -ENOENT;
 181                         goto out;
 182                 }
 183                 rd_arg_inc(rd);
 184                 rd->dev_idx = dev_map->idx;
 185                 ret = cb(rd);
 186         }
 187 out:
 188         if (rd->json_output)
 189                 jsonw_end_array(rd->jw);
 190         return ret;
 191 }
 192
 193 int rd_exec_cmd(struct rd *rd, const struct rd_cmd *cmds, const char *str)
 194 {
 195         const struct rd_cmd *c;
 196
 197         /* First argument in objs table is default variant */
 198         if (rd_no_arg(rd))
 199                 return cmds->func(rd);
 200
 201         for (c = cmds + 1; c->cmd; ++c) {
 202                 if (rd_argv_match(rd, c->cmd)) {
 203                         /* Move to next argument */
 204                         rd_arg_inc(rd);
 205                         return c->func(rd);
 206                 }
 207         }
 208
 209         pr_err("Unknown %s '%s'.\n", str, rd_argv(rd));
 210         return 0;
 211 }
 212
 213 void rd_prepare_msg(struct rd *rd, uint32_t cmd, uint32_t *seq, uint16_t flags)
 214 {
 215         *seq = time(NULL);
 216
 217         rd->nlh = mnl_nlmsg_put_header(rd->buff);
 218         rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd);
 219         rd->nlh->nlmsg_seq = *seq;
 220         rd->nlh->nlmsg_flags = flags;
 221 }
 222
 223 int rd_send_msg(struct rd *rd)
 224 {
 225         int ret;
 226
 227         rd->nl = mnl_socket_open(NETLINK_RDMA);
 228         if (!rd->nl) {
 229                 pr_err("Failed to open NETLINK_RDMA socket\n");
 230                 return -ENODEV;
 231         }
 232
 233         ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID);
 234         if (ret < 0) {
 235                 pr_err("Failed to bind socket with err %d\n", ret);
 236                 goto err;
 237         }
 238
 239         ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len);
 240         if (ret < 0) {
 241                 pr_err("Failed to send to socket with err %d\n", ret);
 242                 goto err;
 243         }
 244         return 0;
 245
 246 err:
 247         mnl_socket_close(rd->nl);
 248         return ret;
 249 }
 250
 251 int rd_recv_msg(struct rd *rd, mnl_cb_t callback, void *data, unsigned int seq)
 252 {
 253         int ret;
 254         unsigned int portid;
 255         char buf[MNL_SOCKET_BUFFER_SIZE];
 256
 257         portid = mnl_socket_get_portid(rd->nl);
 258         do {
 259                 ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf));
 260                 if (ret <= 0)
 261                         break;
 262
 263                 ret = mnl_cb_run(buf, ret, seq, portid, callback, data);
 264         } while (ret > 0);
 265
 266         mnl_socket_close(rd->nl);
 267         return ret;
 268 }
 269
 270 static struct dev_map *_dev_map_lookup(struct rd *rd, const char *dev_name)
 271 {
 272         struct dev_map *dev_map;
 273
 274         list_for_each_entry(dev_map, &rd->dev_map_list, list)
 275                 if (strcmp(dev_name, dev_map->dev_name) == 0)
 276                         return dev_map;
 277
 278         return NULL;
 279 }
 280
 281 struct dev_map *dev_map_lookup(struct rd *rd, bool allow_port_index)
 282 {
 283         struct dev_map *dev_map;
 284         char *dev_name;
 285         char *slash;
 286
 287         if (rd_no_arg(rd))
 288                 return NULL;
 289
 290         dev_name = strdup(rd_argv(rd));
 291         if (allow_port_index) {
 292                 slash = strrchr(dev_name, '/');
 293                 if (slash)
 294                         *slash = '\0';
 295         }
 296
 297         dev_map = _dev_map_lookup(rd, dev_name);
 298         free(dev_name);
 299         return dev_map;
 300 }