rdma/link.c

   1 /*
   2  * link.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 link_help(struct rd *rd)
  15 {
  16         pr_out("Usage: %s link show [DEV/PORT_INDEX]\n", rd->filename);
  17         return 0;
  18 }
  19
  20 static const char *caps_to_str(uint32_t idx)
  21 {
  22 #define RDMA_PORT_FLAGS(x) \
  23         x(SM, 1) \
  24         x(NOTICE, 2) \
  25         x(TRAP, 3) \
  26         x(OPT_IPD, 4) \
  27         x(AUTO_MIGR, 5) \
  28         x(SL_MAP, 6) \
  29         x(MKEY_NVRAM, 7) \
  30         x(PKEY_NVRAM, 8) \
  31         x(LED_INFO, 9) \
  32         x(SM_DISABLED, 10) \
  33         x(SYS_IMAGE_GUIG, 11) \
  34         x(PKEY_SW_EXT_PORT_TRAP, 12) \
  35         x(EXTENDED_SPEEDS, 14) \
  36         x(CM, 16) \
  37         x(SNMP_TUNNEL, 17) \
  38         x(REINIT, 18) \
  39         x(DEVICE_MGMT, 19) \
  40         x(VENDOR_CLASS, 20) \
  41         x(DR_NOTICE, 21) \
  42         x(CAP_MASK_NOTICE, 22) \
  43         x(BOOT_MGMT, 23) \
  44         x(LINK_LATENCY, 24) \
  45         x(CLIENT_REG, 23) \
  46         x(IP_BASED_GIDS, 26)
  47
  48         enum { RDMA_PORT_FLAGS(RDMA_BITMAP_ENUM) };
  49
  50         static const char * const
  51                 rdma_port_names[] = { RDMA_PORT_FLAGS(RDMA_BITMAP_NAMES) };
  52         #undef RDMA_PORT_FLAGS
  53
  54         if (idx < ARRAY_SIZE(rdma_port_names) && rdma_port_names[idx])
  55                 return rdma_port_names[idx];
  56         return "UNKNOWN";
  57 }
  58
  59 static void link_print_caps(struct rd *rd, struct nlattr **tb)
  60 {
  61         uint64_t caps;
  62         uint32_t idx;
  63
  64         if (!tb[RDMA_NLDEV_ATTR_CAP_FLAGS])
  65                 return;
  66
  67         caps = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_CAP_FLAGS]);
  68
  69         if (rd->json_output) {
  70                 jsonw_name(rd->jw, "caps");
  71                 jsonw_start_array(rd->jw);
  72         } else {
  73                 pr_out("\n    caps: <");
  74         }
  75         for (idx = 0; caps; idx++) {
  76                 if (caps & 0x1) {
  77                         if (rd->json_output) {
  78                                 jsonw_string(rd->jw, caps_to_str(idx));
  79                         } else {
  80                                 pr_out("%s", caps_to_str(idx));
  81                                 if (caps >> 0x1)
  82                                         pr_out(", ");
  83                         }
  84                 }
  85                 caps >>= 0x1;
  86         }
  87
  88         if (rd->json_output)
  89                 jsonw_end_array(rd->jw);
  90         else
  91                 pr_out(">");
  92 }
  93
  94 static void link_print_subnet_prefix(struct rd *rd, struct nlattr **tb)
  95 {
  96         uint64_t subnet_prefix;
  97         uint16_t vp[4];
  98         char str[32];
  99
 100         if (!tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX])
 101                 return;
 102
 103         subnet_prefix = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX]);
 104         memcpy(vp, &subnet_prefix, sizeof(uint64_t));
 105         snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]);
 106         if (rd->json_output)
 107                 jsonw_string_field(rd->jw, "subnet_prefix", str);
 108         else
 109                 pr_out("subnet_prefix %s ", str);
 110 }
 111
 112 static void link_print_lid(struct rd *rd, struct nlattr **tb)
 113 {
 114         uint32_t lid;
 115
 116         if (!tb[RDMA_NLDEV_ATTR_LID])
 117                 return;
 118
 119         lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_LID]);
 120         if (rd->json_output)
 121                 jsonw_uint_field(rd->jw, "lid", lid);
 122         else
 123                 pr_out("lid %u ", lid);
 124 }
 125
 126 static void link_print_sm_lid(struct rd *rd, struct nlattr **tb)
 127 {
 128         uint32_t sm_lid;
 129
 130         if (!tb[RDMA_NLDEV_ATTR_SM_LID])
 131                 return;
 132
 133         sm_lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_SM_LID]);
 134         if (rd->json_output)
 135                 jsonw_uint_field(rd->jw, "sm_lid", sm_lid);
 136         else
 137                 pr_out("sm_lid %u ", sm_lid);
 138 }
 139
 140 static void link_print_lmc(struct rd *rd, struct nlattr **tb)
 141 {
 142         uint8_t lmc;
 143
 144         if (!tb[RDMA_NLDEV_ATTR_LMC])
 145                 return;
 146
 147         lmc = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_LMC]);
 148         if (rd->json_output)
 149                 jsonw_uint_field(rd->jw, "lmc", lmc);
 150         else
 151                 pr_out("lmc %u ", lmc);
 152 }
 153
 154 static const char *link_state_to_str(uint8_t link_state)
 155 {
 156         static const char * const link_state_str[] = { "NOP", "DOWN",
 157                                                        "INIT", "ARMED",
 158                                                        "ACTIVE",
 159                                                        "ACTIVE_DEFER" };
 160         if (link_state < ARRAY_SIZE(link_state_str))
 161                 return link_state_str[link_state];
 162         return "UNKNOWN";
 163 }
 164
 165 static void link_print_state(struct rd *rd, struct nlattr **tb)
 166 {
 167         uint8_t state;
 168
 169         if (!tb[RDMA_NLDEV_ATTR_PORT_STATE])
 170                 return;
 171
 172         state = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_PORT_STATE]);
 173         if (rd->json_output)
 174                 jsonw_string_field(rd->jw, "state", link_state_to_str(state));
 175         else
 176                 pr_out("state %s ", link_state_to_str(state));
 177 }
 178
 179 static const char *phys_state_to_str(uint8_t phys_state)
 180 {
 181         static const char * const phys_state_str[] = { "NOP", "SLEEP",
 182                                                        "POLLING", "DISABLED",
 183                                                        "ARMED", "LINK_UP",
 184                                                        "LINK_ERROR_RECOVER",
 185                                                        "PHY_TEST", "UNKNOWN",
 186                                                        "OPA_OFFLINE",
 187                                                        "UNKNOWN", "OPA_TEST" };
 188         if (phys_state < ARRAY_SIZE(phys_state_str))
 189                 return phys_state_str[phys_state];
 190         return "UNKNOWN";
 191 };
 192
 193 static void link_print_phys_state(struct rd *rd, struct nlattr **tb)
 194 {
 195         uint8_t phys_state;
 196
 197         if (!tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE])
 198                 return;
 199
 200         phys_state = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE]);
 201         if (rd->json_output)
 202                 jsonw_string_field(rd->jw, "physical_state",
 203                                    phys_state_to_str(phys_state));
 204         else
 205                 pr_out("physical_state %s ", phys_state_to_str(phys_state));
 206 }
 207
 208 static int link_parse_cb(const struct nlmsghdr *nlh, void *data)
 209 {
 210         struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
 211         struct rd *rd = data;
 212         uint32_t port, idx;
 213         char name[32];
 214
 215         mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
 216         if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_DEV_NAME])
 217                 return MNL_CB_ERROR;
 218
 219         if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) {
 220                 pr_err("This tool doesn't support switches yet\n");
 221                 return MNL_CB_ERROR;
 222         }
 223
 224         idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
 225         port = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]);
 226         snprintf(name, 32, "%s/%u",
 227                  mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]), port);
 228
 229         if (rd->json_output) {
 230                 jsonw_uint_field(rd->jw, "ifindex", idx);
 231                 jsonw_uint_field(rd->jw, "port", port);
 232                 jsonw_string_field(rd->jw, "ifname", name);
 233
 234         } else {
 235                 pr_out("%u/%u: %s: ", idx, port, name);
 236         }
 237
 238         link_print_subnet_prefix(rd, tb);
 239         link_print_lid(rd, tb);
 240         link_print_sm_lid(rd, tb);
 241         link_print_lmc(rd, tb);
 242         link_print_state(rd, tb);
 243         link_print_phys_state(rd, tb);
 244         if (rd->show_details)
 245                 link_print_caps(rd, tb);
 246
 247         if (!rd->json_output)
 248                 pr_out("\n");
 249         return MNL_CB_OK;
 250 }
 251
 252 static int link_no_args(struct rd *rd)
 253 {
 254         uint32_t seq;
 255         int ret;
 256
 257         rd_prepare_msg(rd, RDMA_NLDEV_CMD_PORT_GET, &seq,
 258                        (NLM_F_REQUEST | NLM_F_ACK));
 259         mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
 260         mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_PORT_INDEX, rd->port_idx);
 261         ret = rd_send_msg(rd);
 262         if (ret)
 263                 return ret;
 264
 265         if (rd->json_output)
 266                 jsonw_start_object(rd->jw);
 267         ret = rd_recv_msg(rd, link_parse_cb, rd, seq);
 268         if (rd->json_output)
 269                 jsonw_end_object(rd->jw);
 270         return ret;
 271 }
 272
 273 static int link_one_show(struct rd *rd)
 274 {
 275         const struct rd_cmd cmds[] = {
 276                 { NULL,         link_no_args},
 277                 { 0 }
 278         };
 279
 280         return rd_exec_cmd(rd, cmds, "parameter");
 281 }
 282
 283 static int link_show(struct rd *rd)
 284 {
 285         struct dev_map *dev_map;
 286         uint32_t port;
 287         int ret = 0;
 288
 289         if (rd->json_output)
 290                 jsonw_start_array(rd->jw);
 291         if (rd_no_arg(rd)) {
 292                 list_for_each_entry(dev_map, &rd->dev_map_list, list) {
 293                         rd->dev_idx = dev_map->idx;
 294                         for (port = 1; port < dev_map->num_ports + 1; port++) {
 295                                 rd->port_idx = port;
 296                                 ret = link_one_show(rd);
 297                                 if (ret)
 298                                         goto out;
 299                         }
 300                 }
 301
 302         } else {
 303                 dev_map = dev_map_lookup(rd, true);
 304                 port = get_port_from_argv(rd);
 305                 if (!dev_map || port > dev_map->num_ports) {
 306                         pr_err("Wrong device name\n");
 307                         ret = -ENOENT;
 308                         goto out;
 309                 }
 310                 rd_arg_inc(rd);
 311                 rd->dev_idx = dev_map->idx;
 312                 rd->port_idx = port ? : 1;
 313                 for (; rd->port_idx < dev_map->num_ports + 1; rd->port_idx++) {
 314                         ret = link_one_show(rd);
 315                         if (ret)
 316                                 goto out;
 317                         if (port)
 318                                 /*
 319                                  * We got request to show link for devname
 320                                  * with port index.
 321                                  */
 322                                 break;
 323                 }
 324         }
 325
 326 out:
 327         if (rd->json_output)
 328                 jsonw_end_array(rd->jw);
 329         return ret;
 330 }
 331
 332 int cmd_link(struct rd *rd)
 333 {
 334         const struct rd_cmd cmds[] = {
 335                 { NULL,         link_show },
 336                 { "show",       link_show },
 337                 { "list",       link_show },
 338                 { "help",       link_help },
 339                 { 0 }
 340         };
 341
 342         return rd_exec_cmd(rd, cmds, "link command");
 343 }