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