1 /*
2  * Copyright (c) 2013, Cisco Systems, 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  * 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/bug.h>
34 #include <linux/errno.h>
35 #include <linux/module.h>
36 #include <linux/spinlock.h>
37 
38 #include "usnic_log.h"
39 #include "usnic_vnic.h"
40 #include "usnic_fwd.h"
41 #include "usnic_uiom.h"
42 #include "usnic_debugfs.h"
43 #include "usnic_ib_qp_grp.h"
44 #include "usnic_ib_sysfs.h"
45 #include "usnic_transport.h"
46 
47 #define DFLT_RQ_IDX	0
48 
49 const char *usnic_ib_qp_grp_state_to_string(enum ib_qp_state state)
50 {
51 	switch (state) {
52 	case IB_QPS_RESET:
53 		return "Rst";
54 	case IB_QPS_INIT:
55 		return "Init";
56 	case IB_QPS_RTR:
57 		return "RTR";
58 	case IB_QPS_RTS:
59 		return "RTS";
60 	case IB_QPS_SQD:
61 		return "SQD";
62 	case IB_QPS_SQE:
63 		return "SQE";
64 	case IB_QPS_ERR:
65 		return "ERR";
66 	default:
67 		return "UNKNOWN STATE";
68 
69 	}
70 }
71 
72 int usnic_ib_qp_grp_dump_hdr(char *buf, int buf_sz)
73 {
74 	return scnprintf(buf, buf_sz, "|QPN\t|State\t|PID\t|VF Idx\t|Fil ID");
75 }
76 
77 int usnic_ib_qp_grp_dump_rows(void *obj, char *buf, int buf_sz)
78 {
79 	struct usnic_ib_qp_grp *qp_grp = obj;
80 	struct usnic_ib_qp_grp_flow *default_flow;
81 	if (obj) {
82 		default_flow = list_first_entry(&qp_grp->flows_lst,
83 					struct usnic_ib_qp_grp_flow, link);
84 		return scnprintf(buf, buf_sz, "|%d\t|%s\t|%d\t|%hu\t|%d",
85 					qp_grp->ibqp.qp_num,
86 					usnic_ib_qp_grp_state_to_string(
87 							qp_grp->state),
88 					qp_grp->owner_pid,
89 					usnic_vnic_get_index(qp_grp->vf->vnic),
90 					default_flow->flow->flow_id);
91 	} else {
92 		return scnprintf(buf, buf_sz, "|N/A\t|N/A\t|N/A\t|N/A\t|N/A");
93 	}
94 }
95 
96 static struct usnic_vnic_res_chunk *
97 get_qp_res_chunk(struct usnic_ib_qp_grp *qp_grp)
98 {
99 	lockdep_assert_held(&qp_grp->lock);
100 	/*
101 	 * The QP res chunk, used to derive qp indices,
102 	 * are just indices of the RQs
103 	 */
104 	return usnic_ib_qp_grp_get_chunk(qp_grp, USNIC_VNIC_RES_TYPE_RQ);
105 }
106 
107 static int enable_qp_grp(struct usnic_ib_qp_grp *qp_grp)
108 {
109 
110 	int status;
111 	int i, vnic_idx;
112 	struct usnic_vnic_res_chunk *res_chunk;
113 	struct usnic_vnic_res *res;
114 
115 	lockdep_assert_held(&qp_grp->lock);
116 
117 	vnic_idx = usnic_vnic_get_index(qp_grp->vf->vnic);
118 
119 	res_chunk = get_qp_res_chunk(qp_grp);
120 	if (IS_ERR_OR_NULL(res_chunk)) {
121 		usnic_err("Unable to get qp res with err %ld\n",
122 				PTR_ERR(res_chunk));
123 		return res_chunk ? PTR_ERR(res_chunk) : -ENOMEM;
124 	}
125 
126 	for (i = 0; i < res_chunk->cnt; i++) {
127 		res = res_chunk->res[i];
128 		status = usnic_fwd_enable_qp(qp_grp->ufdev, vnic_idx,
129 						res->vnic_idx);
130 		if (status) {
131 			usnic_err("Failed to enable qp %d of %s:%d\n with err %d\n",
132 					res->vnic_idx, qp_grp->ufdev->name,
133 					vnic_idx, status);
134 			goto out_err;
135 		}
136 	}
137 
138 	return 0;
139 
140 out_err:
141 	for (i--; i >= 0; i--) {
142 		res = res_chunk->res[i];
143 		usnic_fwd_disable_qp(qp_grp->ufdev, vnic_idx,
144 					res->vnic_idx);
145 	}
146 
147 	return status;
148 }
149 
150 static int disable_qp_grp(struct usnic_ib_qp_grp *qp_grp)
151 {
152 	int i, vnic_idx;
153 	struct usnic_vnic_res_chunk *res_chunk;
154 	struct usnic_vnic_res *res;
155 	int status = 0;
156 
157 	lockdep_assert_held(&qp_grp->lock);
158 	vnic_idx = usnic_vnic_get_index(qp_grp->vf->vnic);
159 
160 	res_chunk = get_qp_res_chunk(qp_grp);
161 	if (IS_ERR_OR_NULL(res_chunk)) {
162 		usnic_err("Unable to get qp res with err %ld\n",
163 			PTR_ERR(res_chunk));
164 		return res_chunk ? PTR_ERR(res_chunk) : -ENOMEM;
165 	}
166 
167 	for (i = 0; i < res_chunk->cnt; i++) {
168 		res = res_chunk->res[i];
169 		status = usnic_fwd_disable_qp(qp_grp->ufdev, vnic_idx,
170 						res->vnic_idx);
171 		if (status) {
172 			usnic_err("Failed to disable rq %d of %s:%d\n with err %d\n",
173 					res->vnic_idx,
174 					qp_grp->ufdev->name,
175 					vnic_idx, status);
176 		}
177 	}
178 
179 	return status;
180 
181 }
182 
183 static int init_filter_action(struct usnic_ib_qp_grp *qp_grp,
184 				struct usnic_filter_action *uaction)
185 {
186 	struct usnic_vnic_res_chunk *res_chunk;
187 
188 	res_chunk = usnic_ib_qp_grp_get_chunk(qp_grp, USNIC_VNIC_RES_TYPE_RQ);
189 	if (IS_ERR_OR_NULL(res_chunk)) {
190 		usnic_err("Unable to get %s with err %ld\n",
191 			usnic_vnic_res_type_to_str(USNIC_VNIC_RES_TYPE_RQ),
192 			PTR_ERR(res_chunk));
193 		return res_chunk ? PTR_ERR(res_chunk) : -ENOMEM;
194 	}
195 
196 	uaction->vnic_idx = usnic_vnic_get_index(qp_grp->vf->vnic);
197 	uaction->action.type = FILTER_ACTION_RQ_STEERING;
198 	uaction->action.u.rq_idx = res_chunk->res[DFLT_RQ_IDX]->vnic_idx;
199 
200 	return 0;
201 }
202 
203 static struct usnic_ib_qp_grp_flow*
204 create_roce_custom_flow(struct usnic_ib_qp_grp *qp_grp,
205 			struct usnic_transport_spec *trans_spec)
206 {
207 	uint16_t port_num;
208 	int err;
209 	struct filter filter;
210 	struct usnic_filter_action uaction;
211 	struct usnic_ib_qp_grp_flow *qp_flow;
212 	struct usnic_fwd_flow *flow;
213 	enum usnic_transport_type trans_type;
214 
215 	trans_type = trans_spec->trans_type;
216 	port_num = trans_spec->usnic_roce.port_num;
217 
218 	/* Reserve Port */
219 	port_num = usnic_transport_rsrv_port(trans_type, port_num);
220 	if (port_num == 0)
221 		return ERR_PTR(-EINVAL);
222 
223 	/* Create Flow */
224 	usnic_fwd_init_usnic_filter(&filter, port_num);
225 	err = init_filter_action(qp_grp, &uaction);
226 	if (err)
227 		goto out_unreserve_port;
228 
229 	flow = usnic_fwd_alloc_flow(qp_grp->ufdev, &filter, &uaction);
230 	if (IS_ERR_OR_NULL(flow)) {
231 		usnic_err("Unable to alloc flow failed with err %ld\n",
232 				PTR_ERR(flow));
233 		err = flow ? PTR_ERR(flow) : -EFAULT;
234 		goto out_unreserve_port;
235 	}
236 
237 	/* Create Flow Handle */
238 	qp_flow = kzalloc(sizeof(*qp_flow), GFP_ATOMIC);
239 	if (!qp_flow) {
240 		err = -ENOMEM;
241 		goto out_dealloc_flow;
242 	}
243 	qp_flow->flow = flow;
244 	qp_flow->trans_type = trans_type;
245 	qp_flow->usnic_roce.port_num = port_num;
246 	qp_flow->qp_grp = qp_grp;
247 	return qp_flow;
248 
249 out_dealloc_flow:
250 	usnic_fwd_dealloc_flow(flow);
251 out_unreserve_port:
252 	usnic_transport_unrsrv_port(trans_type, port_num);
253 	return ERR_PTR(err);
254 }
255 
256 static void release_roce_custom_flow(struct usnic_ib_qp_grp_flow *qp_flow)
257 {
258 	usnic_fwd_dealloc_flow(qp_flow->flow);
259 	usnic_transport_unrsrv_port(qp_flow->trans_type,
260 					qp_flow->usnic_roce.port_num);
261 	kfree(qp_flow);
262 }
263 
264 static struct usnic_ib_qp_grp_flow*
265 create_udp_flow(struct usnic_ib_qp_grp *qp_grp,
266 		struct usnic_transport_spec *trans_spec)
267 {
268 	struct socket *sock;
269 	int sock_fd;
270 	int err;
271 	struct filter filter;
272 	struct usnic_filter_action uaction;
273 	struct usnic_ib_qp_grp_flow *qp_flow;
274 	struct usnic_fwd_flow *flow;
275 	enum usnic_transport_type trans_type;
276 	uint32_t addr;
277 	uint16_t port_num;
278 	int proto;
279 
280 	trans_type = trans_spec->trans_type;
281 	sock_fd = trans_spec->udp.sock_fd;
282 
283 	/* Get and check socket */
284 	sock = usnic_transport_get_socket(sock_fd);
285 	if (IS_ERR_OR_NULL(sock))
286 		return ERR_CAST(sock);
287 
288 	err = usnic_transport_sock_get_addr(sock, &proto, &addr, &port_num);
289 	if (err)
290 		goto out_put_sock;
291 
292 	if (proto != IPPROTO_UDP) {
293 		usnic_err("Protocol for fd %d is not UDP", sock_fd);
294 		err = -EPERM;
295 		goto out_put_sock;
296 	}
297 
298 	/* Create flow */
299 	usnic_fwd_init_udp_filter(&filter, addr, port_num);
300 	err = init_filter_action(qp_grp, &uaction);
301 	if (err)
302 		goto out_put_sock;
303 
304 	flow = usnic_fwd_alloc_flow(qp_grp->ufdev, &filter, &uaction);
305 	if (IS_ERR_OR_NULL(flow)) {
306 		usnic_err("Unable to alloc flow failed with err %ld\n",
307 				PTR_ERR(flow));
308 		err = flow ? PTR_ERR(flow) : -EFAULT;
309 		goto out_put_sock;
310 	}
311 
312 	/* Create qp_flow */
313 	qp_flow = kzalloc(sizeof(*qp_flow), GFP_ATOMIC);
314 	if (!qp_flow) {
315 		err = -ENOMEM;
316 		goto out_dealloc_flow;
317 	}
318 	qp_flow->flow = flow;
319 	qp_flow->trans_type = trans_type;
320 	qp_flow->udp.sock = sock;
321 	qp_flow->qp_grp = qp_grp;
322 	return qp_flow;
323 
324 out_dealloc_flow:
325 	usnic_fwd_dealloc_flow(flow);
326 out_put_sock:
327 	usnic_transport_put_socket(sock);
328 	return ERR_PTR(err);
329 }
330 
331 static void release_udp_flow(struct usnic_ib_qp_grp_flow *qp_flow)
332 {
333 	usnic_fwd_dealloc_flow(qp_flow->flow);
334 	usnic_transport_put_socket(qp_flow->udp.sock);
335 	kfree(qp_flow);
336 }
337 
338 static struct usnic_ib_qp_grp_flow*
339 create_and_add_flow(struct usnic_ib_qp_grp *qp_grp,
340 			struct usnic_transport_spec *trans_spec)
341 {
342 	struct usnic_ib_qp_grp_flow *qp_flow;
343 	enum usnic_transport_type trans_type;
344 
345 	trans_type = trans_spec->trans_type;
346 	switch (trans_type) {
347 	case USNIC_TRANSPORT_ROCE_CUSTOM:
348 		qp_flow = create_roce_custom_flow(qp_grp, trans_spec);
349 		break;
350 	case USNIC_TRANSPORT_IPV4_UDP:
351 		qp_flow = create_udp_flow(qp_grp, trans_spec);
352 		break;
353 	default:
354 		usnic_err("Unsupported transport %u\n",
355 				trans_spec->trans_type);
356 		return ERR_PTR(-EINVAL);
357 	}
358 
359 	if (!IS_ERR_OR_NULL(qp_flow)) {
360 		list_add_tail(&qp_flow->link, &qp_grp->flows_lst);
361 		usnic_debugfs_flow_add(qp_flow);
362 	}
363 
364 
365 	return qp_flow;
366 }
367 
368 static void release_and_remove_flow(struct usnic_ib_qp_grp_flow *qp_flow)
369 {
370 	usnic_debugfs_flow_remove(qp_flow);
371 	list_del(&qp_flow->link);
372 
373 	switch (qp_flow->trans_type) {
374 	case USNIC_TRANSPORT_ROCE_CUSTOM:
375 		release_roce_custom_flow(qp_flow);
376 		break;
377 	case USNIC_TRANSPORT_IPV4_UDP:
378 		release_udp_flow(qp_flow);
379 		break;
380 	default:
381 		WARN(1, "Unsupported transport %u\n",
382 				qp_flow->trans_type);
383 		break;
384 	}
385 }
386 
387 static void release_and_remove_all_flows(struct usnic_ib_qp_grp *qp_grp)
388 {
389 	struct usnic_ib_qp_grp_flow *qp_flow, *tmp;
390 	list_for_each_entry_safe(qp_flow, tmp, &qp_grp->flows_lst, link)
391 		release_and_remove_flow(qp_flow);
392 }
393 
394 int usnic_ib_qp_grp_modify(struct usnic_ib_qp_grp *qp_grp,
395 				enum ib_qp_state new_state,
396 				void *data)
397 {
398 	int status = 0;
399 	int vnic_idx;
400 	struct ib_event ib_event;
401 	enum ib_qp_state old_state;
402 	struct usnic_transport_spec *trans_spec;
403 	struct usnic_ib_qp_grp_flow *qp_flow;
404 
405 	old_state = qp_grp->state;
406 	vnic_idx = usnic_vnic_get_index(qp_grp->vf->vnic);
407 	trans_spec = (struct usnic_transport_spec *) data;
408 
409 	spin_lock(&qp_grp->lock);
410 	switch (new_state) {
411 	case IB_QPS_RESET:
412 		switch (old_state) {
413 		case IB_QPS_RESET:
414 			/* NO-OP */
415 			break;
416 		case IB_QPS_INIT:
417 			release_and_remove_all_flows(qp_grp);
418 			status = 0;
419 			break;
420 		case IB_QPS_RTR:
421 		case IB_QPS_RTS:
422 		case IB_QPS_ERR:
423 			status = disable_qp_grp(qp_grp);
424 			release_and_remove_all_flows(qp_grp);
425 			break;
426 		default:
427 			status = -EINVAL;
428 		}
429 		break;
430 	case IB_QPS_INIT:
431 		switch (old_state) {
432 		case IB_QPS_RESET:
433 			if (trans_spec) {
434 				qp_flow = create_and_add_flow(qp_grp,
435 								trans_spec);
436 				if (IS_ERR_OR_NULL(qp_flow)) {
437 					status = qp_flow ? PTR_ERR(qp_flow) : -EFAULT;
438 					break;
439 				}
440 			} else {
441 				/*
442 				 * Optional to specify filters.
443 				 */
444 				status = 0;
445 			}
446 			break;
447 		case IB_QPS_INIT:
448 			if (trans_spec) {
449 				qp_flow = create_and_add_flow(qp_grp,
450 								trans_spec);
451 				if (IS_ERR_OR_NULL(qp_flow)) {
452 					status = qp_flow ? PTR_ERR(qp_flow) : -EFAULT;
453 					break;
454 				}
455 			} else {
456 				/*
457 				 * Doesn't make sense to go into INIT state
458 				 * from INIT state w/o adding filters.
459 				 */
460 				status = -EINVAL;
461 			}
462 			break;
463 		case IB_QPS_RTR:
464 			status = disable_qp_grp(qp_grp);
465 			break;
466 		case IB_QPS_RTS:
467 			status = disable_qp_grp(qp_grp);
468 			break;
469 		default:
470 			status = -EINVAL;
471 		}
472 		break;
473 	case IB_QPS_RTR:
474 		switch (old_state) {
475 		case IB_QPS_INIT:
476 			status = enable_qp_grp(qp_grp);
477 			break;
478 		default:
479 			status = -EINVAL;
480 		}
481 		break;
482 	case IB_QPS_RTS:
483 		switch (old_state) {
484 		case IB_QPS_RTR:
485 			/* NO-OP FOR NOW */
486 			break;
487 		default:
488 			status = -EINVAL;
489 		}
490 		break;
491 	case IB_QPS_ERR:
492 		ib_event.device = &qp_grp->vf->pf->ib_dev;
493 		ib_event.element.qp = &qp_grp->ibqp;
494 		ib_event.event = IB_EVENT_QP_FATAL;
495 
496 		switch (old_state) {
497 		case IB_QPS_RESET:
498 			qp_grp->ibqp.event_handler(&ib_event,
499 					qp_grp->ibqp.qp_context);
500 			break;
501 		case IB_QPS_INIT:
502 			release_and_remove_all_flows(qp_grp);
503 			qp_grp->ibqp.event_handler(&ib_event,
504 					qp_grp->ibqp.qp_context);
505 			break;
506 		case IB_QPS_RTR:
507 		case IB_QPS_RTS:
508 			status = disable_qp_grp(qp_grp);
509 			release_and_remove_all_flows(qp_grp);
510 			qp_grp->ibqp.event_handler(&ib_event,
511 					qp_grp->ibqp.qp_context);
512 			break;
513 		default:
514 			status = -EINVAL;
515 		}
516 		break;
517 	default:
518 		status = -EINVAL;
519 	}
520 	spin_unlock(&qp_grp->lock);
521 
522 	if (!status) {
523 		qp_grp->state = new_state;
524 		usnic_info("Transitioned %u from %s to %s",
525 		qp_grp->grp_id,
526 		usnic_ib_qp_grp_state_to_string(old_state),
527 		usnic_ib_qp_grp_state_to_string(new_state));
528 	} else {
529 		usnic_err("Failed to transition %u from %s to %s",
530 		qp_grp->grp_id,
531 		usnic_ib_qp_grp_state_to_string(old_state),
532 		usnic_ib_qp_grp_state_to_string(new_state));
533 	}
534 
535 	return status;
536 }
537 
538 static struct usnic_vnic_res_chunk**
539 alloc_res_chunk_list(struct usnic_vnic *vnic,
540 			struct usnic_vnic_res_spec *res_spec, void *owner_obj)
541 {
542 	enum usnic_vnic_res_type res_type;
543 	struct usnic_vnic_res_chunk **res_chunk_list;
544 	int err, i, res_cnt, res_lst_sz;
545 
546 	for (res_lst_sz = 0;
547 		res_spec->resources[res_lst_sz].type != USNIC_VNIC_RES_TYPE_EOL;
548 		res_lst_sz++) {
549 		/* Do Nothing */
550 	}
551 
552 	res_chunk_list = kzalloc(sizeof(*res_chunk_list)*(res_lst_sz+1),
553 					GFP_ATOMIC);
554 	if (!res_chunk_list)
555 		return ERR_PTR(-ENOMEM);
556 
557 	for (i = 0; res_spec->resources[i].type != USNIC_VNIC_RES_TYPE_EOL;
558 		i++) {
559 		res_type = res_spec->resources[i].type;
560 		res_cnt = res_spec->resources[i].cnt;
561 
562 		res_chunk_list[i] = usnic_vnic_get_resources(vnic, res_type,
563 					res_cnt, owner_obj);
564 		if (IS_ERR_OR_NULL(res_chunk_list[i])) {
565 			err = res_chunk_list[i] ?
566 					PTR_ERR(res_chunk_list[i]) : -ENOMEM;
567 			usnic_err("Failed to get %s from %s with err %d\n",
568 				usnic_vnic_res_type_to_str(res_type),
569 				usnic_vnic_pci_name(vnic),
570 				err);
571 			goto out_free_res;
572 		}
573 	}
574 
575 	return res_chunk_list;
576 
577 out_free_res:
578 	for (i--; i >= 0; i--)
579 		usnic_vnic_put_resources(res_chunk_list[i]);
580 	kfree(res_chunk_list);
581 	return ERR_PTR(err);
582 }
583 
584 static void free_qp_grp_res(struct usnic_vnic_res_chunk **res_chunk_list)
585 {
586 	int i;
587 	for (i = 0; res_chunk_list[i]; i++)
588 		usnic_vnic_put_resources(res_chunk_list[i]);
589 	kfree(res_chunk_list);
590 }
591 
592 static int qp_grp_and_vf_bind(struct usnic_ib_vf *vf,
593 				struct usnic_ib_pd *pd,
594 				struct usnic_ib_qp_grp *qp_grp)
595 {
596 	int err;
597 	struct pci_dev *pdev;
598 
599 	lockdep_assert_held(&vf->lock);
600 
601 	pdev = usnic_vnic_get_pdev(vf->vnic);
602 	if (vf->qp_grp_ref_cnt == 0) {
603 		err = usnic_uiom_attach_dev_to_pd(pd->umem_pd, &pdev->dev);
604 		if (err) {
605 			usnic_err("Failed to attach %s to domain\n",
606 					pci_name(pdev));
607 			return err;
608 		}
609 		vf->pd = pd;
610 	}
611 	vf->qp_grp_ref_cnt++;
612 
613 	WARN_ON(vf->pd != pd);
614 	qp_grp->vf = vf;
615 
616 	return 0;
617 }
618 
619 static void qp_grp_and_vf_unbind(struct usnic_ib_qp_grp *qp_grp)
620 {
621 	struct pci_dev *pdev;
622 	struct usnic_ib_pd *pd;
623 
624 	lockdep_assert_held(&qp_grp->vf->lock);
625 
626 	pd = qp_grp->vf->pd;
627 	pdev = usnic_vnic_get_pdev(qp_grp->vf->vnic);
628 	if (--qp_grp->vf->qp_grp_ref_cnt == 0) {
629 		qp_grp->vf->pd = NULL;
630 		usnic_uiom_detach_dev_from_pd(pd->umem_pd, &pdev->dev);
631 	}
632 	qp_grp->vf = NULL;
633 }
634 
635 static void log_spec(struct usnic_vnic_res_spec *res_spec)
636 {
637 	char buf[512];
638 	usnic_vnic_spec_dump(buf, sizeof(buf), res_spec);
639 	usnic_dbg("%s\n", buf);
640 }
641 
642 static int qp_grp_id_from_flow(struct usnic_ib_qp_grp_flow *qp_flow,
643 				uint32_t *id)
644 {
645 	enum usnic_transport_type trans_type = qp_flow->trans_type;
646 	int err;
647 	uint16_t port_num = 0;
648 
649 	switch (trans_type) {
650 	case USNIC_TRANSPORT_ROCE_CUSTOM:
651 		*id = qp_flow->usnic_roce.port_num;
652 		break;
653 	case USNIC_TRANSPORT_IPV4_UDP:
654 		err = usnic_transport_sock_get_addr(qp_flow->udp.sock,
655 							NULL, NULL,
656 							&port_num);
657 		if (err)
658 			return err;
659 		/*
660 		 * Copy port_num to stack first and then to *id,
661 		 * so that the short to int cast works for little
662 		 * and big endian systems.
663 		 */
664 		*id = port_num;
665 		break;
666 	default:
667 		usnic_err("Unsupported transport %u\n", trans_type);
668 		return -EINVAL;
669 	}
670 
671 	return 0;
672 }
673 
674 struct usnic_ib_qp_grp *
675 usnic_ib_qp_grp_create(struct usnic_fwd_dev *ufdev, struct usnic_ib_vf *vf,
676 			struct usnic_ib_pd *pd,
677 			struct usnic_vnic_res_spec *res_spec,
678 			struct usnic_transport_spec *transport_spec)
679 {
680 	struct usnic_ib_qp_grp *qp_grp;
681 	int err;
682 	enum usnic_transport_type transport = transport_spec->trans_type;
683 	struct usnic_ib_qp_grp_flow *qp_flow;
684 
685 	lockdep_assert_held(&vf->lock);
686 
687 	err = usnic_vnic_res_spec_satisfied(&min_transport_spec[transport],
688 						res_spec);
689 	if (err) {
690 		usnic_err("Spec does not meet miniumum req for transport %d\n",
691 				transport);
692 		log_spec(res_spec);
693 		return ERR_PTR(err);
694 	}
695 
696 	qp_grp = kzalloc(sizeof(*qp_grp), GFP_ATOMIC);
697 	if (!qp_grp) {
698 		usnic_err("Unable to alloc qp_grp - Out of memory\n");
699 		return NULL;
700 	}
701 
702 	qp_grp->res_chunk_list = alloc_res_chunk_list(vf->vnic, res_spec,
703 							qp_grp);
704 	if (IS_ERR_OR_NULL(qp_grp->res_chunk_list)) {
705 		err = qp_grp->res_chunk_list ?
706 				PTR_ERR(qp_grp->res_chunk_list) : -ENOMEM;
707 		usnic_err("Unable to alloc res for %d with err %d\n",
708 				qp_grp->grp_id, err);
709 		goto out_free_qp_grp;
710 	}
711 
712 	err = qp_grp_and_vf_bind(vf, pd, qp_grp);
713 	if (err)
714 		goto out_free_res;
715 
716 	INIT_LIST_HEAD(&qp_grp->flows_lst);
717 	spin_lock_init(&qp_grp->lock);
718 	qp_grp->ufdev = ufdev;
719 	qp_grp->state = IB_QPS_RESET;
720 	qp_grp->owner_pid = current->pid;
721 
722 	qp_flow = create_and_add_flow(qp_grp, transport_spec);
723 	if (IS_ERR_OR_NULL(qp_flow)) {
724 		usnic_err("Unable to create and add flow with err %ld\n",
725 				PTR_ERR(qp_flow));
726 		err = qp_flow ? PTR_ERR(qp_flow) : -EFAULT;
727 		goto out_qp_grp_vf_unbind;
728 	}
729 
730 	err = qp_grp_id_from_flow(qp_flow, &qp_grp->grp_id);
731 	if (err)
732 		goto out_release_flow;
733 	qp_grp->ibqp.qp_num = qp_grp->grp_id;
734 
735 	usnic_ib_sysfs_qpn_add(qp_grp);
736 
737 	return qp_grp;
738 
739 out_release_flow:
740 	release_and_remove_flow(qp_flow);
741 out_qp_grp_vf_unbind:
742 	qp_grp_and_vf_unbind(qp_grp);
743 out_free_res:
744 	free_qp_grp_res(qp_grp->res_chunk_list);
745 out_free_qp_grp:
746 	kfree(qp_grp);
747 
748 	return ERR_PTR(err);
749 }
750 
751 void usnic_ib_qp_grp_destroy(struct usnic_ib_qp_grp *qp_grp)
752 {
753 
754 	WARN_ON(qp_grp->state != IB_QPS_RESET);
755 	lockdep_assert_held(&qp_grp->vf->lock);
756 
757 	release_and_remove_all_flows(qp_grp);
758 	usnic_ib_sysfs_qpn_remove(qp_grp);
759 	qp_grp_and_vf_unbind(qp_grp);
760 	free_qp_grp_res(qp_grp->res_chunk_list);
761 	kfree(qp_grp);
762 }
763 
764 struct usnic_vnic_res_chunk*
765 usnic_ib_qp_grp_get_chunk(struct usnic_ib_qp_grp *qp_grp,
766 				enum usnic_vnic_res_type res_type)
767 {
768 	int i;
769 
770 	for (i = 0; qp_grp->res_chunk_list[i]; i++) {
771 		if (qp_grp->res_chunk_list[i]->type == res_type)
772 			return qp_grp->res_chunk_list[i];
773 	}
774 
775 	return ERR_PTR(-EINVAL);
776 }
777