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.
9 * Authors: Leon Romanovsky <leonro@mellanox.com>
15 static int res_help(struct rd
*rd
)
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");
33 static int res_print_summary(struct rd
*rd
, struct nlattr
**tb
)
35 struct nlattr
*nla_table
= tb
[RDMA_NLDEV_ATTR_RES_SUMMARY
];
36 struct nlattr
*nla_entry
;
41 mnl_attr_for_each_nested(nla_entry
, nla_table
) {
42 struct nlattr
*nla_line
[RDMA_NLDEV_ATTR_MAX
] = {};
45 err
= mnl_attr_parse_nested(nla_entry
, rd_attr_cb
, nla_line
);
49 if (!nla_line
[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME
] ||
50 !nla_line
[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR
]) {
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
);
60 pr_out("%s %"PRId64
" ", name
, curr
);
66 static int res_no_args_parse_cb(const struct nlmsghdr
*nlh
, void *data
)
68 struct nlattr
*tb
[RDMA_NLDEV_ATTR_MAX
] = {};
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
])
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
);
85 pr_out("%u: %s: ", idx
, name
);
88 res_print_summary(rd
, tb
);
95 int _res_send_msg(struct rd
*rd
, uint32_t command
, mnl_cb_t callback
)
97 uint32_t flags
= NLM_F_REQUEST
| NLM_F_ACK
;
101 if (command
!= RDMA_NLDEV_CMD_RES_GET
)
104 rd_prepare_msg(rd
, command
, &seq
, flags
);
105 mnl_attr_put_u32(rd
->nlh
, RDMA_NLDEV_ATTR_DEV_INDEX
, rd
->dev_idx
);
107 mnl_attr_put_u32(rd
->nlh
,
108 RDMA_NLDEV_ATTR_PORT_INDEX
, rd
->port_idx
);
110 ret
= rd_send_msg(rd
);
115 jsonw_start_object(rd
->jw
);
116 ret
= rd_recv_msg(rd
, callback
, rd
, seq
);
118 jsonw_end_object(rd
->jw
);
122 static const char *path_mig_to_str(uint8_t idx
)
124 static const char * const path_mig_str
[] = { "MIGRATED",
127 if (idx
< ARRAY_SIZE(path_mig_str
))
128 return path_mig_str
[idx
];
132 static const char *qp_states_to_str(uint8_t idx
)
134 static const char * const qp_states_str
[] = { "RESET", "INIT",
138 if (idx
< ARRAY_SIZE(qp_states_str
))
139 return qp_states_str
[idx
];
143 static const char *qp_types_to_str(uint8_t idx
)
145 static const char * const qp_types_str
[] = { "SMI", "GSI", "RC",
146 "UC", "UD", "RAW_IPV6",
148 "UNKNOWN", "RAW_PACKET",
149 "XRC_INI", "XRC_TGT" };
151 if (idx
< ARRAY_SIZE(qp_types_str
))
152 return qp_types_str
[idx
];
156 static void print_lqpn(struct rd
*rd
, uint32_t val
)
159 jsonw_uint_field(rd
->jw
, "lqpn", val
);
161 pr_out("lqpn %u ", val
);
164 static void print_rqpn(struct rd
*rd
, uint32_t val
, struct nlattr
**nla_line
)
166 if (!nla_line
[RDMA_NLDEV_ATTR_RES_RQPN
])
170 jsonw_uint_field(rd
->jw
, "rqpn", val
);
172 pr_out("rqpn %u ", val
);
175 static void print_type(struct rd
*rd
, uint32_t val
)
178 jsonw_string_field(rd
->jw
, "type",
179 qp_types_to_str(val
));
181 pr_out("type %s ", qp_types_to_str(val
));
184 static void print_state(struct rd
*rd
, uint32_t val
)
187 jsonw_string_field(rd
->jw
, "state",
188 qp_states_to_str(val
));
190 pr_out("state %s ", qp_states_to_str(val
));
193 static void print_rqpsn(struct rd
*rd
, uint32_t val
, struct nlattr
**nla_line
)
195 if (!nla_line
[RDMA_NLDEV_ATTR_RES_RQ_PSN
])
199 jsonw_uint_field(rd
->jw
, "rq-psn", val
);
201 pr_out("rq-psn %u ", val
);
204 static void print_sqpsn(struct rd
*rd
, uint32_t val
)
207 jsonw_uint_field(rd
->jw
, "sq-psn", val
);
209 pr_out("sq-psn %u ", val
);
212 static void print_pathmig(struct rd
*rd
, uint32_t val
,
213 struct nlattr
**nla_line
)
215 if (!nla_line
[RDMA_NLDEV_ATTR_RES_PATH_MIG_STATE
])
219 jsonw_string_field(rd
->jw
,
221 path_mig_to_str(val
));
223 pr_out("path-mig-state %s ", path_mig_to_str(val
));
226 void print_pid(struct rd
*rd
, uint32_t val
)
229 jsonw_uint_field(rd
->jw
, "pid", val
);
231 pr_out("pid %u ", val
);
234 void print_comm(struct rd
*rd
, const char *str
, struct nlattr
**nla_line
)
238 if (rd
->json_output
) {
239 /* Don't beatify output in JSON format */
240 jsonw_string_field(rd
->jw
, "comm", str
);
244 if (nla_line
[RDMA_NLDEV_ATTR_RES_PID
])
245 snprintf(tmp
, sizeof(tmp
), "%s", str
);
247 snprintf(tmp
, sizeof(tmp
), "[%s]", str
);
249 pr_out("comm %s ", tmp
);
252 void print_dev(struct rd
*rd
, uint32_t idx
, const char *name
)
254 if (rd
->json_output
) {
255 jsonw_uint_field(rd
->jw
, "ifindex", idx
);
256 jsonw_string_field(rd
->jw
, "ifname", name
);
258 pr_out("dev %s ", name
);
262 static void print_link(struct rd
*rd
, uint32_t idx
, const char *name
,
263 uint32_t port
, struct nlattr
**nla_line
)
265 if (rd
->json_output
) {
266 jsonw_uint_field(rd
->jw
, "ifindex", idx
);
268 if (nla_line
[RDMA_NLDEV_ATTR_PORT_INDEX
])
269 jsonw_uint_field(rd
->jw
, "port", port
);
271 jsonw_string_field(rd
->jw
, "ifname", name
);
273 if (nla_line
[RDMA_NLDEV_ATTR_PORT_INDEX
])
274 pr_out("link %s/%u ", name
, port
);
276 pr_out("link %s/- ", name
);
280 char *get_task_name(uint32_t pid
)
285 if (asprintf(&comm
, "/proc/%d/comm", pid
) < 0)
288 f
= fopen(comm
, "r");
293 if (fscanf(f
, "%ms\n", &comm
) != 1)
301 void print_key(struct rd
*rd
, const char *name
, uint64_t val
)
304 jsonw_xint_field(rd
->jw
, name
, val
);
306 pr_out("%s 0x%" PRIx64
" ", name
, val
);
309 void res_print_uint(struct rd
*rd
, const char *name
, uint64_t val
)
312 jsonw_uint_field(rd
->jw
, name
, val
);
314 pr_out("%s %" PRIu64
" ", name
, val
);
317 static int res_qp_parse_cb(const struct nlmsghdr
*nlh
, void *data
)
319 struct nlattr
*tb
[RDMA_NLDEV_ATTR_MAX
] = {};
320 struct nlattr
*nla_table
, *nla_entry
;
321 struct rd
*rd
= data
;
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
])
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
];
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;
344 err
= mnl_attr_parse_nested(nla_entry
, rd_attr_cb
, nla_line
);
345 if (err
!= MNL_CB_OK
)
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
])) {
357 if (nla_line
[RDMA_NLDEV_ATTR_PORT_INDEX
])
358 port
= mnl_attr_get_u32(nla_line
[RDMA_NLDEV_ATTR_PORT_INDEX
]);
360 if (port
!= rd
->port_idx
)
363 lqpn
= mnl_attr_get_u32(nla_line
[RDMA_NLDEV_ATTR_RES_LQPN
]);
364 if (rd_check_is_filtered(rd
, "lqpn", lqpn
))
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
))
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
))
377 if (rd_check_is_key_exist(rd
, "rqpn"))
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
))
386 if (rd_check_is_key_exist(rd
, "rq-psn"))
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
))
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
)))
399 if (rd_check_is_key_exist(rd
, "path-mig-state"))
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
)))
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
)))
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
);
416 if (rd_check_is_filtered(rd
, "pid", pid
)) {
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
]);
426 jsonw_start_array(rd
->jw
);
428 print_link(rd
, idx
, name
, port
, nla_line
);
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
);
435 print_type(rd
, type
);
436 print_state(rd
, state
);
438 print_rqpsn(rd
, rq_psn
, nla_line
);
439 print_sqpsn(rd
, sq_psn
);
441 print_pathmig(rd
, path_mig_state
, nla_line
);
443 print_comm(rd
, comm
, nla_line
);
445 if (nla_line
[RDMA_NLDEV_ATTR_RES_PID
])
448 print_driver_table(rd
, nla_line
[RDMA_NLDEV_ATTR_DRIVER
]);
454 static void print_qp_type(struct rd
*rd
, uint32_t val
)
457 jsonw_string_field(rd
->jw
, "qp-type",
458 qp_types_to_str(val
));
460 pr_out("qp-type %s ", qp_types_to_str(val
));
463 static const char *cm_id_state_to_str(uint8_t idx
)
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" };
470 if (idx
< ARRAY_SIZE(cm_id_states_str
))
471 return cm_id_states_str
[idx
];
475 static const char *cm_id_ps_to_str(uint32_t ps
)
491 static void print_cm_id_state(struct rd
*rd
, uint8_t state
)
493 if (rd
->json_output
) {
494 jsonw_string_field(rd
->jw
, "state", cm_id_state_to_str(state
));
497 pr_out("state %s ", cm_id_state_to_str(state
));
500 static void print_ps(struct rd
*rd
, uint32_t ps
)
502 if (rd
->json_output
) {
503 jsonw_string_field(rd
->jw
, "ps", cm_id_ps_to_str(ps
));
506 pr_out("ps %s ", cm_id_ps_to_str(ps
));
509 static void print_ipaddr(struct rd
*rd
, const char *key
, char *addrstr
,
512 if (rd
->json_output
) {
513 int name_size
= INET6_ADDRSTRLEN
+strlen(":65535");
514 char json_name
[name_size
];
516 snprintf(json_name
, name_size
, "%s:%u", addrstr
, port
);
517 jsonw_string_field(rd
->jw
, key
, json_name
);
520 pr_out("%s %s:%u ", key
, addrstr
, port
);
523 static int ss_ntop(struct nlattr
*nla_line
, char *addr_str
, uint16_t *port
)
525 struct __kernel_sockaddr_storage
*addr
;
527 addr
= (struct __kernel_sockaddr_storage
*)
528 mnl_attr_get_payload(nla_line
);
529 switch (addr
->ss_family
) {
531 struct sockaddr_in
*sin
= (struct sockaddr_in
*)addr
;
533 if (!inet_ntop(AF_INET
, (const void *)&sin
->sin_addr
, addr_str
,
536 *port
= ntohs(sin
->sin_port
);
540 struct sockaddr_in6
*sin6
= (struct sockaddr_in6
*)addr
;
542 if (!inet_ntop(AF_INET6
, (const void *)&sin6
->sin6_addr
,
543 addr_str
, INET6_ADDRSTRLEN
))
545 *port
= ntohs(sin6
->sin6_port
);
554 static int res_cm_id_parse_cb(const struct nlmsghdr
*nlh
, void *data
)
556 struct nlattr
*tb
[RDMA_NLDEV_ATTR_MAX
] = {};
557 struct nlattr
*nla_table
, *nla_entry
;
558 struct rd
*rd
= data
;
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
])
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
;
583 err
= mnl_attr_parse_nested(nla_entry
, rd_attr_cb
, nla_line
);
584 if (err
!= MNL_CB_OK
)
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
])) {
594 if (nla_line
[RDMA_NLDEV_ATTR_PORT_INDEX
])
595 port
= mnl_attr_get_u32(
596 nla_line
[RDMA_NLDEV_ATTR_PORT_INDEX
]);
598 if (port
&& port
!= rd
->port_idx
)
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
))
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
)))
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
)))
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
)))
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
))
628 if (rd_check_is_string_filtered(rd
, "src-addr",
631 if (rd_check_is_filtered(rd
, "src-port", src_port
))
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
))
639 if (rd_check_is_string_filtered(rd
, "dst-addr",
642 if (rd_check_is_filtered(rd
, "dst-port", dst_port
))
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
);
652 if (rd_check_is_filtered(rd
, "pid", pid
)) {
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
))
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
]);
670 jsonw_start_array(rd
->jw
);
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
);
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
);
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
);
689 if (nla_line
[RDMA_NLDEV_ATTR_RES_PID
])
692 print_driver_table(rd
, nla_line
[RDMA_NLDEV_ATTR_DRIVER
]);
698 void print_users(struct rd
*rd
, uint64_t val
)
701 jsonw_uint_field(rd
->jw
, "users", val
);
703 pr_out("users %" PRIu64
" ", val
);
706 RES_FUNC(res_no_args
, RDMA_NLDEV_CMD_RES_GET
, NULL
, true);
709 filters qp_valid_filters
[MAX_NUMBER_OF_FILTERS
] = {
710 { .name
= "link", .is_number
= false },
711 { .name
= "lqpn", .is_number
= true },
712 { .name
= "rqpn", .is_number
= true },
713 { .name
= "pid", .is_number
= true },
714 { .name
= "sq-psn", .is_number
= true },
715 { .name
= "rq-psn", .is_number
= true },
716 { .name
= "type", .is_number
= false },
717 { .name
= "path-mig-state", .is_number
= false },
718 { .name
= "state", .is_number
= false },
719 { .name
= "pdn", .is_number
= true },
722 RES_FUNC(res_qp
, RDMA_NLDEV_CMD_RES_QP_GET
, qp_valid_filters
, false);
725 struct filters cm_id_valid_filters
[MAX_NUMBER_OF_FILTERS
] = {
726 { .name
= "link", .is_number
= false },
727 { .name
= "lqpn", .is_number
= true },
728 { .name
= "qp-type", .is_number
= false },
729 { .name
= "state", .is_number
= false },
730 { .name
= "ps", .is_number
= false },
731 { .name
= "dev-type", .is_number
= false },
732 { .name
= "transport-type", .is_number
= false },
733 { .name
= "pid", .is_number
= true },
734 { .name
= "src-addr", .is_number
= false },
735 { .name
= "src-port", .is_number
= true },
736 { .name
= "dst-addr", .is_number
= false },
737 { .name
= "dst-port", .is_number
= true },
738 { .name
= "cm-idn", .is_number
= true }
741 RES_FUNC(res_cm_id
, RDMA_NLDEV_CMD_RES_CM_ID_GET
, cm_id_valid_filters
, false);
743 static int res_show(struct rd
*rd
)
745 const struct rd_cmd cmds
[] = {
746 { NULL
, res_no_args
},
748 { "cm_id", res_cm_id
},
756 * Special case to support "rdma res show DEV_NAME"
758 if (rd_argc(rd
) == 1 && dev_map_lookup(rd
, false))
759 return rd_exec_dev(rd
, _res_no_args
);
761 return rd_exec_cmd(rd
, cmds
, "parameter");
764 int cmd_res(struct rd
*rd
)
766 const struct rd_cmd cmds
[] = {
768 { "show", res_show
},
769 { "list", res_show
},
770 { "help", res_help
},
774 return rd_exec_cmd(rd
, cmds
, "resource command");