| /* |
| * utils.c RDMA tool |
| * |
| * This program is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU General Public License |
| * as published by the Free Software Foundation; either version |
| * 2 of the License, or (at your option) any later version. |
| * |
| * Authors: Leon Romanovsky <leonro@mellanox.com> |
| */ |
| |
| #include "rdma.h" |
| |
| static int rd_argc(struct rd *rd) |
| { |
| return rd->argc; |
| } |
| |
| char *rd_argv(struct rd *rd) |
| { |
| if (!rd_argc(rd)) |
| return NULL; |
| return *rd->argv; |
| } |
| |
| static int strcmpx(const char *str1, const char *str2) |
| { |
| if (strlen(str1) > strlen(str2)) |
| return -1; |
| return strncmp(str1, str2, strlen(str1)); |
| } |
| |
| static bool rd_argv_match(struct rd *rd, const char *pattern) |
| { |
| if (!rd_argc(rd)) |
| return false; |
| return strcmpx(rd_argv(rd), pattern) == 0; |
| } |
| |
| void rd_arg_inc(struct rd *rd) |
| { |
| if (!rd_argc(rd)) |
| return; |
| rd->argc--; |
| rd->argv++; |
| } |
| |
| bool rd_no_arg(struct rd *rd) |
| { |
| return rd_argc(rd) == 0; |
| } |
| |
| uint32_t get_port_from_argv(struct rd *rd) |
| { |
| char *slash; |
| |
| slash = strchr(rd_argv(rd), '/'); |
| /* if no port found, return 0 */ |
| return slash ? atoi(slash + 1) : 0; |
| } |
| |
| static struct dev_map *dev_map_alloc(const char *dev_name) |
| { |
| struct dev_map *dev_map; |
| |
| dev_map = calloc(1, sizeof(*dev_map)); |
| if (!dev_map) |
| return NULL; |
| dev_map->dev_name = strdup(dev_name); |
| |
| return dev_map; |
| } |
| |
| static void dev_map_free(struct dev_map *dev_map) |
| { |
| if (!dev_map) |
| return; |
| |
| free(dev_map->dev_name); |
| free(dev_map); |
| } |
| |
| static void dev_map_cleanup(struct rd *rd) |
| { |
| struct dev_map *dev_map, *tmp; |
| |
| list_for_each_entry_safe(dev_map, tmp, |
| &rd->dev_map_list, list) { |
| list_del(&dev_map->list); |
| dev_map_free(dev_map); |
| } |
| } |
| |
| static const enum mnl_attr_data_type nldev_policy[RDMA_NLDEV_ATTR_MAX] = { |
| [RDMA_NLDEV_ATTR_DEV_INDEX] = MNL_TYPE_U32, |
| [RDMA_NLDEV_ATTR_DEV_NAME] = MNL_TYPE_NUL_STRING, |
| [RDMA_NLDEV_ATTR_PORT_INDEX] = MNL_TYPE_U32, |
| [RDMA_NLDEV_ATTR_CAP_FLAGS] = MNL_TYPE_U64, |
| [RDMA_NLDEV_ATTR_FW_VERSION] = MNL_TYPE_NUL_STRING, |
| [RDMA_NLDEV_ATTR_NODE_GUID] = MNL_TYPE_U64, |
| [RDMA_NLDEV_ATTR_SYS_IMAGE_GUID] = MNL_TYPE_U64, |
| [RDMA_NLDEV_ATTR_LID] = MNL_TYPE_U32, |
| [RDMA_NLDEV_ATTR_SM_LID] = MNL_TYPE_U32, |
| [RDMA_NLDEV_ATTR_LMC] = MNL_TYPE_U8, |
| [RDMA_NLDEV_ATTR_PORT_STATE] = MNL_TYPE_U8, |
| [RDMA_NLDEV_ATTR_PORT_PHYS_STATE] = MNL_TYPE_U8, |
| [RDMA_NLDEV_ATTR_DEV_NODE_TYPE] = MNL_TYPE_U8, |
| }; |
| |
| int rd_attr_cb(const struct nlattr *attr, void *data) |
| { |
| const struct nlattr **tb = data; |
| int type; |
| |
| if (mnl_attr_type_valid(attr, RDMA_NLDEV_ATTR_MAX) < 0) |
| return MNL_CB_ERROR; |
| |
| type = mnl_attr_get_type(attr); |
| |
| if (mnl_attr_validate(attr, nldev_policy[type]) < 0) |
| return MNL_CB_ERROR; |
| |
| tb[type] = attr; |
| return MNL_CB_OK; |
| } |
| |
| int rd_dev_init_cb(const struct nlmsghdr *nlh, void *data) |
| { |
| struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {}; |
| struct dev_map *dev_map; |
| struct rd *rd = data; |
| const char *dev_name; |
| |
| mnl_attr_parse(nlh, 0, rd_attr_cb, tb); |
| if (!tb[RDMA_NLDEV_ATTR_DEV_NAME] || !tb[RDMA_NLDEV_ATTR_DEV_INDEX]) |
| return MNL_CB_ERROR; |
| if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) { |
| pr_err("This tool doesn't support switches yet\n"); |
| return MNL_CB_ERROR; |
| } |
| |
| dev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]); |
| |
| dev_map = dev_map_alloc(dev_name); |
| if (!dev_map) |
| /* The main function will cleanup the allocations */ |
| return MNL_CB_ERROR; |
| list_add_tail(&dev_map->list, &rd->dev_map_list); |
| |
| dev_map->num_ports = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); |
| dev_map->idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); |
| return MNL_CB_OK; |
| } |
| |
| void rd_free_devmap(struct rd *rd) |
| { |
| if (!rd) |
| return; |
| dev_map_cleanup(rd); |
| } |
| |
| int rd_exec_cmd(struct rd *rd, const struct rd_cmd *cmds, const char *str) |
| { |
| const struct rd_cmd *c; |
| |
| /* First argument in objs table is default variant */ |
| if (rd_no_arg(rd)) |
| return cmds->func(rd); |
| |
| for (c = cmds + 1; c->cmd; ++c) { |
| if (rd_argv_match(rd, c->cmd)) { |
| /* Move to next argument */ |
| rd_arg_inc(rd); |
| return c->func(rd); |
| } |
| } |
| |
| pr_err("Unknown %s '%s'.\n", str, rd_argv(rd)); |
| return 0; |
| } |
| |
| void rd_prepare_msg(struct rd *rd, uint32_t cmd, uint32_t *seq, uint16_t flags) |
| { |
| *seq = time(NULL); |
| |
| rd->nlh = mnl_nlmsg_put_header(rd->buff); |
| rd->nlh->nlmsg_type = RDMA_NL_GET_TYPE(RDMA_NL_NLDEV, cmd); |
| rd->nlh->nlmsg_seq = *seq; |
| rd->nlh->nlmsg_flags = flags; |
| } |
| |
| int rd_send_msg(struct rd *rd) |
| { |
| int ret; |
| |
| rd->nl = mnl_socket_open(NETLINK_RDMA); |
| if (!rd->nl) { |
| pr_err("Failed to open NETLINK_RDMA socket\n"); |
| return -ENODEV; |
| } |
| |
| ret = mnl_socket_bind(rd->nl, 0, MNL_SOCKET_AUTOPID); |
| if (ret < 0) { |
| pr_err("Failed to bind socket with err %d\n", ret); |
| goto err; |
| } |
| |
| ret = mnl_socket_sendto(rd->nl, rd->nlh, rd->nlh->nlmsg_len); |
| if (ret < 0) { |
| pr_err("Failed to send to socket with err %d\n", ret); |
| goto err; |
| } |
| return 0; |
| |
| err: |
| mnl_socket_close(rd->nl); |
| return ret; |
| } |
| |
| int rd_recv_msg(struct rd *rd, mnl_cb_t callback, void *data, unsigned int seq) |
| { |
| int ret; |
| unsigned int portid; |
| char buf[MNL_SOCKET_BUFFER_SIZE]; |
| |
| portid = mnl_socket_get_portid(rd->nl); |
| do { |
| ret = mnl_socket_recvfrom(rd->nl, buf, sizeof(buf)); |
| if (ret <= 0) |
| break; |
| |
| ret = mnl_cb_run(buf, ret, seq, portid, callback, data); |
| } while (ret > 0); |
| |
| mnl_socket_close(rd->nl); |
| return ret; |
| } |
| |
| struct dev_map *_dev_map_lookup(struct rd *rd, const char *dev_name) |
| { |
| struct dev_map *dev_map; |
| |
| list_for_each_entry(dev_map, &rd->dev_map_list, list) |
| if (strcmp(dev_name, dev_map->dev_name) == 0) |
| return dev_map; |
| |
| return NULL; |
| } |
| |
| struct dev_map *dev_map_lookup(struct rd *rd, bool allow_port_index) |
| { |
| struct dev_map *dev_map; |
| char *dev_name; |
| char *slash; |
| |
| dev_name = strdup(rd_argv(rd)); |
| if (allow_port_index) { |
| slash = strrchr(dev_name, '/'); |
| if (slash) |
| *slash = '\0'; |
| } |
| |
| dev_map = _dev_map_lookup(rd, dev_name); |
| free(dev_name); |
| return dev_map; |
| } |