1 /* 2 * Copyright (c) 2018 Chelsio, 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 <rdma/rdma_cm.h> 34 35 #include "iw_cxgb4.h" 36 #include <rdma/restrack.h> 37 #include <uapi/rdma/rdma_netlink.h> 38 39 static int fill_sq(struct sk_buff *msg, struct t4_wq *wq) 40 { 41 /* WQ+SQ */ 42 if (rdma_nl_put_driver_u32(msg, "sqid", wq->sq.qid)) 43 goto err; 44 if (rdma_nl_put_driver_u32(msg, "flushed", wq->flushed)) 45 goto err; 46 if (rdma_nl_put_driver_u32(msg, "memsize", wq->sq.memsize)) 47 goto err; 48 if (rdma_nl_put_driver_u32(msg, "cidx", wq->sq.cidx)) 49 goto err; 50 if (rdma_nl_put_driver_u32(msg, "pidx", wq->sq.pidx)) 51 goto err; 52 if (rdma_nl_put_driver_u32(msg, "wq_pidx", wq->sq.wq_pidx)) 53 goto err; 54 if (rdma_nl_put_driver_u32(msg, "flush_cidx", wq->sq.flush_cidx)) 55 goto err; 56 if (rdma_nl_put_driver_u32(msg, "in_use", wq->sq.in_use)) 57 goto err; 58 if (rdma_nl_put_driver_u32(msg, "size", wq->sq.size)) 59 goto err; 60 if (rdma_nl_put_driver_u32_hex(msg, "flags", wq->sq.flags)) 61 goto err; 62 return 0; 63 err: 64 return -EMSGSIZE; 65 } 66 67 static int fill_rq(struct sk_buff *msg, struct t4_wq *wq) 68 { 69 /* RQ */ 70 if (rdma_nl_put_driver_u32(msg, "rqid", wq->rq.qid)) 71 goto err; 72 if (rdma_nl_put_driver_u32(msg, "memsize", wq->rq.memsize)) 73 goto err; 74 if (rdma_nl_put_driver_u32(msg, "cidx", wq->rq.cidx)) 75 goto err; 76 if (rdma_nl_put_driver_u32(msg, "pidx", wq->rq.pidx)) 77 goto err; 78 if (rdma_nl_put_driver_u32(msg, "wq_pidx", wq->rq.wq_pidx)) 79 goto err; 80 if (rdma_nl_put_driver_u32(msg, "msn", wq->rq.msn)) 81 goto err; 82 if (rdma_nl_put_driver_u32_hex(msg, "rqt_hwaddr", wq->rq.rqt_hwaddr)) 83 goto err; 84 if (rdma_nl_put_driver_u32(msg, "rqt_size", wq->rq.rqt_size)) 85 goto err; 86 if (rdma_nl_put_driver_u32(msg, "in_use", wq->rq.in_use)) 87 goto err; 88 if (rdma_nl_put_driver_u32(msg, "size", wq->rq.size)) 89 goto err; 90 return 0; 91 err: 92 return -EMSGSIZE; 93 } 94 95 static int fill_swsqe(struct sk_buff *msg, struct t4_sq *sq, u16 idx, 96 struct t4_swsqe *sqe) 97 { 98 if (rdma_nl_put_driver_u32(msg, "idx", idx)) 99 goto err; 100 if (rdma_nl_put_driver_u32(msg, "opcode", sqe->opcode)) 101 goto err; 102 if (rdma_nl_put_driver_u32(msg, "complete", sqe->complete)) 103 goto err; 104 if (sqe->complete && 105 rdma_nl_put_driver_u32(msg, "cqe_status", CQE_STATUS(&sqe->cqe))) 106 goto err; 107 if (rdma_nl_put_driver_u32(msg, "signaled", sqe->signaled)) 108 goto err; 109 if (rdma_nl_put_driver_u32(msg, "flushed", sqe->flushed)) 110 goto err; 111 return 0; 112 err: 113 return -EMSGSIZE; 114 } 115 116 /* 117 * Dump the first and last pending sqes. 118 */ 119 static int fill_swsqes(struct sk_buff *msg, struct t4_sq *sq, 120 u16 first_idx, struct t4_swsqe *first_sqe, 121 u16 last_idx, struct t4_swsqe *last_sqe) 122 { 123 if (!first_sqe) 124 goto out; 125 if (fill_swsqe(msg, sq, first_idx, first_sqe)) 126 goto err; 127 if (!last_sqe) 128 goto out; 129 if (fill_swsqe(msg, sq, last_idx, last_sqe)) 130 goto err; 131 out: 132 return 0; 133 err: 134 return -EMSGSIZE; 135 } 136 137 static int fill_res_qp_entry(struct sk_buff *msg, 138 struct rdma_restrack_entry *res) 139 { 140 struct ib_qp *ibqp = container_of(res, struct ib_qp, res); 141 struct t4_swsqe *fsp = NULL, *lsp = NULL; 142 struct c4iw_qp *qhp = to_c4iw_qp(ibqp); 143 u16 first_sq_idx = 0, last_sq_idx = 0; 144 struct t4_swsqe first_sqe, last_sqe; 145 struct nlattr *table_attr; 146 struct t4_wq wq; 147 148 /* User qp state is not available, so don't dump user qps */ 149 if (qhp->ucontext) 150 return 0; 151 152 table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_DRIVER); 153 if (!table_attr) 154 goto err; 155 156 /* Get a consistent snapshot */ 157 spin_lock_irq(&qhp->lock); 158 wq = qhp->wq; 159 160 /* If there are any pending sqes, copy the first and last */ 161 if (wq.sq.cidx != wq.sq.pidx) { 162 first_sq_idx = wq.sq.cidx; 163 first_sqe = qhp->wq.sq.sw_sq[first_sq_idx]; 164 fsp = &first_sqe; 165 last_sq_idx = wq.sq.pidx; 166 if (last_sq_idx-- == 0) 167 last_sq_idx = wq.sq.size - 1; 168 if (last_sq_idx != first_sq_idx) { 169 last_sqe = qhp->wq.sq.sw_sq[last_sq_idx]; 170 lsp = &last_sqe; 171 } 172 } 173 spin_unlock_irq(&qhp->lock); 174 175 if (fill_sq(msg, &wq)) 176 goto err_cancel_table; 177 178 if (fill_swsqes(msg, &wq.sq, first_sq_idx, fsp, last_sq_idx, lsp)) 179 goto err_cancel_table; 180 181 if (fill_rq(msg, &wq)) 182 goto err_cancel_table; 183 184 nla_nest_end(msg, table_attr); 185 return 0; 186 187 err_cancel_table: 188 nla_nest_cancel(msg, table_attr); 189 err: 190 return -EMSGSIZE; 191 } 192 193 union union_ep { 194 struct c4iw_listen_ep lep; 195 struct c4iw_ep ep; 196 }; 197 198 static int fill_res_ep_entry(struct sk_buff *msg, 199 struct rdma_restrack_entry *res) 200 { 201 struct rdma_cm_id *cm_id = rdma_res_to_id(res); 202 struct nlattr *table_attr; 203 struct c4iw_ep_common *epcp; 204 struct c4iw_listen_ep *listen_ep = NULL; 205 struct c4iw_ep *ep = NULL; 206 struct iw_cm_id *iw_cm_id; 207 union union_ep *uep; 208 209 iw_cm_id = rdma_iw_cm_id(cm_id); 210 if (!iw_cm_id) 211 return 0; 212 epcp = (struct c4iw_ep_common *)iw_cm_id->provider_data; 213 if (!epcp) 214 return 0; 215 uep = kcalloc(1, sizeof(*uep), GFP_KERNEL); 216 if (!uep) 217 return 0; 218 219 table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_DRIVER); 220 if (!table_attr) 221 goto err_free_uep; 222 223 /* Get a consistent snapshot */ 224 mutex_lock(&epcp->mutex); 225 if (epcp->state == LISTEN) { 226 uep->lep = *(struct c4iw_listen_ep *)epcp; 227 mutex_unlock(&epcp->mutex); 228 listen_ep = &uep->lep; 229 epcp = &listen_ep->com; 230 } else { 231 uep->ep = *(struct c4iw_ep *)epcp; 232 mutex_unlock(&epcp->mutex); 233 ep = &uep->ep; 234 epcp = &ep->com; 235 } 236 237 if (rdma_nl_put_driver_u32(msg, "state", epcp->state)) 238 goto err_cancel_table; 239 if (rdma_nl_put_driver_u64_hex(msg, "flags", epcp->flags)) 240 goto err_cancel_table; 241 if (rdma_nl_put_driver_u64_hex(msg, "history", epcp->history)) 242 goto err_cancel_table; 243 244 if (epcp->state == LISTEN) { 245 if (rdma_nl_put_driver_u32(msg, "stid", listen_ep->stid)) 246 goto err_cancel_table; 247 if (rdma_nl_put_driver_u32(msg, "backlog", listen_ep->backlog)) 248 goto err_cancel_table; 249 } else { 250 if (rdma_nl_put_driver_u32(msg, "hwtid", ep->hwtid)) 251 goto err_cancel_table; 252 if (rdma_nl_put_driver_u32(msg, "ord", ep->ord)) 253 goto err_cancel_table; 254 if (rdma_nl_put_driver_u32(msg, "ird", ep->ird)) 255 goto err_cancel_table; 256 if (rdma_nl_put_driver_u32(msg, "emss", ep->emss)) 257 goto err_cancel_table; 258 259 if (!ep->parent_ep && rdma_nl_put_driver_u32(msg, "atid", 260 ep->atid)) 261 goto err_cancel_table; 262 } 263 nla_nest_end(msg, table_attr); 264 kfree(uep); 265 return 0; 266 267 err_cancel_table: 268 nla_nest_cancel(msg, table_attr); 269 err_free_uep: 270 kfree(uep); 271 return -EMSGSIZE; 272 } 273 274 static int fill_cq(struct sk_buff *msg, struct t4_cq *cq) 275 { 276 if (rdma_nl_put_driver_u32(msg, "cqid", cq->cqid)) 277 goto err; 278 if (rdma_nl_put_driver_u32(msg, "memsize", cq->memsize)) 279 goto err; 280 if (rdma_nl_put_driver_u32(msg, "size", cq->size)) 281 goto err; 282 if (rdma_nl_put_driver_u32(msg, "cidx", cq->cidx)) 283 goto err; 284 if (rdma_nl_put_driver_u32(msg, "cidx_inc", cq->cidx_inc)) 285 goto err; 286 if (rdma_nl_put_driver_u32(msg, "sw_cidx", cq->sw_cidx)) 287 goto err; 288 if (rdma_nl_put_driver_u32(msg, "sw_pidx", cq->sw_pidx)) 289 goto err; 290 if (rdma_nl_put_driver_u32(msg, "sw_in_use", cq->sw_in_use)) 291 goto err; 292 if (rdma_nl_put_driver_u32(msg, "vector", cq->vector)) 293 goto err; 294 if (rdma_nl_put_driver_u32(msg, "gen", cq->gen)) 295 goto err; 296 if (rdma_nl_put_driver_u32(msg, "error", cq->error)) 297 goto err; 298 if (rdma_nl_put_driver_u64_hex(msg, "bits_type_ts", 299 be64_to_cpu(cq->bits_type_ts))) 300 goto err; 301 if (rdma_nl_put_driver_u64_hex(msg, "flags", cq->flags)) 302 goto err; 303 304 return 0; 305 306 err: 307 return -EMSGSIZE; 308 } 309 310 static int fill_cqe(struct sk_buff *msg, struct t4_cqe *cqe, u16 idx, 311 const char *qstr) 312 { 313 if (rdma_nl_put_driver_u32(msg, qstr, idx)) 314 goto err; 315 if (rdma_nl_put_driver_u32_hex(msg, "header", 316 be32_to_cpu(cqe->header))) 317 goto err; 318 if (rdma_nl_put_driver_u32(msg, "len", be32_to_cpu(cqe->len))) 319 goto err; 320 if (rdma_nl_put_driver_u32_hex(msg, "wrid_hi", 321 be32_to_cpu(cqe->u.gen.wrid_hi))) 322 goto err; 323 if (rdma_nl_put_driver_u32_hex(msg, "wrid_low", 324 be32_to_cpu(cqe->u.gen.wrid_low))) 325 goto err; 326 if (rdma_nl_put_driver_u64_hex(msg, "bits_type_ts", 327 be64_to_cpu(cqe->bits_type_ts))) 328 goto err; 329 330 return 0; 331 332 err: 333 return -EMSGSIZE; 334 } 335 336 static int fill_hwcqes(struct sk_buff *msg, struct t4_cq *cq, 337 struct t4_cqe *cqes) 338 { 339 u16 idx; 340 341 idx = (cq->cidx > 0) ? cq->cidx - 1 : cq->size - 1; 342 if (fill_cqe(msg, cqes, idx, "hwcq_idx")) 343 goto err; 344 idx = cq->cidx; 345 if (fill_cqe(msg, cqes + 1, idx, "hwcq_idx")) 346 goto err; 347 348 return 0; 349 err: 350 return -EMSGSIZE; 351 } 352 353 static int fill_swcqes(struct sk_buff *msg, struct t4_cq *cq, 354 struct t4_cqe *cqes) 355 { 356 u16 idx; 357 358 if (!cq->sw_in_use) 359 return 0; 360 361 idx = cq->sw_cidx; 362 if (fill_cqe(msg, cqes, idx, "swcq_idx")) 363 goto err; 364 if (cq->sw_in_use == 1) 365 goto out; 366 idx = (cq->sw_pidx > 0) ? cq->sw_pidx - 1 : cq->size - 1; 367 if (fill_cqe(msg, cqes + 1, idx, "swcq_idx")) 368 goto err; 369 out: 370 return 0; 371 err: 372 return -EMSGSIZE; 373 } 374 375 static int fill_res_cq_entry(struct sk_buff *msg, 376 struct rdma_restrack_entry *res) 377 { 378 struct ib_cq *ibcq = container_of(res, struct ib_cq, res); 379 struct c4iw_cq *chp = to_c4iw_cq(ibcq); 380 struct nlattr *table_attr; 381 struct t4_cqe hwcqes[2]; 382 struct t4_cqe swcqes[2]; 383 struct t4_cq cq; 384 u16 idx; 385 386 /* User cq state is not available, so don't dump user cqs */ 387 if (ibcq->uobject) 388 return 0; 389 390 table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_DRIVER); 391 if (!table_attr) 392 goto err; 393 394 /* Get a consistent snapshot */ 395 spin_lock_irq(&chp->lock); 396 397 /* t4_cq struct */ 398 cq = chp->cq; 399 400 /* get 2 hw cqes: cidx-1, and cidx */ 401 idx = (cq.cidx > 0) ? cq.cidx - 1 : cq.size - 1; 402 hwcqes[0] = chp->cq.queue[idx]; 403 404 idx = cq.cidx; 405 hwcqes[1] = chp->cq.queue[idx]; 406 407 /* get first and last sw cqes */ 408 if (cq.sw_in_use) { 409 swcqes[0] = chp->cq.sw_queue[cq.sw_cidx]; 410 if (cq.sw_in_use > 1) { 411 idx = (cq.sw_pidx > 0) ? cq.sw_pidx - 1 : cq.size - 1; 412 swcqes[1] = chp->cq.sw_queue[idx]; 413 } 414 } 415 416 spin_unlock_irq(&chp->lock); 417 418 if (fill_cq(msg, &cq)) 419 goto err_cancel_table; 420 421 if (fill_swcqes(msg, &cq, swcqes)) 422 goto err_cancel_table; 423 424 if (fill_hwcqes(msg, &cq, hwcqes)) 425 goto err_cancel_table; 426 427 nla_nest_end(msg, table_attr); 428 return 0; 429 430 err_cancel_table: 431 nla_nest_cancel(msg, table_attr); 432 err: 433 return -EMSGSIZE; 434 } 435 436 static int fill_res_mr_entry(struct sk_buff *msg, 437 struct rdma_restrack_entry *res) 438 { 439 struct ib_mr *ibmr = container_of(res, struct ib_mr, res); 440 struct c4iw_mr *mhp = to_c4iw_mr(ibmr); 441 struct c4iw_dev *dev = mhp->rhp; 442 u32 stag = mhp->attr.stag; 443 struct nlattr *table_attr; 444 struct fw_ri_tpte tpte; 445 int ret; 446 447 if (!stag) 448 return 0; 449 450 table_attr = nla_nest_start(msg, RDMA_NLDEV_ATTR_DRIVER); 451 if (!table_attr) 452 goto err; 453 454 ret = cxgb4_read_tpte(dev->rdev.lldi.ports[0], stag, (__be32 *)&tpte); 455 if (ret) { 456 dev_err(&dev->rdev.lldi.pdev->dev, 457 "%s cxgb4_read_tpte err %d\n", __func__, ret); 458 return 0; 459 } 460 461 if (rdma_nl_put_driver_u32_hex(msg, "idx", stag >> 8)) 462 goto err_cancel_table; 463 if (rdma_nl_put_driver_u32(msg, "valid", 464 FW_RI_TPTE_VALID_G(ntohl(tpte.valid_to_pdid)))) 465 goto err_cancel_table; 466 if (rdma_nl_put_driver_u32_hex(msg, "key", stag & 0xff)) 467 goto err_cancel_table; 468 if (rdma_nl_put_driver_u32(msg, "state", 469 FW_RI_TPTE_STAGSTATE_G(ntohl(tpte.valid_to_pdid)))) 470 goto err_cancel_table; 471 if (rdma_nl_put_driver_u32(msg, "pdid", 472 FW_RI_TPTE_PDID_G(ntohl(tpte.valid_to_pdid)))) 473 goto err_cancel_table; 474 if (rdma_nl_put_driver_u32_hex(msg, "perm", 475 FW_RI_TPTE_PERM_G(ntohl(tpte.locread_to_qpid)))) 476 goto err_cancel_table; 477 if (rdma_nl_put_driver_u32(msg, "ps", 478 FW_RI_TPTE_PS_G(ntohl(tpte.locread_to_qpid)))) 479 goto err_cancel_table; 480 if (rdma_nl_put_driver_u64(msg, "len", 481 ((u64)ntohl(tpte.len_hi) << 32) | ntohl(tpte.len_lo))) 482 goto err_cancel_table; 483 if (rdma_nl_put_driver_u32_hex(msg, "pbl_addr", 484 FW_RI_TPTE_PBLADDR_G(ntohl(tpte.nosnoop_pbladdr)))) 485 goto err_cancel_table; 486 487 nla_nest_end(msg, table_attr); 488 return 0; 489 490 err_cancel_table: 491 nla_nest_cancel(msg, table_attr); 492 err: 493 return -EMSGSIZE; 494 } 495 496 c4iw_restrack_func *c4iw_restrack_funcs[RDMA_RESTRACK_MAX] = { 497 [RDMA_RESTRACK_QP] = fill_res_qp_entry, 498 [RDMA_RESTRACK_CM_ID] = fill_res_ep_entry, 499 [RDMA_RESTRACK_CQ] = fill_res_cq_entry, 500 [RDMA_RESTRACK_MR] = fill_res_mr_entry, 501 }; 502