Commit | Line | Data |
---|---|---|
e126ba97 EC |
1 | /* |
2 | * Copyright (c) 2013, Mellanox Technologies inc. All rights reserved. | |
3 | * | |
4 | * This software is available to you under a choice of one of two | |
5 | * licenses. You may choose to be licensed under the terms of the GNU | |
6 | * General Public License (GPL) Version 2, available from the file | |
7 | * COPYING in the main directory of this source tree, or the | |
8 | * OpenIB.org BSD license below: | |
9 | * | |
10 | * Redistribution and use in source and binary forms, with or | |
11 | * without modification, are permitted provided that the following | |
12 | * conditions are met: | |
13 | * | |
14 | * - Redistributions of source code must retain the above | |
15 | * copyright notice, this list of conditions and the following | |
16 | * disclaimer. | |
17 | * | |
18 | * - Redistributions in binary form must reproduce the above | |
19 | * copyright notice, this list of conditions and the following | |
20 | * disclaimer in the documentation and/or other materials | |
21 | * provided with the distribution. | |
22 | * | |
23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
25 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
27 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
28 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
29 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
30 | * SOFTWARE. | |
31 | */ | |
32 | ||
33 | #include <linux/module.h> | |
34 | #include <linux/debugfs.h> | |
35 | #include <linux/mlx5/qp.h> | |
36 | #include <linux/mlx5/cq.h> | |
37 | #include <linux/mlx5/driver.h> | |
38 | #include "mlx5_core.h" | |
39 | ||
40 | enum { | |
41 | QP_PID, | |
42 | QP_STATE, | |
43 | QP_XPORT, | |
44 | QP_MTU, | |
45 | QP_N_RECV, | |
46 | QP_RECV_SZ, | |
47 | QP_N_SEND, | |
48 | QP_LOG_PG_SZ, | |
49 | QP_RQPN, | |
50 | }; | |
51 | ||
52 | static char *qp_fields[] = { | |
53 | [QP_PID] = "pid", | |
54 | [QP_STATE] = "state", | |
55 | [QP_XPORT] = "transport", | |
56 | [QP_MTU] = "mtu", | |
57 | [QP_N_RECV] = "num_recv", | |
58 | [QP_RECV_SZ] = "rcv_wqe_sz", | |
59 | [QP_N_SEND] = "num_send", | |
60 | [QP_LOG_PG_SZ] = "log2_page_sz", | |
61 | [QP_RQPN] = "remote_qpn", | |
62 | }; | |
63 | ||
64 | enum { | |
65 | EQ_NUM_EQES, | |
66 | EQ_INTR, | |
67 | EQ_LOG_PG_SZ, | |
68 | }; | |
69 | ||
70 | static char *eq_fields[] = { | |
71 | [EQ_NUM_EQES] = "num_eqes", | |
72 | [EQ_INTR] = "intr", | |
73 | [EQ_LOG_PG_SZ] = "log_page_size", | |
74 | }; | |
75 | ||
76 | enum { | |
77 | CQ_PID, | |
78 | CQ_NUM_CQES, | |
79 | CQ_LOG_PG_SZ, | |
80 | }; | |
81 | ||
82 | static char *cq_fields[] = { | |
83 | [CQ_PID] = "pid", | |
84 | [CQ_NUM_CQES] = "num_cqes", | |
85 | [CQ_LOG_PG_SZ] = "log_page_size", | |
86 | }; | |
87 | ||
88 | struct dentry *mlx5_debugfs_root; | |
89 | EXPORT_SYMBOL(mlx5_debugfs_root); | |
90 | ||
91 | void mlx5_register_debugfs(void) | |
92 | { | |
93 | mlx5_debugfs_root = debugfs_create_dir("mlx5", NULL); | |
94 | if (IS_ERR_OR_NULL(mlx5_debugfs_root)) | |
95 | mlx5_debugfs_root = NULL; | |
96 | } | |
97 | ||
98 | void mlx5_unregister_debugfs(void) | |
99 | { | |
100 | debugfs_remove(mlx5_debugfs_root); | |
101 | } | |
102 | ||
103 | int mlx5_qp_debugfs_init(struct mlx5_core_dev *dev) | |
104 | { | |
105 | if (!mlx5_debugfs_root) | |
106 | return 0; | |
107 | ||
108 | atomic_set(&dev->num_qps, 0); | |
109 | ||
110 | dev->priv.qp_debugfs = debugfs_create_dir("QPs", dev->priv.dbg_root); | |
111 | if (!dev->priv.qp_debugfs) | |
112 | return -ENOMEM; | |
113 | ||
114 | return 0; | |
115 | } | |
116 | ||
117 | void mlx5_qp_debugfs_cleanup(struct mlx5_core_dev *dev) | |
118 | { | |
119 | if (!mlx5_debugfs_root) | |
120 | return; | |
121 | ||
122 | debugfs_remove_recursive(dev->priv.qp_debugfs); | |
123 | } | |
124 | ||
125 | int mlx5_eq_debugfs_init(struct mlx5_core_dev *dev) | |
126 | { | |
127 | if (!mlx5_debugfs_root) | |
128 | return 0; | |
129 | ||
130 | dev->priv.eq_debugfs = debugfs_create_dir("EQs", dev->priv.dbg_root); | |
131 | if (!dev->priv.eq_debugfs) | |
132 | return -ENOMEM; | |
133 | ||
134 | return 0; | |
135 | } | |
136 | ||
137 | void mlx5_eq_debugfs_cleanup(struct mlx5_core_dev *dev) | |
138 | { | |
139 | if (!mlx5_debugfs_root) | |
140 | return; | |
141 | ||
142 | debugfs_remove_recursive(dev->priv.eq_debugfs); | |
143 | } | |
144 | ||
145 | static ssize_t average_read(struct file *filp, char __user *buf, size_t count, | |
146 | loff_t *pos) | |
147 | { | |
148 | struct mlx5_cmd_stats *stats; | |
149 | u64 field = 0; | |
150 | int ret; | |
e126ba97 EC |
151 | char tbuf[22]; |
152 | ||
153 | if (*pos) | |
154 | return 0; | |
155 | ||
156 | stats = filp->private_data; | |
746b5583 | 157 | spin_lock_irq(&stats->lock); |
e126ba97 | 158 | if (stats->n) |
9a0f06fe | 159 | field = div64_u64(stats->sum, stats->n); |
746b5583 | 160 | spin_unlock_irq(&stats->lock); |
e126ba97 EC |
161 | ret = snprintf(tbuf, sizeof(tbuf), "%llu\n", field); |
162 | if (ret > 0) { | |
5e631a03 DC |
163 | if (copy_to_user(buf, tbuf, ret)) |
164 | return -EFAULT; | |
e126ba97 EC |
165 | } |
166 | ||
167 | *pos += ret; | |
168 | return ret; | |
169 | } | |
170 | ||
171 | ||
172 | static ssize_t average_write(struct file *filp, const char __user *buf, | |
173 | size_t count, loff_t *pos) | |
174 | { | |
175 | struct mlx5_cmd_stats *stats; | |
176 | ||
177 | stats = filp->private_data; | |
746b5583 | 178 | spin_lock_irq(&stats->lock); |
e126ba97 EC |
179 | stats->sum = 0; |
180 | stats->n = 0; | |
746b5583 | 181 | spin_unlock_irq(&stats->lock); |
e126ba97 EC |
182 | |
183 | *pos += count; | |
184 | ||
185 | return count; | |
186 | } | |
187 | ||
188 | static const struct file_operations stats_fops = { | |
189 | .owner = THIS_MODULE, | |
190 | .open = simple_open, | |
191 | .read = average_read, | |
192 | .write = average_write, | |
193 | }; | |
194 | ||
195 | int mlx5_cmdif_debugfs_init(struct mlx5_core_dev *dev) | |
196 | { | |
197 | struct mlx5_cmd_stats *stats; | |
198 | struct dentry **cmd; | |
199 | const char *namep; | |
200 | int err; | |
201 | int i; | |
202 | ||
203 | if (!mlx5_debugfs_root) | |
204 | return 0; | |
205 | ||
206 | cmd = &dev->priv.cmdif_debugfs; | |
207 | *cmd = debugfs_create_dir("commands", dev->priv.dbg_root); | |
208 | if (!*cmd) | |
209 | return -ENOMEM; | |
210 | ||
211 | for (i = 0; i < ARRAY_SIZE(dev->cmd.stats); i++) { | |
212 | stats = &dev->cmd.stats[i]; | |
213 | namep = mlx5_command_str(i); | |
214 | if (strcmp(namep, "unknown command opcode")) { | |
215 | stats->root = debugfs_create_dir(namep, *cmd); | |
216 | if (!stats->root) { | |
217 | mlx5_core_warn(dev, "failed adding command %d\n", | |
218 | i); | |
219 | err = -ENOMEM; | |
220 | goto out; | |
221 | } | |
222 | ||
223 | stats->avg = debugfs_create_file("average", 0400, | |
224 | stats->root, stats, | |
225 | &stats_fops); | |
226 | if (!stats->avg) { | |
227 | mlx5_core_warn(dev, "failed creating debugfs file\n"); | |
228 | err = -ENOMEM; | |
229 | goto out; | |
230 | } | |
231 | ||
232 | stats->count = debugfs_create_u64("n", 0400, | |
233 | stats->root, | |
234 | &stats->n); | |
235 | if (!stats->count) { | |
236 | mlx5_core_warn(dev, "failed creating debugfs file\n"); | |
237 | err = -ENOMEM; | |
238 | goto out; | |
239 | } | |
240 | } | |
241 | } | |
242 | ||
243 | return 0; | |
244 | out: | |
245 | debugfs_remove_recursive(dev->priv.cmdif_debugfs); | |
246 | return err; | |
247 | } | |
248 | ||
249 | void mlx5_cmdif_debugfs_cleanup(struct mlx5_core_dev *dev) | |
250 | { | |
251 | if (!mlx5_debugfs_root) | |
252 | return; | |
253 | ||
254 | debugfs_remove_recursive(dev->priv.cmdif_debugfs); | |
255 | } | |
256 | ||
257 | int mlx5_cq_debugfs_init(struct mlx5_core_dev *dev) | |
258 | { | |
259 | if (!mlx5_debugfs_root) | |
260 | return 0; | |
261 | ||
262 | dev->priv.cq_debugfs = debugfs_create_dir("CQs", dev->priv.dbg_root); | |
263 | if (!dev->priv.cq_debugfs) | |
264 | return -ENOMEM; | |
265 | ||
266 | return 0; | |
267 | } | |
268 | ||
269 | void mlx5_cq_debugfs_cleanup(struct mlx5_core_dev *dev) | |
270 | { | |
271 | if (!mlx5_debugfs_root) | |
272 | return; | |
273 | ||
274 | debugfs_remove_recursive(dev->priv.cq_debugfs); | |
275 | } | |
276 | ||
277 | static u64 qp_read_field(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp, | |
278 | int index) | |
279 | { | |
280 | struct mlx5_query_qp_mbox_out *out; | |
281 | struct mlx5_qp_context *ctx; | |
282 | u64 param = 0; | |
283 | int err; | |
284 | int no_sq; | |
285 | ||
286 | out = kzalloc(sizeof(*out), GFP_KERNEL); | |
287 | if (!out) | |
288 | return param; | |
289 | ||
290 | err = mlx5_core_qp_query(dev, qp, out, sizeof(*out)); | |
291 | if (err) { | |
292 | mlx5_core_warn(dev, "failed to query qp\n"); | |
293 | goto out; | |
294 | } | |
295 | ||
296 | ctx = &out->ctx; | |
297 | switch (index) { | |
298 | case QP_PID: | |
299 | param = qp->pid; | |
300 | break; | |
301 | case QP_STATE: | |
302 | param = be32_to_cpu(ctx->flags) >> 28; | |
303 | break; | |
304 | case QP_XPORT: | |
305 | param = (be32_to_cpu(ctx->flags) >> 16) & 0xff; | |
306 | break; | |
307 | case QP_MTU: | |
308 | param = ctx->mtu_msgmax >> 5; | |
309 | break; | |
310 | case QP_N_RECV: | |
311 | param = 1 << ((ctx->rq_size_stride >> 3) & 0xf); | |
312 | break; | |
313 | case QP_RECV_SZ: | |
314 | param = 1 << ((ctx->rq_size_stride & 7) + 4); | |
315 | break; | |
316 | case QP_N_SEND: | |
317 | no_sq = be16_to_cpu(ctx->sq_crq_size) >> 15; | |
318 | if (!no_sq) | |
319 | param = 1 << (be16_to_cpu(ctx->sq_crq_size) >> 11); | |
320 | else | |
321 | param = 0; | |
322 | break; | |
323 | case QP_LOG_PG_SZ: | |
582c016e | 324 | param = (be32_to_cpu(ctx->log_pg_sz_remote_qpn) >> 24) & 0x1f; |
e126ba97 EC |
325 | param += 12; |
326 | break; | |
327 | case QP_RQPN: | |
582c016e | 328 | param = be32_to_cpu(ctx->log_pg_sz_remote_qpn) & 0xffffff; |
e126ba97 EC |
329 | break; |
330 | } | |
331 | ||
332 | out: | |
333 | kfree(out); | |
334 | return param; | |
335 | } | |
336 | ||
337 | static u64 eq_read_field(struct mlx5_core_dev *dev, struct mlx5_eq *eq, | |
338 | int index) | |
339 | { | |
340 | struct mlx5_query_eq_mbox_out *out; | |
341 | struct mlx5_eq_context *ctx; | |
342 | u64 param = 0; | |
343 | int err; | |
344 | ||
345 | out = kzalloc(sizeof(*out), GFP_KERNEL); | |
346 | if (!out) | |
347 | return param; | |
348 | ||
349 | ctx = &out->ctx; | |
350 | ||
351 | err = mlx5_core_eq_query(dev, eq, out, sizeof(*out)); | |
352 | if (err) { | |
353 | mlx5_core_warn(dev, "failed to query eq\n"); | |
354 | goto out; | |
355 | } | |
356 | ||
357 | switch (index) { | |
358 | case EQ_NUM_EQES: | |
359 | param = 1 << ((be32_to_cpu(ctx->log_sz_usr_page) >> 24) & 0x1f); | |
360 | break; | |
361 | case EQ_INTR: | |
362 | param = ctx->intr; | |
363 | break; | |
364 | case EQ_LOG_PG_SZ: | |
365 | param = (ctx->log_page_size & 0x1f) + 12; | |
366 | break; | |
367 | } | |
368 | ||
369 | out: | |
370 | kfree(out); | |
371 | return param; | |
372 | } | |
373 | ||
374 | static u64 cq_read_field(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq, | |
375 | int index) | |
376 | { | |
377 | struct mlx5_query_cq_mbox_out *out; | |
378 | struct mlx5_cq_context *ctx; | |
379 | u64 param = 0; | |
380 | int err; | |
381 | ||
382 | out = kzalloc(sizeof(*out), GFP_KERNEL); | |
383 | if (!out) | |
384 | return param; | |
385 | ||
386 | ctx = &out->ctx; | |
387 | ||
388 | err = mlx5_core_query_cq(dev, cq, out); | |
389 | if (err) { | |
390 | mlx5_core_warn(dev, "failed to query cq\n"); | |
391 | goto out; | |
392 | } | |
393 | ||
394 | switch (index) { | |
395 | case CQ_PID: | |
396 | param = cq->pid; | |
397 | break; | |
398 | case CQ_NUM_CQES: | |
399 | param = 1 << ((be32_to_cpu(ctx->log_sz_usr_page) >> 24) & 0x1f); | |
400 | break; | |
401 | case CQ_LOG_PG_SZ: | |
402 | param = (ctx->log_pg_sz & 0x1f) + 12; | |
403 | break; | |
404 | } | |
405 | ||
406 | out: | |
407 | kfree(out); | |
408 | return param; | |
409 | } | |
410 | ||
411 | static ssize_t dbg_read(struct file *filp, char __user *buf, size_t count, | |
412 | loff_t *pos) | |
413 | { | |
414 | struct mlx5_field_desc *desc; | |
415 | struct mlx5_rsc_debug *d; | |
416 | char tbuf[18]; | |
417 | u64 field; | |
418 | int ret; | |
e126ba97 EC |
419 | |
420 | if (*pos) | |
421 | return 0; | |
422 | ||
423 | desc = filp->private_data; | |
424 | d = (void *)(desc - desc->i) - sizeof(*d); | |
425 | switch (d->type) { | |
426 | case MLX5_DBG_RSC_QP: | |
427 | field = qp_read_field(d->dev, d->object, desc->i); | |
428 | break; | |
429 | ||
430 | case MLX5_DBG_RSC_EQ: | |
431 | field = eq_read_field(d->dev, d->object, desc->i); | |
432 | break; | |
433 | ||
434 | case MLX5_DBG_RSC_CQ: | |
435 | field = cq_read_field(d->dev, d->object, desc->i); | |
436 | break; | |
437 | ||
438 | default: | |
439 | mlx5_core_warn(d->dev, "invalid resource type %d\n", d->type); | |
440 | return -EINVAL; | |
441 | } | |
442 | ||
443 | ret = snprintf(tbuf, sizeof(tbuf), "0x%llx\n", field); | |
444 | if (ret > 0) { | |
5e631a03 DC |
445 | if (copy_to_user(buf, tbuf, ret)) |
446 | return -EFAULT; | |
e126ba97 EC |
447 | } |
448 | ||
449 | *pos += ret; | |
450 | return ret; | |
451 | } | |
452 | ||
453 | static const struct file_operations fops = { | |
454 | .owner = THIS_MODULE, | |
455 | .open = simple_open, | |
456 | .read = dbg_read, | |
457 | }; | |
458 | ||
459 | static int add_res_tree(struct mlx5_core_dev *dev, enum dbg_rsc_type type, | |
460 | struct dentry *root, struct mlx5_rsc_debug **dbg, | |
461 | int rsn, char **field, int nfile, void *data) | |
462 | { | |
463 | struct mlx5_rsc_debug *d; | |
464 | char resn[32]; | |
465 | int err; | |
466 | int i; | |
467 | ||
468 | d = kzalloc(sizeof(*d) + nfile * sizeof(d->fields[0]), GFP_KERNEL); | |
469 | if (!d) | |
470 | return -ENOMEM; | |
471 | ||
472 | d->dev = dev; | |
473 | d->object = data; | |
474 | d->type = type; | |
475 | sprintf(resn, "0x%x", rsn); | |
476 | d->root = debugfs_create_dir(resn, root); | |
477 | if (!d->root) { | |
478 | err = -ENOMEM; | |
479 | goto out_free; | |
480 | } | |
481 | ||
482 | for (i = 0; i < nfile; i++) { | |
483 | d->fields[i].i = i; | |
484 | d->fields[i].dent = debugfs_create_file(field[i], 0400, | |
485 | d->root, &d->fields[i], | |
486 | &fops); | |
487 | if (!d->fields[i].dent) { | |
488 | err = -ENOMEM; | |
489 | goto out_rem; | |
490 | } | |
491 | } | |
492 | *dbg = d; | |
493 | ||
494 | return 0; | |
495 | out_rem: | |
496 | debugfs_remove_recursive(d->root); | |
497 | ||
498 | out_free: | |
499 | kfree(d); | |
500 | return err; | |
501 | } | |
502 | ||
503 | static void rem_res_tree(struct mlx5_rsc_debug *d) | |
504 | { | |
505 | debugfs_remove_recursive(d->root); | |
506 | kfree(d); | |
507 | } | |
508 | ||
509 | int mlx5_debug_qp_add(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp) | |
510 | { | |
511 | int err; | |
512 | ||
513 | if (!mlx5_debugfs_root) | |
514 | return 0; | |
515 | ||
516 | err = add_res_tree(dev, MLX5_DBG_RSC_QP, dev->priv.qp_debugfs, | |
517 | &qp->dbg, qp->qpn, qp_fields, | |
518 | ARRAY_SIZE(qp_fields), qp); | |
519 | if (err) | |
520 | qp->dbg = NULL; | |
521 | ||
522 | return err; | |
523 | } | |
524 | ||
525 | void mlx5_debug_qp_remove(struct mlx5_core_dev *dev, struct mlx5_core_qp *qp) | |
526 | { | |
527 | if (!mlx5_debugfs_root) | |
528 | return; | |
529 | ||
530 | if (qp->dbg) | |
531 | rem_res_tree(qp->dbg); | |
532 | } | |
533 | ||
534 | ||
535 | int mlx5_debug_eq_add(struct mlx5_core_dev *dev, struct mlx5_eq *eq) | |
536 | { | |
537 | int err; | |
538 | ||
539 | if (!mlx5_debugfs_root) | |
540 | return 0; | |
541 | ||
542 | err = add_res_tree(dev, MLX5_DBG_RSC_EQ, dev->priv.eq_debugfs, | |
543 | &eq->dbg, eq->eqn, eq_fields, | |
544 | ARRAY_SIZE(eq_fields), eq); | |
545 | if (err) | |
546 | eq->dbg = NULL; | |
547 | ||
548 | return err; | |
549 | } | |
550 | ||
551 | void mlx5_debug_eq_remove(struct mlx5_core_dev *dev, struct mlx5_eq *eq) | |
552 | { | |
553 | if (!mlx5_debugfs_root) | |
554 | return; | |
555 | ||
556 | if (eq->dbg) | |
557 | rem_res_tree(eq->dbg); | |
558 | } | |
559 | ||
560 | int mlx5_debug_cq_add(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq) | |
561 | { | |
562 | int err; | |
563 | ||
564 | if (!mlx5_debugfs_root) | |
565 | return 0; | |
566 | ||
567 | err = add_res_tree(dev, MLX5_DBG_RSC_CQ, dev->priv.cq_debugfs, | |
568 | &cq->dbg, cq->cqn, cq_fields, | |
569 | ARRAY_SIZE(cq_fields), cq); | |
570 | if (err) | |
571 | cq->dbg = NULL; | |
572 | ||
573 | return err; | |
574 | } | |
575 | ||
576 | void mlx5_debug_cq_remove(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq) | |
577 | { | |
578 | if (!mlx5_debugfs_root) | |
579 | return; | |
580 | ||
581 | if (cq->dbg) | |
582 | rem_res_tree(cq->dbg); | |
583 | } |