]>
Commit | Line | Data |
---|---|---|
835d8321 | 1 | // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB |
da990ab4 LR |
2 | /* |
3 | * link.c RDMA tool | |
da990ab4 LR |
4 | * Authors: Leon Romanovsky <leonro@mellanox.com> |
5 | */ | |
6 | ||
7 | #include "rdma.h" | |
8 | ||
9 | static int link_help(struct rd *rd) | |
10 | { | |
11 | pr_out("Usage: %s link show [DEV/PORT_INDEX]\n", rd->filename); | |
4336c582 SW |
12 | pr_out("Usage: %s link add NAME type TYPE netdev NETDEV\n", |
13 | rd->filename); | |
14 | pr_out("Usage: %s link delete NAME\n", rd->filename); | |
da990ab4 LR |
15 | return 0; |
16 | } | |
17 | ||
18 | static const char *caps_to_str(uint32_t idx) | |
19 | { | |
40fc8c2c | 20 | #define RDMA_PORT_FLAGS_LOW(x) \ |
d090fbf3 | 21 | x(RESERVED, 0) \ |
da990ab4 LR |
22 | x(SM, 1) \ |
23 | x(NOTICE, 2) \ | |
24 | x(TRAP, 3) \ | |
25 | x(OPT_IPD, 4) \ | |
26 | x(AUTO_MIGR, 5) \ | |
27 | x(SL_MAP, 6) \ | |
28 | x(MKEY_NVRAM, 7) \ | |
29 | x(PKEY_NVRAM, 8) \ | |
30 | x(LED_INFO, 9) \ | |
31 | x(SM_DISABLED, 10) \ | |
4e2eb9fd | 32 | x(SYS_IMAGE_GUID, 11) \ |
da990ab4 | 33 | x(PKEY_SW_EXT_PORT_TRAP, 12) \ |
d090fbf3 | 34 | x(CABLE_INFO, 13) \ |
da990ab4 | 35 | x(EXTENDED_SPEEDS, 14) \ |
d090fbf3 | 36 | x(CAP_MASK2, 15) \ |
da990ab4 LR |
37 | x(CM, 16) \ |
38 | x(SNMP_TUNNEL, 17) \ | |
39 | x(REINIT, 18) \ | |
40 | x(DEVICE_MGMT, 19) \ | |
41 | x(VENDOR_CLASS, 20) \ | |
42 | x(DR_NOTICE, 21) \ | |
43 | x(CAP_MASK_NOTICE, 22) \ | |
44 | x(BOOT_MGMT, 23) \ | |
45 | x(LINK_LATENCY, 24) \ | |
8f478ec2 | 46 | x(CLIENT_REG, 25) \ |
d090fbf3 LR |
47 | x(OTHER_LOCAL_CHANGES, 26) \ |
48 | x(LINK_SPPED_WIDTH, 27) \ | |
49 | x(VENDOR_SPECIFIC_MADS, 28) \ | |
50 | x(MULT_PKER_TRAP, 29) \ | |
51 | x(MULT_FDB, 30) \ | |
52 | x(HIERARCHY_INFO, 31) | |
da990ab4 | 53 | |
40fc8c2c MG |
54 | #define RDMA_PORT_FLAGS_HIGH(x) \ |
55 | x(SET_NODE_DESC, 0) \ | |
56 | x(EXT_INFO, 1) \ | |
57 | x(VIRT, 2) \ | |
58 | x(SWITCH_POR_STATE_TABLE, 3) \ | |
59 | x(LINK_WIDTH_2X, 4) \ | |
60 | x(LINK_SPEED_HDR, 5) | |
da990ab4 | 61 | |
40fc8c2c MG |
62 | /* |
63 | * Separation below is needed to allow compilation of rdmatool | |
64 | * on 32bits systems. On such systems, C-enum is limited to be | |
65 | * int and can't hold more than 32 bits. | |
66 | */ | |
67 | enum { RDMA_PORT_FLAGS_LOW(RDMA_BITMAP_ENUM) }; | |
68 | enum { RDMA_PORT_FLAGS_HIGH(RDMA_BITMAP_ENUM) }; | |
69 | ||
70 | static const char * const | |
71 | rdma_port_names_low[] = { RDMA_PORT_FLAGS_LOW(RDMA_BITMAP_NAMES) }; | |
da990ab4 | 72 | static const char * const |
40fc8c2c MG |
73 | rdma_port_names_high[] = { RDMA_PORT_FLAGS_HIGH(RDMA_BITMAP_NAMES) }; |
74 | uint32_t high_idx; | |
75 | #undef RDMA_PORT_FLAGS_LOW | |
76 | #undef RDMA_PORT_FLAGS_HIGH | |
77 | ||
78 | if (idx < ARRAY_SIZE(rdma_port_names_low) && rdma_port_names_low[idx]) | |
79 | return rdma_port_names_low[idx]; | |
80 | ||
81 | high_idx = idx - ARRAY_SIZE(rdma_port_names_low); | |
82 | if (high_idx < ARRAY_SIZE(rdma_port_names_high) && | |
83 | rdma_port_names_high[high_idx]) | |
84 | return rdma_port_names_high[high_idx]; | |
da990ab4 | 85 | |
40fc8c2c | 86 | return "UNKNOWN"; |
da990ab4 LR |
87 | } |
88 | ||
7fc75744 | 89 | static void link_print_caps(struct rd *rd, struct nlattr **tb) |
da990ab4 LR |
90 | { |
91 | uint64_t caps; | |
92 | uint32_t idx; | |
93 | ||
94 | if (!tb[RDMA_NLDEV_ATTR_CAP_FLAGS]) | |
95 | return; | |
96 | ||
97 | caps = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_CAP_FLAGS]); | |
98 | ||
b0a688a5 IK |
99 | print_color_string(PRINT_FP, COLOR_NONE, NULL, "\n caps: <", NULL); |
100 | open_json_array(PRINT_JSON, "caps"); | |
da990ab4 | 101 | for (idx = 0; caps; idx++) { |
b0a688a5 IK |
102 | if (caps & 0x1) |
103 | print_color_string(PRINT_ANY, COLOR_NONE, NULL, | |
104 | caps >> 0x1 ? "%s, " : "%s", | |
105 | caps_to_str(idx)); | |
da990ab4 LR |
106 | caps >>= 0x1; |
107 | } | |
b0a688a5 | 108 | close_json_array(PRINT_ANY, ">"); |
da990ab4 LR |
109 | } |
110 | ||
7fc75744 | 111 | static void link_print_subnet_prefix(struct rd *rd, struct nlattr **tb) |
da990ab4 LR |
112 | { |
113 | uint64_t subnet_prefix; | |
7fc75744 LR |
114 | uint16_t vp[4]; |
115 | char str[32]; | |
da990ab4 LR |
116 | |
117 | if (!tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX]) | |
118 | return; | |
119 | ||
120 | subnet_prefix = mnl_attr_get_u64(tb[RDMA_NLDEV_ATTR_SUBNET_PREFIX]); | |
7fc75744 LR |
121 | memcpy(vp, &subnet_prefix, sizeof(uint64_t)); |
122 | snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]); | |
b0a688a5 IK |
123 | print_color_string(PRINT_ANY, COLOR_NONE, "subnet_prefix", |
124 | "subnet_prefix %s ", str); | |
da990ab4 LR |
125 | } |
126 | ||
7fc75744 | 127 | static void link_print_lid(struct rd *rd, struct nlattr **tb) |
da990ab4 | 128 | { |
7fc75744 LR |
129 | uint32_t lid; |
130 | ||
da990ab4 LR |
131 | if (!tb[RDMA_NLDEV_ATTR_LID]) |
132 | return; | |
133 | ||
7fc75744 | 134 | lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_LID]); |
b0a688a5 | 135 | print_color_uint(PRINT_ANY, COLOR_NONE, "lid", "lid %u ", lid); |
da990ab4 LR |
136 | } |
137 | ||
7fc75744 | 138 | static void link_print_sm_lid(struct rd *rd, struct nlattr **tb) |
da990ab4 | 139 | { |
7fc75744 LR |
140 | uint32_t sm_lid; |
141 | ||
da990ab4 LR |
142 | if (!tb[RDMA_NLDEV_ATTR_SM_LID]) |
143 | return; | |
144 | ||
7fc75744 | 145 | sm_lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_SM_LID]); |
b0a688a5 | 146 | print_color_uint(PRINT_ANY, COLOR_NONE, "sm_lid", "sm_lid %u ", sm_lid); |
da990ab4 LR |
147 | } |
148 | ||
7fc75744 | 149 | static void link_print_lmc(struct rd *rd, struct nlattr **tb) |
da990ab4 | 150 | { |
7fc75744 LR |
151 | uint8_t lmc; |
152 | ||
da990ab4 LR |
153 | if (!tb[RDMA_NLDEV_ATTR_LMC]) |
154 | return; | |
155 | ||
7fc75744 | 156 | lmc = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_LMC]); |
b0a688a5 | 157 | print_color_uint(PRINT_ANY, COLOR_NONE, "lmc", "lmc %u ", lmc); |
da990ab4 LR |
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 | ||
7fc75744 | 171 | static void link_print_state(struct rd *rd, struct nlattr **tb) |
da990ab4 LR |
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]); | |
b0a688a5 IK |
179 | print_color_string(PRINT_ANY, COLOR_NONE, "state", "state %s ", |
180 | link_state_to_str(state)); | |
da990ab4 LR |
181 | } |
182 | ||
183 | static const char *phys_state_to_str(uint8_t phys_state) | |
184 | { | |
185 | static const char * const phys_state_str[] = { "NOP", "SLEEP", | |
186 | "POLLING", "DISABLED", | |
187 | "ARMED", "LINK_UP", | |
188 | "LINK_ERROR_RECOVER", | |
189 | "PHY_TEST", "UNKNOWN", | |
190 | "OPA_OFFLINE", | |
191 | "UNKNOWN", "OPA_TEST" }; | |
192 | if (phys_state < ARRAY_SIZE(phys_state_str)) | |
193 | return phys_state_str[phys_state]; | |
194 | return "UNKNOWN"; | |
195 | }; | |
196 | ||
7fc75744 | 197 | static void link_print_phys_state(struct rd *rd, struct nlattr **tb) |
da990ab4 LR |
198 | { |
199 | uint8_t phys_state; | |
200 | ||
201 | if (!tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE]) | |
202 | return; | |
203 | ||
204 | phys_state = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_PORT_PHYS_STATE]); | |
b0a688a5 IK |
205 | print_color_string(PRINT_ANY, COLOR_NONE, "physical_state", |
206 | "physical_state %s ", phys_state_to_str(phys_state)); | |
da990ab4 LR |
207 | } |
208 | ||
15259427 LR |
209 | static void link_print_netdev(struct rd *rd, struct nlattr **tb) |
210 | { | |
211 | const char *netdev_name; | |
212 | uint32_t idx; | |
213 | ||
214 | if (!tb[RDMA_NLDEV_ATTR_NDEV_NAME] || !tb[RDMA_NLDEV_ATTR_NDEV_INDEX]) | |
215 | return; | |
216 | ||
217 | netdev_name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_NDEV_NAME]); | |
218 | idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_NDEV_INDEX]); | |
b0a688a5 IK |
219 | print_color_string(PRINT_ANY, COLOR_NONE, "netdev", "netdev %s ", |
220 | netdev_name); | |
221 | print_color_uint(PRINT_ANY, COLOR_NONE, "netdev_index", | |
222 | rd->show_details ? "netdev_index %u " : "", idx); | |
15259427 LR |
223 | } |
224 | ||
da990ab4 LR |
225 | static int link_parse_cb(const struct nlmsghdr *nlh, void *data) |
226 | { | |
227 | struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {}; | |
228 | struct rd *rd = data; | |
7fc75744 | 229 | uint32_t port, idx; |
b0a688a5 | 230 | const char *name; |
da990ab4 LR |
231 | |
232 | mnl_attr_parse(nlh, 0, rd_attr_cb, tb); | |
233 | if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || !tb[RDMA_NLDEV_ATTR_DEV_NAME]) | |
234 | return MNL_CB_ERROR; | |
235 | ||
236 | if (!tb[RDMA_NLDEV_ATTR_PORT_INDEX]) { | |
237 | pr_err("This tool doesn't support switches yet\n"); | |
238 | return MNL_CB_ERROR; | |
239 | } | |
240 | ||
7fc75744 LR |
241 | idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); |
242 | port = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); | |
b0a688a5 | 243 | name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]); |
7fc75744 | 244 | |
b0a688a5 IK |
245 | open_json_object(NULL); |
246 | print_color_uint(PRINT_JSON, COLOR_NONE, "ifindex", NULL, idx); | |
247 | print_color_string(PRINT_ANY, COLOR_NONE, "ifname", "link %s/", name); | |
248 | print_color_uint(PRINT_ANY, COLOR_NONE, "port", "%u ", port); | |
7fc75744 LR |
249 | link_print_subnet_prefix(rd, tb); |
250 | link_print_lid(rd, tb); | |
251 | link_print_sm_lid(rd, tb); | |
252 | link_print_lmc(rd, tb); | |
253 | link_print_state(rd, tb); | |
254 | link_print_phys_state(rd, tb); | |
15259427 | 255 | link_print_netdev(rd, tb); |
da990ab4 | 256 | if (rd->show_details) |
7fc75744 | 257 | link_print_caps(rd, tb); |
da990ab4 | 258 | |
b0a688a5 | 259 | newline(rd); |
da990ab4 LR |
260 | return MNL_CB_OK; |
261 | } | |
262 | ||
263 | static int link_no_args(struct rd *rd) | |
264 | { | |
265 | uint32_t seq; | |
266 | int ret; | |
267 | ||
268 | rd_prepare_msg(rd, RDMA_NLDEV_CMD_PORT_GET, &seq, | |
269 | (NLM_F_REQUEST | NLM_F_ACK)); | |
270 | mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx); | |
271 | mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_PORT_INDEX, rd->port_idx); | |
272 | ret = rd_send_msg(rd); | |
273 | if (ret) | |
274 | return ret; | |
275 | ||
7fc75744 | 276 | ret = rd_recv_msg(rd, link_parse_cb, rd, seq); |
7fc75744 | 277 | return ret; |
da990ab4 LR |
278 | } |
279 | ||
280 | static int link_one_show(struct rd *rd) | |
281 | { | |
282 | const struct rd_cmd cmds[] = { | |
283 | { NULL, link_no_args}, | |
284 | { 0 } | |
285 | }; | |
286 | ||
e3dee3c8 LR |
287 | if (!rd->port_idx) |
288 | return 0; | |
289 | ||
da990ab4 LR |
290 | return rd_exec_cmd(rd, cmds, "parameter"); |
291 | } | |
292 | ||
293 | static int link_show(struct rd *rd) | |
294 | { | |
6416d1a0 | 295 | return rd_exec_link(rd, link_one_show, true); |
da990ab4 LR |
296 | } |
297 | ||
4336c582 SW |
298 | static int link_add_netdev(struct rd *rd) |
299 | { | |
300 | char *link_netdev; | |
301 | uint32_t seq; | |
302 | ||
303 | if (rd_no_arg(rd)) { | |
304 | pr_err("Please provide a net device name.\n"); | |
305 | return -EINVAL; | |
306 | } | |
307 | ||
308 | link_netdev = rd_argv(rd); | |
309 | rd_prepare_msg(rd, RDMA_NLDEV_CMD_NEWLINK, &seq, | |
310 | (NLM_F_REQUEST | NLM_F_ACK)); | |
311 | mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_DEV_NAME, rd->link_name); | |
312 | mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_LINK_TYPE, rd->link_type); | |
313 | mnl_attr_put_strz(rd->nlh, RDMA_NLDEV_ATTR_NDEV_NAME, link_netdev); | |
314 | return rd_sendrecv_msg(rd, seq); | |
315 | } | |
316 | ||
317 | static int link_add_type(struct rd *rd) | |
318 | { | |
319 | const struct rd_cmd cmds[] = { | |
320 | { NULL, link_help}, | |
321 | { "netdev", link_add_netdev}, | |
322 | { 0 } | |
323 | }; | |
324 | ||
325 | if (rd_no_arg(rd)) { | |
326 | pr_err("Please provide a link type name.\n"); | |
327 | return -EINVAL; | |
328 | } | |
329 | rd->link_type = rd_argv(rd); | |
330 | rd_arg_inc(rd); | |
331 | return rd_exec_cmd(rd, cmds, "parameter"); | |
332 | } | |
333 | ||
334 | static int link_add(struct rd *rd) | |
335 | { | |
336 | const struct rd_cmd cmds[] = { | |
337 | { NULL, link_help}, | |
338 | { "type", link_add_type}, | |
339 | { 0 } | |
340 | }; | |
341 | ||
342 | if (rd_no_arg(rd)) { | |
343 | pr_err("Please provide a link name to add.\n"); | |
344 | return -EINVAL; | |
345 | } | |
346 | rd->link_name = rd_argv(rd); | |
347 | rd_arg_inc(rd); | |
348 | ||
349 | return rd_exec_cmd(rd, cmds, "parameter"); | |
350 | } | |
351 | ||
352 | static int _link_del(struct rd *rd) | |
353 | { | |
354 | uint32_t seq; | |
355 | ||
356 | if (!rd_no_arg(rd)) { | |
357 | pr_err("Unknown parameter %s\n", rd_argv(rd)); | |
358 | return -EINVAL; | |
359 | } | |
360 | rd_prepare_msg(rd, RDMA_NLDEV_CMD_DELLINK, &seq, | |
361 | (NLM_F_REQUEST | NLM_F_ACK)); | |
362 | mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx); | |
363 | return rd_sendrecv_msg(rd, seq); | |
364 | } | |
365 | ||
366 | static int link_del(struct rd *rd) | |
367 | { | |
368 | return rd_exec_require_dev(rd, _link_del); | |
369 | } | |
370 | ||
da990ab4 LR |
371 | int cmd_link(struct rd *rd) |
372 | { | |
373 | const struct rd_cmd cmds[] = { | |
374 | { NULL, link_show }, | |
4336c582 SW |
375 | { "add", link_add }, |
376 | { "delete", link_del }, | |
da990ab4 LR |
377 | { "show", link_show }, |
378 | { "list", link_show }, | |
379 | { "help", link_help }, | |
380 | { 0 } | |
381 | }; | |
382 | ||
383 | return rd_exec_cmd(rd, cmds, "link command"); | |
384 | } |