]>
Commit | Line | Data |
---|---|---|
1 | // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB | |
2 | /* | |
3 | * link.c RDMA tool | |
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); | |
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); | |
15 | return 0; | |
16 | } | |
17 | ||
18 | static const char *caps_to_str(uint32_t idx) | |
19 | { | |
20 | #define RDMA_PORT_FLAGS_LOW(x) \ | |
21 | x(RESERVED, 0) \ | |
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) \ | |
32 | x(SYS_IMAGE_GUID, 11) \ | |
33 | x(PKEY_SW_EXT_PORT_TRAP, 12) \ | |
34 | x(CABLE_INFO, 13) \ | |
35 | x(EXTENDED_SPEEDS, 14) \ | |
36 | x(CAP_MASK2, 15) \ | |
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) \ | |
46 | x(CLIENT_REG, 25) \ | |
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) | |
53 | ||
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) | |
61 | ||
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) }; | |
72 | static const char * const | |
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]; | |
85 | ||
86 | return "UNKNOWN"; | |
87 | } | |
88 | ||
89 | static void link_print_caps(struct rd *rd, struct nlattr **tb) | |
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 | ||
99 | print_color_string(PRINT_FP, COLOR_NONE, NULL, "\n caps: <", NULL); | |
100 | open_json_array(PRINT_JSON, "caps"); | |
101 | for (idx = 0; caps; idx++) { | |
102 | if (caps & 0x1) | |
103 | print_color_string(PRINT_ANY, COLOR_NONE, NULL, | |
104 | caps >> 0x1 ? "%s, " : "%s", | |
105 | caps_to_str(idx)); | |
106 | caps >>= 0x1; | |
107 | } | |
108 | close_json_array(PRINT_ANY, ">"); | |
109 | } | |
110 | ||
111 | static void link_print_subnet_prefix(struct rd *rd, struct nlattr **tb) | |
112 | { | |
113 | uint64_t subnet_prefix; | |
114 | uint16_t vp[4]; | |
115 | char str[32]; | |
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]); | |
121 | memcpy(vp, &subnet_prefix, sizeof(uint64_t)); | |
122 | snprintf(str, 32, "%04x:%04x:%04x:%04x", vp[3], vp[2], vp[1], vp[0]); | |
123 | print_color_string(PRINT_ANY, COLOR_NONE, "subnet_prefix", | |
124 | "subnet_prefix %s ", str); | |
125 | } | |
126 | ||
127 | static void link_print_lid(struct rd *rd, struct nlattr **tb) | |
128 | { | |
129 | uint32_t lid; | |
130 | ||
131 | if (!tb[RDMA_NLDEV_ATTR_LID]) | |
132 | return; | |
133 | ||
134 | lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_LID]); | |
135 | print_color_uint(PRINT_ANY, COLOR_NONE, "lid", "lid %u ", lid); | |
136 | } | |
137 | ||
138 | static void link_print_sm_lid(struct rd *rd, struct nlattr **tb) | |
139 | { | |
140 | uint32_t sm_lid; | |
141 | ||
142 | if (!tb[RDMA_NLDEV_ATTR_SM_LID]) | |
143 | return; | |
144 | ||
145 | sm_lid = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_SM_LID]); | |
146 | print_color_uint(PRINT_ANY, COLOR_NONE, "sm_lid", "sm_lid %u ", sm_lid); | |
147 | } | |
148 | ||
149 | static void link_print_lmc(struct rd *rd, struct nlattr **tb) | |
150 | { | |
151 | uint8_t lmc; | |
152 | ||
153 | if (!tb[RDMA_NLDEV_ATTR_LMC]) | |
154 | return; | |
155 | ||
156 | lmc = mnl_attr_get_u8(tb[RDMA_NLDEV_ATTR_LMC]); | |
157 | print_color_uint(PRINT_ANY, COLOR_NONE, "lmc", "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 | print_color_string(PRINT_ANY, COLOR_NONE, "state", "state %s ", | |
180 | link_state_to_str(state)); | |
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 | ||
197 | static void link_print_phys_state(struct rd *rd, struct nlattr **tb) | |
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]); | |
205 | print_color_string(PRINT_ANY, COLOR_NONE, "physical_state", | |
206 | "physical_state %s ", phys_state_to_str(phys_state)); | |
207 | } | |
208 | ||
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]); | |
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); | |
223 | } | |
224 | ||
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; | |
229 | uint32_t port, idx; | |
230 | const char *name; | |
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 | ||
241 | idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); | |
242 | port = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_PORT_INDEX]); | |
243 | name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]); | |
244 | ||
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); | |
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); | |
255 | link_print_netdev(rd, tb); | |
256 | if (rd->show_details) | |
257 | link_print_caps(rd, tb); | |
258 | ||
259 | newline(rd); | |
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 | ||
276 | ret = rd_recv_msg(rd, link_parse_cb, rd, seq); | |
277 | return ret; | |
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 | ||
287 | if (!rd->port_idx) | |
288 | return 0; | |
289 | ||
290 | return rd_exec_cmd(rd, cmds, "parameter"); | |
291 | } | |
292 | ||
293 | static int link_show(struct rd *rd) | |
294 | { | |
295 | return rd_exec_link(rd, link_one_show, true); | |
296 | } | |
297 | ||
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 | ||
371 | int cmd_link(struct rd *rd) | |
372 | { | |
373 | const struct rd_cmd cmds[] = { | |
374 | { NULL, link_show }, | |
375 | { "add", link_add }, | |
376 | { "delete", link_del }, | |
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 | } |