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 int c4iw_fill_res_qp_entry(struct sk_buff *msg, struct ib_qp *ibqp)
138 {
139 	struct t4_swsqe *fsp = NULL, *lsp = NULL;
140 	struct c4iw_qp *qhp = to_c4iw_qp(ibqp);
141 	u16 first_sq_idx = 0, last_sq_idx = 0;
142 	struct t4_swsqe first_sqe, last_sqe;
143 	struct nlattr *table_attr;
144 	struct t4_wq wq;
145 
146 	/* User qp state is not available, so don't dump user qps */
147 	if (qhp->ucontext)
148 		return 0;
149 
150 	table_attr = nla_nest_start_noflag(msg, RDMA_NLDEV_ATTR_DRIVER);
151 	if (!table_attr)
152 		goto err;
153 
154 	/* Get a consistent snapshot */
155 	spin_lock_irq(&qhp->lock);
156 	wq = qhp->wq;
157 
158 	/* If there are any pending sqes, copy the first and last */
159 	if (wq.sq.cidx != wq.sq.pidx) {
160 		first_sq_idx = wq.sq.cidx;
161 		first_sqe = qhp->wq.sq.sw_sq[first_sq_idx];
162 		fsp = &first_sqe;
163 		last_sq_idx = wq.sq.pidx;
164 		if (last_sq_idx-- == 0)
165 			last_sq_idx = wq.sq.size - 1;
166 		if (last_sq_idx != first_sq_idx) {
167 			last_sqe = qhp->wq.sq.sw_sq[last_sq_idx];
168 			lsp = &last_sqe;
169 		}
170 	}
171 	spin_unlock_irq(&qhp->lock);
172 
173 	if (fill_sq(msg, &wq))
174 		goto err_cancel_table;
175 
176 	if (fill_swsqes(msg, &wq.sq, first_sq_idx, fsp, last_sq_idx, lsp))
177 		goto err_cancel_table;
178 
179 	if (fill_rq(msg, &wq))
180 		goto err_cancel_table;
181 
182 	nla_nest_end(msg, table_attr);
183 	return 0;
184 
185 err_cancel_table:
186 	nla_nest_cancel(msg, table_attr);
187 err:
188 	return -EMSGSIZE;
189 }
190 
191 union union_ep {
192 	struct c4iw_listen_ep lep;
193 	struct c4iw_ep ep;
194 };
195 
196 int c4iw_fill_res_cm_id_entry(struct sk_buff *msg,
197 			      struct rdma_cm_id *cm_id)
198 {
199 	struct nlattr *table_attr;
200 	struct c4iw_ep_common *epcp;
201 	struct c4iw_listen_ep *listen_ep = NULL;
202 	struct c4iw_ep *ep = NULL;
203 	struct iw_cm_id *iw_cm_id;
204 	union union_ep *uep;
205 
206 	iw_cm_id = rdma_iw_cm_id(cm_id);
207 	if (!iw_cm_id)
208 		return 0;
209 	epcp = (struct c4iw_ep_common *)iw_cm_id->provider_data;
210 	if (!epcp)
211 		return 0;
212 	uep = kzalloc(sizeof(*uep), GFP_KERNEL);
213 	if (!uep)
214 		return 0;
215 
216 	table_attr = nla_nest_start_noflag(msg, RDMA_NLDEV_ATTR_DRIVER);
217 	if (!table_attr)
218 		goto err_free_uep;
219 
220 	/* Get a consistent snapshot */
221 	mutex_lock(&epcp->mutex);
222 	if (epcp->state == LISTEN) {
223 		uep->lep = *(struct c4iw_listen_ep *)epcp;
224 		mutex_unlock(&epcp->mutex);
225 		listen_ep = &uep->lep;
226 		epcp = &listen_ep->com;
227 	} else {
228 		uep->ep = *(struct c4iw_ep *)epcp;
229 		mutex_unlock(&epcp->mutex);
230 		ep = &uep->ep;
231 		epcp = &ep->com;
232 	}
233 
234 	if (rdma_nl_put_driver_u32(msg, "state", epcp->state))
235 		goto err_cancel_table;
236 	if (rdma_nl_put_driver_u64_hex(msg, "flags", epcp->flags))
237 		goto err_cancel_table;
238 	if (rdma_nl_put_driver_u64_hex(msg, "history", epcp->history))
239 		goto err_cancel_table;
240 
241 	if (epcp->state == LISTEN) {
242 		if (rdma_nl_put_driver_u32(msg, "stid", listen_ep->stid))
243 			goto err_cancel_table;
244 		if (rdma_nl_put_driver_u32(msg, "backlog", listen_ep->backlog))
245 			goto err_cancel_table;
246 	} else {
247 		if (rdma_nl_put_driver_u32(msg, "hwtid", ep->hwtid))
248 			goto err_cancel_table;
249 		if (rdma_nl_put_driver_u32(msg, "ord", ep->ord))
250 			goto err_cancel_table;
251 		if (rdma_nl_put_driver_u32(msg, "ird", ep->ird))
252 			goto err_cancel_table;
253 		if (rdma_nl_put_driver_u32(msg, "emss", ep->emss))
254 			goto err_cancel_table;
255 
256 		if (!ep->parent_ep && rdma_nl_put_driver_u32(msg, "atid",
257 							     ep->atid))
258 			goto err_cancel_table;
259 	}
260 	nla_nest_end(msg, table_attr);
261 	kfree(uep);
262 	return 0;
263 
264 err_cancel_table:
265 	nla_nest_cancel(msg, table_attr);
266 err_free_uep:
267 	kfree(uep);
268 	return -EMSGSIZE;
269 }
270 
271 static int fill_cq(struct sk_buff *msg, struct t4_cq *cq)
272 {
273 	if (rdma_nl_put_driver_u32(msg, "cqid", cq->cqid))
274 		goto err;
275 	if (rdma_nl_put_driver_u32(msg, "memsize", cq->memsize))
276 		goto err;
277 	if (rdma_nl_put_driver_u32(msg, "size", cq->size))
278 		goto err;
279 	if (rdma_nl_put_driver_u32(msg, "cidx", cq->cidx))
280 		goto err;
281 	if (rdma_nl_put_driver_u32(msg, "cidx_inc", cq->cidx_inc))
282 		goto err;
283 	if (rdma_nl_put_driver_u32(msg, "sw_cidx", cq->sw_cidx))
284 		goto err;
285 	if (rdma_nl_put_driver_u32(msg, "sw_pidx", cq->sw_pidx))
286 		goto err;
287 	if (rdma_nl_put_driver_u32(msg, "sw_in_use", cq->sw_in_use))
288 		goto err;
289 	if (rdma_nl_put_driver_u32(msg, "vector", cq->vector))
290 		goto err;
291 	if (rdma_nl_put_driver_u32(msg, "gen", cq->gen))
292 		goto err;
293 	if (rdma_nl_put_driver_u32(msg, "error", cq->error))
294 		goto err;
295 	if (rdma_nl_put_driver_u64_hex(msg, "bits_type_ts",
296 					 be64_to_cpu(cq->bits_type_ts)))
297 		goto err;
298 	if (rdma_nl_put_driver_u64_hex(msg, "flags", cq->flags))
299 		goto err;
300 
301 	return 0;
302 
303 err:
304 	return -EMSGSIZE;
305 }
306 
307 static int fill_cqe(struct sk_buff *msg, struct t4_cqe *cqe, u16 idx,
308 		    const char *qstr)
309 {
310 	if (rdma_nl_put_driver_u32(msg, qstr, idx))
311 		goto err;
312 	if (rdma_nl_put_driver_u32_hex(msg, "header",
313 					 be32_to_cpu(cqe->header)))
314 		goto err;
315 	if (rdma_nl_put_driver_u32(msg, "len", be32_to_cpu(cqe->len)))
316 		goto err;
317 	if (rdma_nl_put_driver_u32_hex(msg, "wrid_hi",
318 					 be32_to_cpu(cqe->u.gen.wrid_hi)))
319 		goto err;
320 	if (rdma_nl_put_driver_u32_hex(msg, "wrid_low",
321 					 be32_to_cpu(cqe->u.gen.wrid_low)))
322 		goto err;
323 	if (rdma_nl_put_driver_u64_hex(msg, "bits_type_ts",
324 					 be64_to_cpu(cqe->bits_type_ts)))
325 		goto err;
326 
327 	return 0;
328 
329 err:
330 	return -EMSGSIZE;
331 }
332 
333 static int fill_hwcqes(struct sk_buff *msg, struct t4_cq *cq,
334 		       struct t4_cqe *cqes)
335 {
336 	u16 idx;
337 
338 	idx = (cq->cidx > 0) ? cq->cidx - 1 : cq->size - 1;
339 	if (fill_cqe(msg, cqes, idx, "hwcq_idx"))
340 		goto err;
341 	idx = cq->cidx;
342 	if (fill_cqe(msg, cqes + 1, idx, "hwcq_idx"))
343 		goto err;
344 
345 	return 0;
346 err:
347 	return -EMSGSIZE;
348 }
349 
350 static int fill_swcqes(struct sk_buff *msg, struct t4_cq *cq,
351 		       struct t4_cqe *cqes)
352 {
353 	u16 idx;
354 
355 	if (!cq->sw_in_use)
356 		return 0;
357 
358 	idx = cq->sw_cidx;
359 	if (fill_cqe(msg, cqes, idx, "swcq_idx"))
360 		goto err;
361 	if (cq->sw_in_use == 1)
362 		goto out;
363 	idx = (cq->sw_pidx > 0) ? cq->sw_pidx - 1 : cq->size - 1;
364 	if (fill_cqe(msg, cqes + 1, idx, "swcq_idx"))
365 		goto err;
366 out:
367 	return 0;
368 err:
369 	return -EMSGSIZE;
370 }
371 
372 int c4iw_fill_res_cq_entry(struct sk_buff *msg, struct ib_cq *ibcq)
373 {
374 	struct c4iw_cq *chp = to_c4iw_cq(ibcq);
375 	struct nlattr *table_attr;
376 	struct t4_cqe hwcqes[2];
377 	struct t4_cqe swcqes[2];
378 	struct t4_cq cq;
379 	u16 idx;
380 
381 	/* User cq state is not available, so don't dump user cqs */
382 	if (ibcq->uobject)
383 		return 0;
384 
385 	table_attr = nla_nest_start_noflag(msg, RDMA_NLDEV_ATTR_DRIVER);
386 	if (!table_attr)
387 		goto err;
388 
389 	/* Get a consistent snapshot */
390 	spin_lock_irq(&chp->lock);
391 
392 	/* t4_cq struct */
393 	cq = chp->cq;
394 
395 	/* get 2 hw cqes: cidx-1, and cidx */
396 	idx = (cq.cidx > 0) ? cq.cidx - 1 : cq.size - 1;
397 	hwcqes[0] = chp->cq.queue[idx];
398 
399 	idx = cq.cidx;
400 	hwcqes[1] = chp->cq.queue[idx];
401 
402 	/* get first and last sw cqes */
403 	if (cq.sw_in_use) {
404 		swcqes[0] = chp->cq.sw_queue[cq.sw_cidx];
405 		if (cq.sw_in_use > 1) {
406 			idx = (cq.sw_pidx > 0) ? cq.sw_pidx - 1 : cq.size - 1;
407 			swcqes[1] = chp->cq.sw_queue[idx];
408 		}
409 	}
410 
411 	spin_unlock_irq(&chp->lock);
412 
413 	if (fill_cq(msg, &cq))
414 		goto err_cancel_table;
415 
416 	if (fill_swcqes(msg, &cq, swcqes))
417 		goto err_cancel_table;
418 
419 	if (fill_hwcqes(msg, &cq, hwcqes))
420 		goto err_cancel_table;
421 
422 	nla_nest_end(msg, table_attr);
423 	return 0;
424 
425 err_cancel_table:
426 	nla_nest_cancel(msg, table_attr);
427 err:
428 	return -EMSGSIZE;
429 }
430 
431 int c4iw_fill_res_mr_entry(struct sk_buff *msg, struct ib_mr *ibmr)
432 {
433 	struct c4iw_mr *mhp = to_c4iw_mr(ibmr);
434 	struct c4iw_dev *dev = mhp->rhp;
435 	u32 stag = mhp->attr.stag;
436 	struct nlattr *table_attr;
437 	struct fw_ri_tpte tpte;
438 	int ret;
439 
440 	if (!stag)
441 		return 0;
442 
443 	table_attr = nla_nest_start_noflag(msg, RDMA_NLDEV_ATTR_DRIVER);
444 	if (!table_attr)
445 		goto err;
446 
447 	ret = cxgb4_read_tpte(dev->rdev.lldi.ports[0], stag, (__be32 *)&tpte);
448 	if (ret) {
449 		dev_err(&dev->rdev.lldi.pdev->dev,
450 			"%s cxgb4_read_tpte err %d\n", __func__, ret);
451 		return 0;
452 	}
453 
454 	if (rdma_nl_put_driver_u32_hex(msg, "idx", stag >> 8))
455 		goto err_cancel_table;
456 	if (rdma_nl_put_driver_u32(msg, "valid",
457 			FW_RI_TPTE_VALID_G(ntohl(tpte.valid_to_pdid))))
458 		goto err_cancel_table;
459 	if (rdma_nl_put_driver_u32_hex(msg, "key", stag & 0xff))
460 		goto err_cancel_table;
461 	if (rdma_nl_put_driver_u32(msg, "state",
462 			FW_RI_TPTE_STAGSTATE_G(ntohl(tpte.valid_to_pdid))))
463 		goto err_cancel_table;
464 	if (rdma_nl_put_driver_u32(msg, "pdid",
465 			FW_RI_TPTE_PDID_G(ntohl(tpte.valid_to_pdid))))
466 		goto err_cancel_table;
467 	if (rdma_nl_put_driver_u32_hex(msg, "perm",
468 			FW_RI_TPTE_PERM_G(ntohl(tpte.locread_to_qpid))))
469 		goto err_cancel_table;
470 	if (rdma_nl_put_driver_u32(msg, "ps",
471 			FW_RI_TPTE_PS_G(ntohl(tpte.locread_to_qpid))))
472 		goto err_cancel_table;
473 	if (rdma_nl_put_driver_u64(msg, "len",
474 		      ((u64)ntohl(tpte.len_hi) << 32) | ntohl(tpte.len_lo)))
475 		goto err_cancel_table;
476 	if (rdma_nl_put_driver_u32_hex(msg, "pbl_addr",
477 			FW_RI_TPTE_PBLADDR_G(ntohl(tpte.nosnoop_pbladdr))))
478 		goto err_cancel_table;
479 
480 	nla_nest_end(msg, table_attr);
481 	return 0;
482 
483 err_cancel_table:
484 	nla_nest_cancel(msg, table_attr);
485 err:
486 	return -EMSGSIZE;
487 }
488