]> git.proxmox.com Git - mirror_iproute2.git/blob - rdma/res.c
projects / mirror_iproute2.git / blob
? search:


1de8c7978c89b0bd6c334c3d65c129d89e8a3c33
[mirror_iproute2.git] / rdma / res.c
1 /*
2 * res.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 "res.h"
13 #include <inttypes.h>
14
15 static int res_help(struct rd *rd)
16 {
17 pr_out("Usage: %s resource\n", rd->filename);
18 pr_out(" resource show [DEV]\n");
19 pr_out(" resource show [qp|cm_id|pd|mr|cq]\n");
20 pr_out(" resource show qp link [DEV/PORT]\n");
21 pr_out(" resource show qp link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n");
22 pr_out(" resource show cm_id link [DEV/PORT]\n");
23 pr_out(" resource show cm_id link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n");
24 pr_out(" resource show cq link [DEV/PORT]\n");
25 pr_out(" resource show cq link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n");
26 pr_out(" resource show pd dev [DEV]\n");
27 pr_out(" resource show pd dev [DEV] [FILTER-NAME FILTER-VALUE]\n");
28 pr_out(" resource show mr dev [DEV]\n");
29 pr_out(" resource show mr dev [DEV] [FILTER-NAME FILTER-VALUE]\n");
30 return 0;
31 }
32
33 static int res_print_summary(struct rd *rd, struct nlattr **tb)
34 {
35 struct nlattr *nla_table = tb[RDMA_NLDEV_ATTR_RES_SUMMARY];
36 struct nlattr *nla_entry;
37 const char *name;
38 uint64_t curr;
39 int err;
40
41 mnl_attr_for_each_nested(nla_entry, nla_table) {
42 struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
43 char json_name[32];
44
45 err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
46 if (err != MNL_CB_OK)
47 return -EINVAL;
48
49 if (!nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME] ||
50 !nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]) {
51 return -EINVAL;
52 }
53
54 name = mnl_attr_get_str(nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME]);
55 curr = mnl_attr_get_u64(nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]);
56 if (rd->json_output) {
57 snprintf(json_name, 32, "%s", name);
58 jsonw_lluint_field(rd->jw, json_name, curr);
59 } else {
60 pr_out("%s %"PRId64 " ", name, curr);
61 }
62 }
63 return 0;
64 }
65
66 static int res_no_args_parse_cb(const struct nlmsghdr *nlh, void *data)
67 {
68 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
69 struct rd *rd = data;
70 const char *name;
71 uint32_t idx;
72
73 mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
74 if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
75 !tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
76 !tb[RDMA_NLDEV_ATTR_RES_SUMMARY])
77 return MNL_CB_ERROR;
78
79 idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
80 name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
81 if (rd->json_output) {
82 jsonw_uint_field(rd->jw, "ifindex", idx);
83 jsonw_string_field(rd->jw, "ifname", name);
84 } else {
85 pr_out("%u: %s: ", idx, name);
86 }
87
88 res_print_summary(rd, tb);
89
90 if (!rd->json_output)
91 pr_out("\n");
92 return MNL_CB_OK;
93 }
94
95 int _res_send_msg(struct rd *rd, uint32_t command, mnl_cb_t callback)
96 {
97 uint32_t flags = NLM_F_REQUEST | NLM_F_ACK;
98 uint32_t seq;
99 int ret;
100
101 if (command != RDMA_NLDEV_CMD_RES_GET)
102 flags |= NLM_F_DUMP;
103
104 rd_prepare_msg(rd, command, &seq, flags);
105 mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx);
106 if (rd->port_idx)
107 mnl_attr_put_u32(rd->nlh,
108 RDMA_NLDEV_ATTR_PORT_INDEX, rd->port_idx);
109
110 ret = rd_send_msg(rd);
111 if (ret)
112 return ret;
113
114 if (rd->json_output)
115 jsonw_start_object(rd->jw);
116 ret = rd_recv_msg(rd, callback, rd, seq);
117 if (rd->json_output)
118 jsonw_end_object(rd->jw);
119 return ret;
120 }
121
122 static const char *path_mig_to_str(uint8_t idx)
123 {
124 static const char * const path_mig_str[] = { "MIGRATED",
125 "REARM", "ARMED" };
126
127 if (idx < ARRAY_SIZE(path_mig_str))
128 return path_mig_str[idx];
129 return "UNKNOWN";
130 }
131
132 static const char *qp_states_to_str(uint8_t idx)
133 {
134 static const char * const qp_states_str[] = { "RESET", "INIT",
135 "RTR", "RTS", "SQD",
136 "SQE", "ERR" };
137
138 if (idx < ARRAY_SIZE(qp_states_str))
139 return qp_states_str[idx];
140 return "UNKNOWN";
141 }
142
143 static const char *qp_types_to_str(uint8_t idx)
144 {
145 static const char * const qp_types_str[] = { "SMI", "GSI", "RC",
146 "UC", "UD", "RAW_IPV6",
147 "RAW_ETHERTYPE",
148 "UNKNOWN", "RAW_PACKET",
149 "XRC_INI", "XRC_TGT" };
150
151 if (idx < ARRAY_SIZE(qp_types_str))
152 return qp_types_str[idx];
153 return "UNKNOWN";
154 }
155
156 static void print_lqpn(struct rd *rd, uint32_t val)
157 {
158 if (rd->json_output)
159 jsonw_uint_field(rd->jw, "lqpn", val);
160 else
161 pr_out("lqpn %u ", val);
162 }
163
164 static void print_rqpn(struct rd *rd, uint32_t val, struct nlattr **nla_line)
165 {
166 if (!nla_line[RDMA_NLDEV_ATTR_RES_RQPN])
167 return;
168
169 if (rd->json_output)
170 jsonw_uint_field(rd->jw, "rqpn", val);
171 else
172 pr_out("rqpn %u ", val);
173 }
174
175 static void print_type(struct rd *rd, uint32_t val)
176 {
177 if (rd->json_output)
178 jsonw_string_field(rd->jw, "type",
179 qp_types_to_str(val));
180 else
181 pr_out("type %s ", qp_types_to_str(val));
182 }
183
184 static void print_state(struct rd *rd, uint32_t val)
185 {
186 if (rd->json_output)
187 jsonw_string_field(rd->jw, "state",
188 qp_states_to_str(val));
189 else
190 pr_out("state %s ", qp_states_to_str(val));
191 }
192
193 static void print_rqpsn(struct rd *rd, uint32_t val, struct nlattr **nla_line)
194 {
195 if (!nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN])
196 return;
197
198 if (rd->json_output)
199 jsonw_uint_field(rd->jw, "rq-psn", val);
200 else
201 pr_out("rq-psn %u ", val);
202 }
203
204 static void print_sqpsn(struct rd *rd, uint32_t val)
205 {
206 if (rd->json_output)
207 jsonw_uint_field(rd->jw, "sq-psn", val);
208 else
209 pr_out("sq-psn %u ", val);
210 }
211
212 static void print_pathmig(struct rd *rd, uint32_t val,
213 struct nlattr **nla_line)
214 {
215 if (!nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE])
216 return;
217
218 if (rd->json_output)
219 jsonw_string_field(rd->jw,
220 "path-mig-state",
221 path_mig_to_str(val));
222 else
223 pr_out("path-mig-state %s ", path_mig_to_str(val));
224 }
225
226 void print_pid(struct rd *rd, uint32_t val)
227 {
228 if (rd->json_output)
229 jsonw_uint_field(rd->jw, "pid", val);
230 else
231 pr_out("pid %u ", val);
232 }
233
234 void print_comm(struct rd *rd, const char *str, struct nlattr **nla_line)
235 {
236 char tmp[18];
237
238 if (rd->json_output) {
239 /* Don't beatify output in JSON format */
240 jsonw_string_field(rd->jw, "comm", str);
241 return;
242 }
243
244 if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
245 snprintf(tmp, sizeof(tmp), "%s", str);
246 else
247 snprintf(tmp, sizeof(tmp), "[%s]", str);
248
249 pr_out("comm %s ", tmp);
250 }
251
252 void print_dev(struct rd *rd, uint32_t idx, const char *name)
253 {
254 if (rd->json_output) {
255 jsonw_uint_field(rd->jw, "ifindex", idx);
256 jsonw_string_field(rd->jw, "ifname", name);
257 } else {
258 pr_out("dev %s ", name);
259 }
260 }
261
262 static void print_link(struct rd *rd, uint32_t idx, const char *name,
263 uint32_t port, struct nlattr **nla_line)
264 {
265 if (rd->json_output) {
266 jsonw_uint_field(rd->jw, "ifindex", idx);
267
268 if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
269 jsonw_uint_field(rd->jw, "port", port);
270
271 jsonw_string_field(rd->jw, "ifname", name);
272 } else {
273 if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
274 pr_out("link %s/%u ", name, port);
275 else
276 pr_out("link %s/- ", name);
277 }
278 }
279
280 char *get_task_name(uint32_t pid)
281 {
282 char *comm;
283 FILE *f;
284
285 if (asprintf(&comm, "/proc/%d/comm", pid) < 0)
286 return NULL;
287
288 f = fopen(comm, "r");
289 free(comm);
290 if (!f)
291 return NULL;
292
293 if (fscanf(f, "%ms\n", &comm) != 1)
294 comm = NULL;
295
296 fclose(f);
297
298 return comm;
299 }
300
301 void print_key(struct rd *rd, const char *name, uint64_t val)
302 {
303 if (rd->json_output)
304 jsonw_xint_field(rd->jw, name, val);
305 else
306 pr_out("%s 0x%" PRIx64 " ", name, val);
307 }
308
309 void res_print_uint(struct rd *rd, const char *name, uint64_t val)
310 {
311 if (rd->json_output)
312 jsonw_uint_field(rd->jw, name, val);
313 else
314 pr_out("%s %" PRIu64 " ", name, val);
315 }
316
317 static int res_qp_parse_cb(const struct nlmsghdr *nlh, void *data)
318 {
319 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
320 struct nlattr *nla_table, *nla_entry;
321 struct rd *rd = data;
322 const char *name;
323 uint32_t idx;
324
325 mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
326 if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
327 !tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
328 !tb[RDMA_NLDEV_ATTR_RES_QP])
329 return MNL_CB_ERROR;
330
331 name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
332 idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
333 nla_table = tb[RDMA_NLDEV_ATTR_RES_QP];
334
335 mnl_attr_for_each_nested(nla_entry, nla_table) {
336 struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
337 uint32_t lqpn, rqpn = 0, rq_psn = 0, sq_psn;
338 uint8_t type, state, path_mig_state = 0;
339 uint32_t port = 0, pid = 0;
340 uint32_t pdn = 0;
341 char *comm = NULL;
342 int err;
343
344 err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
345 if (err != MNL_CB_OK)
346 return MNL_CB_ERROR;
347
348 if (!nla_line[RDMA_NLDEV_ATTR_RES_LQPN] ||
349 !nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN] ||
350 !nla_line[RDMA_NLDEV_ATTR_RES_TYPE] ||
351 !nla_line[RDMA_NLDEV_ATTR_RES_STATE] ||
352 (!nla_line[RDMA_NLDEV_ATTR_RES_PID] &&
353 !nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) {
354 return MNL_CB_ERROR;
355 }
356
357 if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
358 port = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]);
359
360 if (port != rd->port_idx)
361 continue;
362
363 lqpn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_LQPN]);
364 if (rd_check_is_filtered(rd, "lqpn", lqpn))
365 continue;
366
367 if (nla_line[RDMA_NLDEV_ATTR_RES_PDN])
368 pdn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PDN]);
369 if (rd_check_is_filtered(rd, "pdn", pdn))
370 continue;
371
372 if (nla_line[RDMA_NLDEV_ATTR_RES_RQPN]) {
373 rqpn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQPN]);
374 if (rd_check_is_filtered(rd, "rqpn", rqpn))
375 continue;
376 } else {
377 if (rd_check_is_key_exist(rd, "rqpn"))
378 continue;
379 }
380
381 if (nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]) {
382 rq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_RQ_PSN]);
383 if (rd_check_is_filtered(rd, "rq-psn", rq_psn))
384 continue;
385 } else {
386 if (rd_check_is_key_exist(rd, "rq-psn"))
387 continue;
388 }
389
390 sq_psn = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_SQ_PSN]);
391 if (rd_check_is_filtered(rd, "sq-psn", sq_psn))
392 continue;
393
394 if (nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]) {
395 path_mig_state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE]);
396 if (rd_check_is_string_filtered(rd, "path-mig-state", path_mig_to_str(path_mig_state)))
397 continue;
398 } else {
399 if (rd_check_is_key_exist(rd, "path-mig-state"))
400 continue;
401 }
402
403 type = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_TYPE]);
404 if (rd_check_is_string_filtered(rd, "type", qp_types_to_str(type)))
405 continue;
406
407 state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_STATE]);
408 if (rd_check_is_string_filtered(rd, "state", qp_states_to_str(state)))
409 continue;
410
411 if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) {
412 pid = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PID]);
413 comm = get_task_name(pid);
414 }
415
416 if (rd_check_is_filtered(rd, "pid", pid)) {
417 free(comm);
418 continue;
419 }
420
421 if (nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])
422 /* discard const from mnl_attr_get_str */
423 comm = (char *)mnl_attr_get_str(nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]);
424
425 if (rd->json_output)
426 jsonw_start_array(rd->jw);
427
428 print_link(rd, idx, name, port, nla_line);
429
430 print_lqpn(rd, lqpn);
431 if (nla_line[RDMA_NLDEV_ATTR_RES_PDN])
432 res_print_uint(rd, "pdn", pdn);
433 print_rqpn(rd, rqpn, nla_line);
434
435 print_type(rd, type);
436 print_state(rd, state);
437
438 print_rqpsn(rd, rq_psn, nla_line);
439 print_sqpsn(rd, sq_psn);
440
441 print_pathmig(rd, path_mig_state, nla_line);
442 print_pid(rd, pid);
443 print_comm(rd, comm, nla_line);
444
445 if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
446 free(comm);
447
448 print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]);
449 newline(rd);
450 }
451 return MNL_CB_OK;
452 }
453
454 static void print_qp_type(struct rd *rd, uint32_t val)
455 {
456 if (rd->json_output)
457 jsonw_string_field(rd->jw, "qp-type",
458 qp_types_to_str(val));
459 else
460 pr_out("qp-type %s ", qp_types_to_str(val));
461 }
462
463 static const char *cm_id_state_to_str(uint8_t idx)
464 {
465 static const char * const cm_id_states_str[] = {
466 "IDLE", "ADDR_QUERY", "ADDR_RESOLVED", "ROUTE_QUERY",
467 "ROUTE_RESOLVED", "CONNECT", "DISCONNECT", "ADDR_BOUND",
468 "LISTEN", "DEVICE_REMOVAL", "DESTROYING" };
469
470 if (idx < ARRAY_SIZE(cm_id_states_str))
471 return cm_id_states_str[idx];
472 return "UNKNOWN";
473 }
474
475 static const char *cm_id_ps_to_str(uint32_t ps)
476 {
477 switch (ps) {
478 case RDMA_PS_IPOIB:
479 return "IPoIB";
480 case RDMA_PS_IB:
481 return "IPoIB";
482 case RDMA_PS_TCP:
483 return "TCP";
484 case RDMA_PS_UDP:
485 return "UDP";
486 default:
487 return "---";
488 }
489 }
490
491 static void print_cm_id_state(struct rd *rd, uint8_t state)
492 {
493 if (rd->json_output) {
494 jsonw_string_field(rd->jw, "state", cm_id_state_to_str(state));
495 return;
496 }
497 pr_out("state %s ", cm_id_state_to_str(state));
498 }
499
500 static void print_ps(struct rd *rd, uint32_t ps)
501 {
502 if (rd->json_output) {
503 jsonw_string_field(rd->jw, "ps", cm_id_ps_to_str(ps));
504 return;
505 }
506 pr_out("ps %s ", cm_id_ps_to_str(ps));
507 }
508
509 static void print_ipaddr(struct rd *rd, const char *key, char *addrstr,
510 uint16_t port)
511 {
512 if (rd->json_output) {
513 int name_size = INET6_ADDRSTRLEN+strlen(":65535");
514 char json_name[name_size];
515
516 snprintf(json_name, name_size, "%s:%u", addrstr, port);
517 jsonw_string_field(rd->jw, key, json_name);
518 return;
519 }
520 pr_out("%s %s:%u ", key, addrstr, port);
521 }
522
523 static int ss_ntop(struct nlattr *nla_line, char *addr_str, uint16_t *port)
524 {
525 struct __kernel_sockaddr_storage *addr;
526
527 addr = (struct __kernel_sockaddr_storage *)
528 mnl_attr_get_payload(nla_line);
529 switch (addr->ss_family) {
530 case AF_INET: {
531 struct sockaddr_in *sin = (struct sockaddr_in *)addr;
532
533 if (!inet_ntop(AF_INET, (const void *)&sin->sin_addr, addr_str,
534 INET6_ADDRSTRLEN))
535 return -EINVAL;
536 *port = ntohs(sin->sin_port);
537 break;
538 }
539 case AF_INET6: {
540 struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;
541
542 if (!inet_ntop(AF_INET6, (const void *)&sin6->sin6_addr,
543 addr_str, INET6_ADDRSTRLEN))
544 return -EINVAL;
545 *port = ntohs(sin6->sin6_port);
546 break;
547 }
548 default:
549 return -EINVAL;
550 }
551 return 0;
552 }
553
554 static int res_cm_id_parse_cb(const struct nlmsghdr *nlh, void *data)
555 {
556 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
557 struct nlattr *nla_table, *nla_entry;
558 struct rd *rd = data;
559 const char *name;
560 int idx;
561
562 mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
563 if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
564 !tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
565 !tb[RDMA_NLDEV_ATTR_RES_CM_ID])
566 return MNL_CB_ERROR;
567
568 name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
569 idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
570 nla_table = tb[RDMA_NLDEV_ATTR_RES_CM_ID];
571 mnl_attr_for_each_nested(nla_entry, nla_table) {
572 struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
573 char src_addr_str[INET6_ADDRSTRLEN];
574 char dst_addr_str[INET6_ADDRSTRLEN];
575 uint16_t src_port, dst_port;
576 uint32_t port = 0, pid = 0;
577 uint8_t type = 0, state;
578 uint32_t lqpn = 0, ps;
579 uint32_t cm_idn = 0;
580 char *comm = NULL;
581 int err;
582
583 err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
584 if (err != MNL_CB_OK)
585 return -EINVAL;
586
587 if (!nla_line[RDMA_NLDEV_ATTR_RES_STATE] ||
588 !nla_line[RDMA_NLDEV_ATTR_RES_PS] ||
589 (!nla_line[RDMA_NLDEV_ATTR_RES_PID] &&
590 !nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) {
591 return MNL_CB_ERROR;
592 }
593
594 if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX])
595 port = mnl_attr_get_u32(
596 nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]);
597
598 if (port && port != rd->port_idx)
599 continue;
600
601 if (nla_line[RDMA_NLDEV_ATTR_RES_LQPN]) {
602 lqpn = mnl_attr_get_u32(
603 nla_line[RDMA_NLDEV_ATTR_RES_LQPN]);
604 if (rd_check_is_filtered(rd, "lqpn", lqpn))
605 continue;
606 }
607 if (nla_line[RDMA_NLDEV_ATTR_RES_TYPE]) {
608 type = mnl_attr_get_u8(
609 nla_line[RDMA_NLDEV_ATTR_RES_TYPE]);
610 if (rd_check_is_string_filtered(rd, "qp-type",
611 qp_types_to_str(type)))
612 continue;
613 }
614
615 ps = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_PS]);
616 if (rd_check_is_string_filtered(rd, "ps", cm_id_ps_to_str(ps)))
617 continue;
618
619 state = mnl_attr_get_u8(nla_line[RDMA_NLDEV_ATTR_RES_STATE]);
620 if (rd_check_is_string_filtered(rd, "state",
621 cm_id_state_to_str(state)))
622 continue;
623
624 if (nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR]) {
625 if (ss_ntop(nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR],
626 src_addr_str, &src_port))
627 continue;
628 if (rd_check_is_string_filtered(rd, "src-addr",
629 src_addr_str))
630 continue;
631 if (rd_check_is_filtered(rd, "src-port", src_port))
632 continue;
633 }
634
635 if (nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR]) {
636 if (ss_ntop(nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR],
637 dst_addr_str, &dst_port))
638 continue;
639 if (rd_check_is_string_filtered(rd, "dst-addr",
640 dst_addr_str))
641 continue;
642 if (rd_check_is_filtered(rd, "dst-port", dst_port))
643 continue;
644 }
645
646 if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) {
647 pid = mnl_attr_get_u32(
648 nla_line[RDMA_NLDEV_ATTR_RES_PID]);
649 comm = get_task_name(pid);
650 }
651
652 if (rd_check_is_filtered(rd, "pid", pid)) {
653 free(comm);
654 continue;
655 }
656
657 if (nla_line[RDMA_NLDEV_ATTR_RES_CM_IDN])
658 cm_idn = mnl_attr_get_u32(
659 nla_line[RDMA_NLDEV_ATTR_RES_CM_IDN]);
660 if (rd_check_is_filtered(rd, "cm-idn", cm_idn))
661 continue;
662
663 if (nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]) {
664 /* discard const from mnl_attr_get_str */
665 comm = (char *)mnl_attr_get_str(
666 nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]);
667 }
668
669 if (rd->json_output)
670 jsonw_start_array(rd->jw);
671
672 print_link(rd, idx, name, port, nla_line);
673 if (nla_line[RDMA_NLDEV_ATTR_RES_LQPN])
674 print_lqpn(rd, lqpn);
675 if (nla_line[RDMA_NLDEV_ATTR_RES_TYPE])
676 print_qp_type(rd, type);
677 print_cm_id_state(rd, state);
678 print_ps(rd, ps);
679 print_pid(rd, pid);
680 print_comm(rd, comm, nla_line);
681 if (nla_line[RDMA_NLDEV_ATTR_RES_CM_IDN])
682 res_print_uint(rd, "cm-idn", cm_idn);
683
684 if (nla_line[RDMA_NLDEV_ATTR_RES_SRC_ADDR])
685 print_ipaddr(rd, "src-addr", src_addr_str, src_port);
686 if (nla_line[RDMA_NLDEV_ATTR_RES_DST_ADDR])
687 print_ipaddr(rd, "dst-addr", dst_addr_str, dst_port);
688
689 if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
690 free(comm);
691
692 print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]);
693 newline(rd);
694 }
695 return MNL_CB_OK;
696 }
697
698 static void print_cqe(struct rd *rd, uint32_t val)
699 {
700 if (rd->json_output)
701 jsonw_uint_field(rd->jw, "cqe", val);
702 else
703 pr_out("cqe %u ", val);
704 }
705
706 void print_users(struct rd *rd, uint64_t val)
707 {
708 if (rd->json_output)
709 jsonw_uint_field(rd->jw, "users", val);
710 else
711 pr_out("users %" PRIu64 " ", val);
712 }
713
714 static const char *poll_ctx_to_str(uint8_t idx)
715 {
716 static const char * const cm_id_states_str[] = {
717 "DIRECT", "SOFTIRQ", "WORKQUEUE", "UNBOUND_WORKQUEUE"};
718
719 if (idx < ARRAY_SIZE(cm_id_states_str))
720 return cm_id_states_str[idx];
721 return "UNKNOWN";
722 }
723
724 static void print_poll_ctx(struct rd *rd, uint8_t poll_ctx)
725 {
726 if (rd->json_output) {
727 jsonw_string_field(rd->jw, "poll-ctx",
728 poll_ctx_to_str(poll_ctx));
729 return;
730 }
731 pr_out("poll-ctx %s ", poll_ctx_to_str(poll_ctx));
732 }
733
734 static int res_cq_parse_cb(const struct nlmsghdr *nlh, void *data)
735 {
736 struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {};
737 struct nlattr *nla_table, *nla_entry;
738 struct rd *rd = data;
739 const char *name;
740 uint32_t idx;
741
742 mnl_attr_parse(nlh, 0, rd_attr_cb, tb);
743 if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] ||
744 !tb[RDMA_NLDEV_ATTR_DEV_NAME] ||
745 !tb[RDMA_NLDEV_ATTR_RES_CQ])
746 return MNL_CB_ERROR;
747
748 name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]);
749 idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]);
750 nla_table = tb[RDMA_NLDEV_ATTR_RES_CQ];
751
752 mnl_attr_for_each_nested(nla_entry, nla_table) {
753 struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {};
754 char *comm = NULL;
755 uint32_t pid = 0;
756 uint8_t poll_ctx = 0;
757 uint32_t ctxn = 0;
758 uint32_t cqn = 0;
759 uint64_t users;
760 uint32_t cqe;
761 int err;
762
763 err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line);
764 if (err != MNL_CB_OK)
765 return MNL_CB_ERROR;
766
767 if (!nla_line[RDMA_NLDEV_ATTR_RES_CQE] ||
768 !nla_line[RDMA_NLDEV_ATTR_RES_USECNT] ||
769 (!nla_line[RDMA_NLDEV_ATTR_RES_PID] &&
770 !nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])) {
771 return MNL_CB_ERROR;
772 }
773
774 cqe = mnl_attr_get_u32(nla_line[RDMA_NLDEV_ATTR_RES_CQE]);
775
776 users = mnl_attr_get_u64(nla_line[RDMA_NLDEV_ATTR_RES_USECNT]);
777 if (rd_check_is_filtered(rd, "users", users))
778 continue;
779
780 if (nla_line[RDMA_NLDEV_ATTR_RES_POLL_CTX]) {
781 poll_ctx = mnl_attr_get_u8(
782 nla_line[RDMA_NLDEV_ATTR_RES_POLL_CTX]);
783 if (rd_check_is_string_filtered(rd, "poll-ctx",
784 poll_ctx_to_str(poll_ctx)))
785 continue;
786 }
787
788 if (nla_line[RDMA_NLDEV_ATTR_RES_PID]) {
789 pid = mnl_attr_get_u32(
790 nla_line[RDMA_NLDEV_ATTR_RES_PID]);
791 comm = get_task_name(pid);
792 }
793
794 if (rd_check_is_filtered(rd, "pid", pid)) {
795 free(comm);
796 continue;
797 }
798
799 if (nla_line[RDMA_NLDEV_ATTR_RES_CQN])
800 cqn = mnl_attr_get_u32(
801 nla_line[RDMA_NLDEV_ATTR_RES_CQN]);
802 if (rd_check_is_filtered(rd, "cqn", cqn))
803 continue;
804
805 if (nla_line[RDMA_NLDEV_ATTR_RES_CTXN])
806 ctxn = mnl_attr_get_u32(
807 nla_line[RDMA_NLDEV_ATTR_RES_CTXN]);
808 if (rd_check_is_filtered(rd, "ctxn", ctxn))
809 continue;
810
811 if (nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME])
812 /* discard const from mnl_attr_get_str */
813 comm = (char *)mnl_attr_get_str(
814 nla_line[RDMA_NLDEV_ATTR_RES_KERN_NAME]);
815
816 if (rd->json_output)
817 jsonw_start_array(rd->jw);
818
819 print_dev(rd, idx, name);
820 print_cqe(rd, cqe);
821 print_users(rd, users);
822 if (nla_line[RDMA_NLDEV_ATTR_RES_POLL_CTX])
823 print_poll_ctx(rd, poll_ctx);
824 print_pid(rd, pid);
825 print_comm(rd, comm, nla_line);
826
827 if (nla_line[RDMA_NLDEV_ATTR_RES_CQN])
828 res_print_uint(rd, "cqn", cqn);
829 if (nla_line[RDMA_NLDEV_ATTR_RES_CTXN])
830 res_print_uint(rd, "ctxn", ctxn);
831
832 if (nla_line[RDMA_NLDEV_ATTR_RES_PID])
833 free(comm);
834
835 print_driver_table(rd, nla_line[RDMA_NLDEV_ATTR_DRIVER]);
836 newline(rd);
837 }
838 return MNL_CB_OK;
839 }
840
841 RES_FUNC(res_no_args, RDMA_NLDEV_CMD_RES_GET, NULL, true);
842
843 static const struct
844 filters qp_valid_filters[MAX_NUMBER_OF_FILTERS] = {
845 { .name = "link", .is_number = false },
846 { .name = "lqpn", .is_number = true },
847 { .name = "rqpn", .is_number = true },
848 { .name = "pid", .is_number = true },
849 { .name = "sq-psn", .is_number = true },
850 { .name = "rq-psn", .is_number = true },
851 { .name = "type", .is_number = false },
852 { .name = "path-mig-state", .is_number = false },
853 { .name = "state", .is_number = false },
854 { .name = "pdn", .is_number = true },
855 };
856
857 RES_FUNC(res_qp, RDMA_NLDEV_CMD_RES_QP_GET, qp_valid_filters, false);
858
859 static const
860 struct filters cm_id_valid_filters[MAX_NUMBER_OF_FILTERS] = {
861 { .name = "link", .is_number = false },
862 { .name = "lqpn", .is_number = true },
863 { .name = "qp-type", .is_number = false },
864 { .name = "state", .is_number = false },
865 { .name = "ps", .is_number = false },
866 { .name = "dev-type", .is_number = false },
867 { .name = "transport-type", .is_number = false },
868 { .name = "pid", .is_number = true },
869 { .name = "src-addr", .is_number = false },
870 { .name = "src-port", .is_number = true },
871 { .name = "dst-addr", .is_number = false },
872 { .name = "dst-port", .is_number = true },
873 { .name = "cm-idn", .is_number = true }
874 };
875
876 RES_FUNC(res_cm_id, RDMA_NLDEV_CMD_RES_CM_ID_GET, cm_id_valid_filters, false);
877
878 static const
879 struct filters cq_valid_filters[MAX_NUMBER_OF_FILTERS] = {
880 { .name = "dev", .is_number = false },
881 { .name = "users", .is_number = true },
882 { .name = "poll-ctx", .is_number = false },
883 { .name = "pid", .is_number = true },
884 { .name = "cqn", .is_number = true },
885 { .name = "ctxn", .is_number = true }
886 };
887
888 RES_FUNC(res_cq, RDMA_NLDEV_CMD_RES_CQ_GET, cq_valid_filters, true);
889
890 static int res_show(struct rd *rd)
891 {
892 const struct rd_cmd cmds[] = {
893 { NULL, res_no_args },
894 { "qp", res_qp },
895 { "cm_id", res_cm_id },
896 { "cq", res_cq },
897 { "mr", res_mr },
898 { "pd", res_pd },
899 { 0 }
900 };
901
902 /*
903 * Special case to support "rdma res show DEV_NAME"
904 */
905 if (rd_argc(rd) == 1 && dev_map_lookup(rd, false))
906 return rd_exec_dev(rd, _res_no_args);
907
908 return rd_exec_cmd(rd, cmds, "parameter");
909 }
910
911 int cmd_res(struct rd *rd)
912 {
913 const struct rd_cmd cmds[] = {
914 { NULL, res_show },
915 { "show", res_show },
916 { "list", res_show },
917 { "help", res_help },
918 { 0 }
919 };
920
921 return rd_exec_cmd(rd, cmds, "resource command");
922 }
Upstream mirror of iproute2