]>
Commit | Line | Data |
---|---|---|
1 | // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB | |
2 | /* | |
3 | * res.c RDMA tool | |
4 | * Authors: Leon Romanovsky <leonro@mellanox.com> | |
5 | */ | |
6 | ||
7 | #include "res.h" | |
8 | #include <inttypes.h> | |
9 | ||
10 | static int res_help(struct rd *rd) | |
11 | { | |
12 | pr_out("Usage: %s resource\n", rd->filename); | |
13 | pr_out(" resource show [DEV]\n"); | |
14 | pr_out(" resource show [qp|cm_id|pd|mr|cq]\n"); | |
15 | pr_out(" resource show qp link [DEV/PORT]\n"); | |
16 | pr_out(" resource show qp link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n"); | |
17 | pr_out(" resource show cm_id link [DEV/PORT]\n"); | |
18 | pr_out(" resource show cm_id link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n"); | |
19 | pr_out(" resource show cq link [DEV/PORT]\n"); | |
20 | pr_out(" resource show cq link [DEV/PORT] [FILTER-NAME FILTER-VALUE]\n"); | |
21 | pr_out(" resource show pd dev [DEV]\n"); | |
22 | pr_out(" resource show pd dev [DEV] [FILTER-NAME FILTER-VALUE]\n"); | |
23 | pr_out(" resource show mr dev [DEV]\n"); | |
24 | pr_out(" resource show mr dev [DEV] [FILTER-NAME FILTER-VALUE]\n"); | |
25 | return 0; | |
26 | } | |
27 | ||
28 | static int res_print_summary(struct rd *rd, struct nlattr **tb) | |
29 | { | |
30 | struct nlattr *nla_table = tb[RDMA_NLDEV_ATTR_RES_SUMMARY]; | |
31 | struct nlattr *nla_entry; | |
32 | const char *name; | |
33 | uint64_t curr; | |
34 | int err; | |
35 | ||
36 | mnl_attr_for_each_nested(nla_entry, nla_table) { | |
37 | struct nlattr *nla_line[RDMA_NLDEV_ATTR_MAX] = {}; | |
38 | ||
39 | err = mnl_attr_parse_nested(nla_entry, rd_attr_cb, nla_line); | |
40 | if (err != MNL_CB_OK) | |
41 | return -EINVAL; | |
42 | ||
43 | if (!nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME] || | |
44 | !nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]) { | |
45 | return -EINVAL; | |
46 | } | |
47 | ||
48 | name = mnl_attr_get_str(nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_NAME]); | |
49 | curr = mnl_attr_get_u64(nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]); | |
50 | res_print_uint( | |
51 | rd, name, curr, | |
52 | nla_line[RDMA_NLDEV_ATTR_RES_SUMMARY_ENTRY_CURR]); | |
53 | } | |
54 | return 0; | |
55 | } | |
56 | ||
57 | static int res_no_args_idx_parse_cb(const struct nlmsghdr *nlh, void *data) | |
58 | { | |
59 | return MNL_CB_OK; | |
60 | } | |
61 | ||
62 | static int res_no_args_parse_cb(const struct nlmsghdr *nlh, void *data) | |
63 | { | |
64 | struct nlattr *tb[RDMA_NLDEV_ATTR_MAX] = {}; | |
65 | struct rd *rd = data; | |
66 | const char *name; | |
67 | uint32_t idx; | |
68 | ||
69 | mnl_attr_parse(nlh, 0, rd_attr_cb, tb); | |
70 | if (!tb[RDMA_NLDEV_ATTR_DEV_INDEX] || | |
71 | !tb[RDMA_NLDEV_ATTR_DEV_NAME] || | |
72 | !tb[RDMA_NLDEV_ATTR_RES_SUMMARY]) | |
73 | return MNL_CB_ERROR; | |
74 | ||
75 | idx = mnl_attr_get_u32(tb[RDMA_NLDEV_ATTR_DEV_INDEX]); | |
76 | name = mnl_attr_get_str(tb[RDMA_NLDEV_ATTR_DEV_NAME]); | |
77 | open_json_object(NULL); | |
78 | print_color_uint(PRINT_ANY, COLOR_NONE, "ifindex", "%u: ", idx); | |
79 | print_color_string(PRINT_ANY, COLOR_NONE, "ifname", "%s: ", name); | |
80 | res_print_summary(rd, tb); | |
81 | newline(rd); | |
82 | return MNL_CB_OK; | |
83 | } | |
84 | ||
85 | int _res_send_idx_msg(struct rd *rd, uint32_t command, mnl_cb_t callback, | |
86 | uint32_t idx, uint32_t id) | |
87 | { | |
88 | uint32_t flags = NLM_F_REQUEST | NLM_F_ACK; | |
89 | uint32_t seq; | |
90 | int ret; | |
91 | ||
92 | rd_prepare_msg(rd, command, &seq, flags); | |
93 | mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx); | |
94 | if (rd->port_idx) | |
95 | mnl_attr_put_u32(rd->nlh, | |
96 | RDMA_NLDEV_ATTR_PORT_INDEX, rd->port_idx); | |
97 | ||
98 | mnl_attr_put_u32(rd->nlh, id, idx); | |
99 | ||
100 | if (command == RDMA_NLDEV_CMD_STAT_GET) | |
101 | mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_STAT_RES, | |
102 | RDMA_NLDEV_ATTR_RES_MR); | |
103 | ||
104 | ret = rd_send_msg(rd); | |
105 | if (ret) | |
106 | return ret; | |
107 | ret = rd_recv_msg(rd, callback, rd, seq); | |
108 | return ret; | |
109 | } | |
110 | ||
111 | int _res_send_msg(struct rd *rd, uint32_t command, mnl_cb_t callback) | |
112 | { | |
113 | uint32_t flags = NLM_F_REQUEST | NLM_F_ACK; | |
114 | uint32_t seq; | |
115 | int ret; | |
116 | ||
117 | if (command != RDMA_NLDEV_CMD_RES_GET) | |
118 | flags |= NLM_F_DUMP; | |
119 | ||
120 | rd_prepare_msg(rd, command, &seq, flags); | |
121 | mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_DEV_INDEX, rd->dev_idx); | |
122 | if (rd->port_idx) | |
123 | mnl_attr_put_u32(rd->nlh, | |
124 | RDMA_NLDEV_ATTR_PORT_INDEX, rd->port_idx); | |
125 | ||
126 | if (command == RDMA_NLDEV_CMD_STAT_GET) | |
127 | mnl_attr_put_u32(rd->nlh, RDMA_NLDEV_ATTR_STAT_RES, | |
128 | RDMA_NLDEV_ATTR_RES_MR); | |
129 | ||
130 | ret = rd_send_msg(rd); | |
131 | if (ret) | |
132 | return ret; | |
133 | ||
134 | ret = rd_recv_msg(rd, callback, rd, seq); | |
135 | return ret; | |
136 | } | |
137 | ||
138 | const char *qp_types_to_str(uint8_t idx) | |
139 | { | |
140 | static const char * const qp_types_str[] = { "SMI", "GSI", "RC", | |
141 | "UC", "UD", "RAW_IPV6", | |
142 | "RAW_ETHERTYPE", | |
143 | "UNKNOWN", "RAW_PACKET", | |
144 | "XRC_INI", "XRC_TGT", | |
145 | [0xFF] = "DRIVER", | |
146 | }; | |
147 | ||
148 | if (idx < ARRAY_SIZE(qp_types_str) && qp_types_str[idx]) | |
149 | return qp_types_str[idx]; | |
150 | return "UNKNOWN"; | |
151 | } | |
152 | ||
153 | void print_comm(struct rd *rd, const char *str, struct nlattr **nla_line) | |
154 | { | |
155 | char tmp[18]; | |
156 | ||
157 | if (!str) | |
158 | return; | |
159 | ||
160 | if (nla_line[RDMA_NLDEV_ATTR_RES_PID] || rd->json_output) | |
161 | snprintf(tmp, sizeof(tmp), "%s", str); | |
162 | else | |
163 | snprintf(tmp, sizeof(tmp), "[%s]", str); | |
164 | print_color_string(PRINT_ANY, COLOR_NONE, "comm", "comm %s ", tmp); | |
165 | } | |
166 | ||
167 | void print_dev(struct rd *rd, uint32_t idx, const char *name) | |
168 | { | |
169 | print_color_int(PRINT_ANY, COLOR_NONE, "ifindex", NULL, idx); | |
170 | print_color_string(PRINT_ANY, COLOR_NONE, "ifname", "dev %s ", name); | |
171 | } | |
172 | ||
173 | void print_link(struct rd *rd, uint32_t idx, const char *name, uint32_t port, | |
174 | struct nlattr **nla_line) | |
175 | { | |
176 | char tmp[64] = {}; | |
177 | ||
178 | print_color_uint(PRINT_JSON, COLOR_NONE, "ifindex", NULL, idx); | |
179 | print_color_string(PRINT_ANY, COLOR_NONE, "ifname", NULL, name); | |
180 | if (nla_line[RDMA_NLDEV_ATTR_PORT_INDEX]) { | |
181 | print_color_uint(PRINT_ANY, COLOR_NONE, "port", NULL, port); | |
182 | snprintf(tmp, sizeof(tmp), "%s/%d", name, port); | |
183 | } else { | |
184 | snprintf(tmp, sizeof(tmp), "%s/-", name); | |
185 | } | |
186 | ||
187 | if (!rd->json_output) | |
188 | print_color_string(PRINT_ANY, COLOR_NONE, NULL, "link %s ", | |
189 | tmp); | |
190 | } | |
191 | ||
192 | void print_qp_type(struct rd *rd, uint32_t val) | |
193 | { | |
194 | print_color_string(PRINT_ANY, COLOR_NONE, "qp-type", "qp-type %s ", | |
195 | qp_types_to_str(val)); | |
196 | } | |
197 | ||
198 | char *get_task_name(uint32_t pid) | |
199 | { | |
200 | char *comm; | |
201 | FILE *f; | |
202 | ||
203 | if (!pid) | |
204 | return NULL; | |
205 | ||
206 | if (asprintf(&comm, "/proc/%d/comm", pid) < 0) | |
207 | return NULL; | |
208 | ||
209 | f = fopen(comm, "r"); | |
210 | free(comm); | |
211 | if (!f) | |
212 | return NULL; | |
213 | ||
214 | if (fscanf(f, "%ms\n", &comm) != 1) | |
215 | comm = NULL; | |
216 | ||
217 | fclose(f); | |
218 | ||
219 | return comm; | |
220 | } | |
221 | ||
222 | void print_key(struct rd *rd, const char *name, uint64_t val, | |
223 | struct nlattr *nlattr) | |
224 | { | |
225 | if (!nlattr) | |
226 | return; | |
227 | print_color_string(PRINT_FP, COLOR_NONE, NULL, name, NULL); | |
228 | print_color_hex(PRINT_ANY, COLOR_NONE, name, " 0x%" PRIx64 " ", val); | |
229 | } | |
230 | ||
231 | void res_print_uint(struct rd *rd, const char *name, uint64_t val, | |
232 | struct nlattr *nlattr) | |
233 | { | |
234 | if (!nlattr) | |
235 | return; | |
236 | print_color_uint(PRINT_ANY, COLOR_NONE, name, name, val); | |
237 | print_color_uint(PRINT_FP, COLOR_NONE, NULL, " %d ", val); | |
238 | } | |
239 | ||
240 | RES_FUNC(res_no_args, RDMA_NLDEV_CMD_RES_GET, NULL, true, 0); | |
241 | ||
242 | static int res_show(struct rd *rd) | |
243 | { | |
244 | const struct rd_cmd cmds[] = { | |
245 | { NULL, res_no_args }, | |
246 | { "qp", res_qp }, | |
247 | { "cm_id", res_cm_id }, | |
248 | { "cq", res_cq }, | |
249 | { "mr", res_mr }, | |
250 | { "pd", res_pd }, | |
251 | { 0 } | |
252 | }; | |
253 | ||
254 | /* | |
255 | * Special case to support "rdma res show DEV_NAME" | |
256 | */ | |
257 | if (rd_argc(rd) == 1 && dev_map_lookup(rd, false)) | |
258 | return rd_exec_dev(rd, _res_no_args); | |
259 | ||
260 | return rd_exec_cmd(rd, cmds, "parameter"); | |
261 | } | |
262 | ||
263 | int cmd_res(struct rd *rd) | |
264 | { | |
265 | const struct rd_cmd cmds[] = { | |
266 | { NULL, res_show }, | |
267 | { "show", res_show }, | |
268 | { "list", res_show }, | |
269 | { "help", res_help }, | |
270 | { 0 } | |
271 | }; | |
272 | ||
273 | return rd_exec_cmd(rd, cmds, "resource command"); | |
274 | } |