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 #include <ctype.h>
  14
  15 int rd_argc(struct rd *rd)
  16 {
  17         return rd->argc;
  18 }
  19
  20 char *rd_argv(struct rd *rd)
  21 {
  22         if (!rd_argc(rd))
  23                 return NULL;
  24         return *rd->argv;
  25 }
  26
  27 int strcmpx(const char *str1, const char *str2)
  28 {
  29         if (strlen(str1) > strlen(str2))
  30                 return -1;
  31         return strncmp(str1, str2, strlen(str1));
  32 }
  33
  34 static bool rd_argv_match(struct rd *rd, const char *pattern)
  35 {
  36         if (!rd_argc(rd))
  37                 return false;
  38         return strcmpx(rd_argv(rd), pattern) == 0;
  39 }
  40
  41 void rd_arg_inc(struct rd *rd)
  42 {
  43         if (!rd_argc(rd))
  44                 return;
  45         rd->argc--;
  46         rd->argv++;
  47 }
  48
  49 bool rd_no_arg(struct rd *rd)
  50 {
  51         return rd_argc(rd) == 0;
  52 }
  53
  54 /*
  55  * Possible input:output
  56  * dev/port    | first port | is_dump_all
  57  * mlx5_1      | 0          | true
  58  * mlx5_1/     | 0          | true
  59  * mlx5_1/0    | 0          | false
  60  * mlx5_1/1    | 1          | false
  61  * mlx5_1/-    | 0          | false
  62  *
  63  * In strict mode, /- will return error.
  64  */
  65 static int get_port_from_argv(struct rd *rd, uint32_t *port,
  66                               bool *is_dump_all, bool strict_port)
  67 {
  68         char *slash;
  69
  70         *port = 0;
  71         *is_dump_all = true;
  72
  73         slash = strchr(rd_argv(rd), '/');
  74         /* if no port found, return 0 */
  75         if (slash++) {
  76                 if (*slash == '-') {
  77                         if (strict_port)
  78                                 return -EINVAL;
  79                         *is_dump_all = false;
  80                         return 0;
  81                 }
  82
  83                 if (isdigit(*slash)) {
  84                         *is_dump_all = false;
  85                         *port = atoi(slash);
  86                 }
  87                 if (!*port && strlen(slash))
  88                         return -EINVAL;
  89         }
  90         return 0;
  91 }
  92
  93 static struct dev_map *dev_map_alloc(const char *dev_name)
  94 {
  95         struct dev_map *dev_map;
  96
  97         dev_map = calloc(1, sizeof(*dev_map));
  98         if (!dev_map)
  99                 return NULL;
 100         dev_map->dev_name = strdup(dev_name);
 101         if (!dev_map->dev_name) {
 102                 free(dev_map);
 103                 return NULL;
 104         }
 105
 106         return dev_map;
 107 }
 108
 109 static void dev_map_cleanup(struct rd *rd)
 110 {
 111         struct dev_map *dev_map, *tmp;
 112
 113         list_for_each_entry_safe(dev_map, tmp,
 114                                  &rd->dev_map_list, list) {
 115                 list_del(&dev_map->list);
 116                 free(dev_map->dev_name);
 117                 free(dev_map);
 118         }
 119 }
 120
 121 static int add_filter(struct rd *rd, char *key, char *value,
 122                       const struct filters valid_filters[])
 123 {
 124         char cset[] = "1234567890,-";
 125         struct filter_entry *fe;
 126         bool key_found = false;
 127         int idx = 0;
 128         int ret;
 129
 130         fe = calloc(1, sizeof(*fe));
 131         if (!fe)
 132                 return -ENOMEM;
 133
 134         while (idx < MAX_NUMBER_OF_FILTERS && valid_filters[idx].name) {
 135                 if (!strcmpx(key, valid_filters[idx].name)) {
 136                         key_found = true;
 137                         break;
 138                 }
 139                 idx++;
 140         }
 141         if (!key_found) {
 142                 pr_err("Unsupported filter option: %s\n", key);
 143                 ret = -EINVAL;
 144                 goto err;
 145         }
 146
 147         /*
 148          * Check the filter validity, not optimal, but works
 149          *
 150          * Actually, there are three types of filters
 151          *  numeric - for example PID or QPN
 152          *  string  - for example states
 153          *  link    - user requested to filter on specific link
 154          *            e.g. mlx5_1/1, mlx5_1/-, mlx5_1 ...
 155          */
 156         if (valid_filters[idx].is_number &&
 157             strspn(value, cset) != strlen(value)) {
 158                 pr_err("%s filter accepts \"%s\" characters only\n", key, cset);
 159                 ret = -EINVAL;
 160                 goto err;
 161         }
 162
 163         fe->key = strdup(key);
 164         fe->value = strdup(value);
 165         if (!fe->key || !fe->value) {
 166                 ret = -ENOMEM;
 167                 goto err_alloc;
 168         }
 169
 170         for (idx = 0; idx < strlen(fe->value); idx++)
 171                 fe->value[idx] = tolower(fe->value[idx]);
 172
 173         list_add_tail(&fe->list, &rd->filter_list);
 174         return 0;
 175
 176 err_alloc:
 177         free(fe->value);
 178         free(fe->key);
 179 err:
 180         free(fe);
 181         return ret;
 182 }
 183
 184 int rd_build_filter(struct rd *rd, const struct filters valid_filters[])
 185 {
 186         int ret = 0;
 187         int idx = 0;
 188
 189         if (!valid_filters || !rd_argc(rd))
 190                 goto out;
 191
 192         if (rd_argc(rd) == 1) {
 193                 pr_err("No filter data was supplied to filter option %s\n", rd_argv(rd));
 194                 ret = -EINVAL;
 195                 goto out;
 196         }
 197
 198         if (rd_argc(rd) % 2) {
 199                 pr_err("There is filter option without data\n");
 200                 ret = -EINVAL;
 201                 goto out;
 202         }
 203
 204         while (idx != rd_argc(rd)) {
 205                 /*
 206                  * We can do micro-optimization and skip "dev"
 207                  * and "link" filters, but it is not worth of it.
 208                  */
 209                 ret = add_filter(rd, *(rd->argv + idx),
 210                                  *(rd->argv + idx + 1), valid_filters);
 211                 if (ret)
 212                         goto out;
 213                 idx += 2;
 214         }
 215
 216 out:
 217         return ret;
 218 }
 219
 220 bool rd_check_is_key_exist(struct rd *rd, const char *key)
 221 {
 222         struct filter_entry *fe;
 223
 224         list_for_each_entry(fe, &rd->filter_list, list) {
 225                 if (!strcmpx(fe->key, key))
 226                         return true;
 227         }
 228
 229         return false;
 230 }
 231
 232 /*
 233  * Check if string entry is filtered:
 234  *  * key doesn't exist -> user didn't request -> not filtered
 235  */
 236 bool rd_check_is_string_filtered(struct rd *rd,
 237                                  const char *key, const char *val)
 238 {
 239         bool key_is_filtered = false;
 240         struct filter_entry *fe;
 241         char *p = NULL;
 242         char *str;
 243
 244         list_for_each_entry(fe, &rd->filter_list, list) {
 245                 if (!strcmpx(fe->key, key)) {
 246                         /* We found the key */
 247                         p = strdup(fe->value);
 248                         key_is_filtered = true;
 249                         if (!p) {
 250                                 /*
 251                                  * Something extremely wrong if we fail
 252                                  * to allocate small amount of bytes.
 253                                  */
 254                                 pr_err("Found key, but failed to allocate memory to store value\n");
 255                                 return key_is_filtered;
 256                         }
 257
 258                         /*
 259                          * Need to check if value in range
 260                          * It can come in the following formats
 261                          * and their permutations:
 262                          * str
 263                          * str1,str2
 264                          */
 265                         str = strtok(p, ",");
 266                         while (str) {
 267                                 if (strlen(str) == strlen(val) &&
 268                                     !strcasecmp(str, val)) {
 269                                         key_is_filtered = false;
 270                                         goto out;
 271                                 }
 272                                 str = strtok(NULL, ",");
 273                         }
 274                         goto out;
 275                 }
 276         }
 277
 278 out:
 279         free(p);
 280         return key_is_filtered;
 281 }
 282
 283 /*
 284  * Check if key is filtered:
 285  * key doesn't exist -> user didn't request -> not filtered
 286  */
 287 bool rd_check_is_filtered(struct rd *rd, const char *key, uint32_t val)
 288 {
 289         bool key_is_filtered = false;
 290         struct filter_entry *fe;
 291
 292         list_for_each_entry(fe, &rd->filter_list, list) {
 293                 uint32_t left_val = 0, fe_value = 0;
 294                 bool range_check = false;
 295                 char *p = fe->value;
 296
 297                 if (!strcmpx(fe->key, key)) {
 298                         /* We found the key */
 299                         key_is_filtered = true;
 300                         /*
 301                          * Need to check if value in range
 302                          * It can come in the following formats
 303                          * (and their permutations):
 304                          * numb
 305                          * numb1,numb2
 306                          * ,numb1,numb2
 307                          * numb1-numb2
 308                          * numb1,numb2-numb3,numb4-numb5
 309                          */
 310                         while (*p) {
 311                                 if (isdigit(*p)) {
 312                                         fe_value = strtol(p, &p, 10);
 313                                         if (fe_value == val ||
 314                                             (range_check && left_val < val &&
 315                                              val < fe_value)) {
 316                                                 key_is_filtered = false;
 317                                                 goto out;
 318                                         }
 319                                         range_check = false;
 320                                 } else {
 321                                         if (*p == '-') {
 322                                                 left_val = fe_value;
 323                                                 range_check = true;
 324                                         }
 325                                         p++;
 326                                 }
 327                         }
 328                         goto out;
 329                 }
 330         }
 331
 332 out:
 333         return key_is_filtered;
 334 }
 335
 336 static void filters_cleanup(struct rd *rd)
 337 {
 338         struct filter_entry *fe, *tmp;
 339
 340         list_for_each_entry_safe(fe, tmp,
 341                                  &rd->filter_list, list) {
 342                 list_del(&fe->list);
 343                 free(fe->key);
 344                 free(fe->value);
 345                 free(fe);
 346         }
 347 }
 348
 349 static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = {
 350         [RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32,
 351         [RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING,
 352         [RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32,
 353         [RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64,
 354         [RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING,
 355         [RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64,
 356         [RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64,
 357         [RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32,
 358         [RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32,
 359         [RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8,
 360         [RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8,
 361         [RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8,
 362         [RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8,
 363         [RDMA_NLDEV_ATTR_RES_SUMMARY]   = MNL_TYPE_NESTED,
 364         [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY]     = MNL_TYPE_NESTED,
 365         [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME] = MNL_TYPE_NUL_STRING,
 366         [RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR] = MNL_TYPE_U64,
 367         [RDMA_NLDEV_ATTR_RES_QP]                = MNL_TYPE_NESTED,
 368         [RDMA_NLDEV_ATTR_RES_QP_ENTRY]          = MNL_TYPE_NESTED,
 369         [RDMA_NLDEV_ATTR_RES_LQPN]      = MNL_TYPE_U32,
 370         [RDMA_NLDEV_ATTR_RES_RQPN]      = MNL_TYPE_U32,
 371         [RDMA_NLDEV_ATTR_RES_RQ_PSN]            = MNL_TYPE_U32,
 372         [RDMA_NLDEV_ATTR_RES_SQ_PSN]            = MNL_TYPE_U32,
 373         [RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]    = MNL_TYPE_U8,
 374         [RDMA_NLDEV_ATTR_RES_TYPE]              = MNL_TYPE_U8,
 375         [RDMA_NLDEV_ATTR_RES_STATE]             = MNL_TYPE_U8,
 376         [RDMA_NLDEV_ATTR_RES_PID]               = MNL_TYPE_U32,
 377         [RDMA_NLDEV_ATTR_RES_KERN_NAME] = MNL_TYPE_NUL_STRING,
 378         [RDMA_NLDEV_ATTR_RES_CM_ID]             = MNL_TYPE_NESTED,
 379         [RDMA_NLDEV_ATTR_RES_CM_ID_ENTRY]       = MNL_TYPE_NESTED,
 380         [RDMA_NLDEV_ATTR_RES_PS]                = MNL_TYPE_U32,
 381         [RDMA_NLDEV_ATTR_RES_SRC_ADDR]          = MNL_TYPE_UNSPEC,
 382         [RDMA_NLDEV_ATTR_RES_DST_ADDR]          = MNL_TYPE_UNSPEC,
 383         [RDMA_NLDEV_ATTR_RES_CQ] = MNL_TYPE_NESTED,
 384         [RDMA_NLDEV_ATTR_RES_CQ_ENTRY] = MNL_TYPE_NESTED,
 385         [RDMA_NLDEV_ATTR_RES_CQE] = MNL_TYPE_U32,
 386         [RDMA_NLDEV_ATTR_RES_USECNT] = MNL_TYPE_U64,
 387         [RDMA_NLDEV_ATTR_RES_POLL_CTX] = MNL_TYPE_U8,
 388         [RDMA_NLDEV_ATTR_RES_MR] = MNL_TYPE_NESTED,
 389         [RDMA_NLDEV_ATTR_RES_MR_ENTRY] = MNL_TYPE_NESTED,
 390         [RDMA_NLDEV_ATTR_RES_RKEY] = MNL_TYPE_U32,
 391         [RDMA_NLDEV_ATTR_RES_LKEY] = MNL_TYPE_U32,
 392         [RDMA_NLDEV_ATTR_RES_IOVA] = MNL_TYPE_U64,
 393         [RDMA_NLDEV_ATTR_RES_MRLEN] = MNL_TYPE_U64,
 394 };
 395
 396 int rd_attr_cb(const struct nlattr *attr, void *data)
 397 {
 398         const struct nlattr **tb = data;
 399         int type;
 400
 401         if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0)
 402                 /* We received uknown attribute */
 403                 return MNL_CB_OK;
 404
 405         type = mnl_attr_get_type(attr);
 406
 407         if (mnl_attr_validate(attr, nldev_policy[type]) < 0)
 408                 return MNL_CB_ERROR;
 409
 410         tb[type] = attr;
 411         return MNL_CB_OK;
 412 }
 413
 414 int rd_dev_init_cb(const struct nlmsghdr *nlh, void *data)
 415 {
 416         struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
 417         struct dev_map *dev_map;
 418         struct rd *rd = data;
 419         const char *dev_name;
 420
 421         mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
 422         if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_DEV_INDEX])
 423                 return MNL_CB_ERROR;
 424         if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
 425                 pr_err("This tool doesn't support switches yet\n");
 426                 return MNL_CB_ERROR;
 427         }
 428
 429         dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
 430
 431         dev_map = dev_map_alloc(dev_name);
 432         if (!dev_map)
 433                 /* The main function will cleanup the allocations */
 434                 return MNL_CB_ERROR;
 435         list_add_tail(&dev_map->list, &rd->dev_map_list);
 436
 437         dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
 438         dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
 439         return MNL_CB_OK;
 440 }
 441
 442 void rd_free(struct rd *rd)
 443 {
 444         if (!rd)
 445                 return;
 446         free(rd->buff);
 447         dev_map_cleanup(rd);
 448         filters_cleanup(rd);
 449 }
 450
 451 int rd_set_arg_to_devname(struct rd *rd)
 452 {
 453         int ret = 0;
 454
 455         while (!rd_no_arg(rd)) {
 456                 if (rd_argv_match(rd, "dev") || rd_argv_match(rd, "link")) {
 457                         rd_arg_inc(rd);
 458                         if (rd_no_arg(rd)) {
 459                                 pr_err("No device name was supplied\n");
 460                                 ret = -EINVAL;
 461                         }
 462                         goto out;
 463                 }
 464                 rd_arg_inc(rd);
 465         }
 466 out:
 467         return ret;
 468 }
 469
 470 int rd_exec_link(struct rd *rd, int (*cb)(struct rd *rd), bool strict_port)
 471 {
 472         struct dev_map *dev_map;
 473         uint32_t port;
 474         int ret = 0;
 475
 476         if (rd->json_output)
 477                 jsonw_start_array(rd->jw);
 478         if (rd_no_arg(rd)) {
 479                 list_for_each_entry(dev_map, &rd->dev_map_list, list) {
 480                         rd->dev_idx = dev_map->idx;
 481                         port = (strict_port) ? 1 : 0;
 482                         for (; port < dev_map->num_ports + 1; port++) {
 483                                 rd->port_idx = port;
 484                                 ret = cb(rd);
 485                                 if (ret)
 486                                         goto out;
 487                         }
 488                 }
 489
 490         } else {
 491                 bool is_dump_all;
 492
 493                 dev_map = dev_map_lookup(rd, true);
 494                 ret = get_port_from_argv(rd, &port, &is_dump_all, strict_port);
 495                 if (!dev_map || port > dev_map->num_ports || (!port && ret)) {
 496                         pr_err("Wrong device name\n");
 497                         ret = -ENOENT;
 498                         goto out;
 499                 }
 500                 rd_arg_inc(rd);
 501                 rd->dev_idx = dev_map->idx;
 502                 rd->port_idx = port;
 503                 for (; rd->port_idx < dev_map->num_ports + 1; rd->port_idx++) {
 504                         ret = cb(rd);
 505                         if (ret)
 506                                 goto out;
 507                         if (!is_dump_all)
 508                                 /*
 509                                  * We got request to show link for devname
 510                                  * with port index.
 511                                  */
 512                                 break;
 513                 }
 514         }
 515
 516 out:
 517         if (rd->json_output)
 518                 jsonw_end_array(rd->jw);
 519         return ret;
 520 }
 521
 522 int rd_exec_dev(struct rd *rd, int (*cb)(struct rd *rd))
 523 {
 524         struct dev_map *dev_map;
 525         int ret = 0;
 526
 527         if (rd->json_output)
 528                 jsonw_start_array(rd->jw);
 529         if (rd_no_arg(rd)) {
 530                 list_for_each_entry(dev_map, &rd->dev_map_list, list) {
 531                         rd->dev_idx = dev_map->idx;
 532                         ret = cb(rd);
 533                         if (ret)
 534                                 goto out;
 535                 }
 536         } else {
 537                 dev_map = dev_map_lookup(rd, false);
 538                 if (!dev_map) {
 539                         pr_err("Wrong device name - %s\n", rd_argv(rd));
 540                         ret = -ENOENT;
 541                         goto out;
 542                 }
 543                 rd_arg_inc(rd);
 544                 rd->dev_idx = dev_map->idx;
 545                 ret = cb(rd);
 546         }
 547 out:
 548         if (rd->json_output)
 549                 jsonw_end_array(rd->jw);
 550         return ret;
 551 }
 552
 553 int rd_exec_cmd(struct rd *rd, const struct rd_cmd *cmds, const char *str)
 554 {
 555         const struct rd_cmd *c;
 556
 557         /* First argument in objs table is default variant */
 558         if (rd_no_arg(rd))
 559                 return cmds->func(rd);
 560
 561         for (c = cmds + 1; c->cmd; ++c) {
 562                 if (rd_argv_match(rd, c->cmd)) {
 563                         /* Move to next argument */
 564                         rd_arg_inc(rd);
 565                         return c->func(rd);
 566                 }
 567         }
 568
 569         pr_err("Unknown %s '%s'.\n", str, rd_argv(rd));
 570         return 0;
 571 }
 572
 573 void rd_prepare_msg(struct rd *rd, uint32_t cmd, uint32_t *seq, uint16_t flags)
 574 {
 575         *seq = time(NULL);
 576
 577         rd->nlh = mnl_nlmsg_put_header(rd->buff);
 578         rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd);
 579         rd->nlh->nlmsg_seq = *seq;
 580         rd->nlh->nlmsg_flags = flags;
 581 }
 582
 583 int rd_send_msg(struct rd *rd)
 584 {
 585         int ret;
 586
 587         rd->nl = mnl_socket_open(NETLINK_RDMA);
 588         if (!rd->nl) {
 589                 pr_err("Failed to open NETLINK_RDMA socket\n");
 590                 return -ENODEV;
 591         }
 592
 593         ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID);
 594         if (ret < 0) {
 595                 pr_err("Failed to bind socket with err %d\n", ret);
 596                 goto err;
 597         }
 598
 599         ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len);
 600         if (ret < 0) {
 601                 pr_err("Failed to send to socket with err %d\n", ret);
 602                 goto err;
 603         }
 604         return 0;
 605
 606 err:
 607         mnl_socket_close(rd->nl);
 608         return ret;
 609 }
 610
 611 int rd_recv_msg(struct rd *rd, mnl_cb_t callback, void *data, unsigned int seq)
 612 {
 613         int ret;
 614         unsigned int portid;
 615         char buf[MNL_SOCKET_BUFFER_SIZE];
 616
 617         portid = mnl_socket_get_portid(rd->nl);
 618         do {
 619                 ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf));
 620                 if (ret <= 0)
 621                         break;
 622
 623                 ret = mnl_cb_run(buf, ret, seq, portid, callback, data);
 624         } while (ret > 0);
 625
 626         mnl_socket_close(rd->nl);
 627         return ret;
 628 }
 629
 630 static struct dev_map *_dev_map_lookup(struct rd *rd, const char *dev_name)
 631 {
 632         struct dev_map *dev_map;
 633
 634         list_for_each_entry(dev_map, &rd->dev_map_list, list)
 635                 if (strcmp(dev_name, dev_map->dev_name) == 0)
 636                         return dev_map;
 637
 638         return NULL;
 639 }
 640
 641 struct dev_map *dev_map_lookup(struct rd *rd, bool allow_port_index)
 642 {
 643         struct dev_map *dev_map;
 644         char *dev_name;
 645         char *slash;
 646
 647         if (rd_no_arg(rd))
 648                 return NULL;
 649
 650         dev_name = strdup(rd_argv(rd));
 651         if (allow_port_index) {
 652                 slash = strrchr(dev_name, '/');
 653                 if (slash)
 654                         *slash = '\0';
 655         }
 656
 657         dev_map = _dev_map_lookup(rd, dev_name);
 658         free(dev_name);
 659         return dev_map;
 660 }