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(res_chunk)) {
121 		usnic_err("Unable to get qp res with err %ld\n",
122 				PTR_ERR(res_chunk));
123 		return PTR_ERR(res_chunk);
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(res_chunk)) {
162 		usnic_err("Unable to get qp res with err %ld\n",
163 			PTR_ERR(res_chunk));
164 		return PTR_ERR(res_chunk);
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(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 PTR_ERR(res_chunk);
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 		err = flow ? PTR_ERR(flow) : -EFAULT;
232 		goto out_unreserve_port;
233 	}
234 
235 	/* Create Flow Handle */
236 	qp_flow = kzalloc(sizeof(*qp_flow), GFP_ATOMIC);
237 	if (!qp_flow) {
238 		err = -ENOMEM;
239 		goto out_dealloc_flow;
240 	}
241 	qp_flow->flow = flow;
242 	qp_flow->trans_type = trans_type;
243 	qp_flow->usnic_roce.port_num = port_num;
244 	qp_flow->qp_grp = qp_grp;
245 	return qp_flow;
246 
247 out_dealloc_flow:
248 	usnic_fwd_dealloc_flow(flow);
249 out_unreserve_port:
250 	usnic_transport_unrsrv_port(trans_type, port_num);
251 	return ERR_PTR(err);
252 }
253 
254 static void release_roce_custom_flow(struct usnic_ib_qp_grp_flow *qp_flow)
255 {
256 	usnic_fwd_dealloc_flow(qp_flow->flow);
257 	usnic_transport_unrsrv_port(qp_flow->trans_type,
258 					qp_flow->usnic_roce.port_num);
259 	kfree(qp_flow);
260 }
261 
262 static struct usnic_ib_qp_grp_flow*
263 create_udp_flow(struct usnic_ib_qp_grp *qp_grp,
264 		struct usnic_transport_spec *trans_spec)
265 {
266 	struct socket *sock;
267 	int sock_fd;
268 	int err;
269 	struct filter filter;
270 	struct usnic_filter_action uaction;
271 	struct usnic_ib_qp_grp_flow *qp_flow;
272 	struct usnic_fwd_flow *flow;
273 	enum usnic_transport_type trans_type;
274 	uint32_t addr;
275 	uint16_t port_num;
276 	int proto;
277 
278 	trans_type = trans_spec->trans_type;
279 	sock_fd = trans_spec->udp.sock_fd;
280 
281 	/* Get and check socket */
282 	sock = usnic_transport_get_socket(sock_fd);
283 	if (IS_ERR_OR_NULL(sock))
284 		return ERR_CAST(sock);
285 
286 	err = usnic_transport_sock_get_addr(sock, &proto, &addr, &port_num);
287 	if (err)
288 		goto out_put_sock;
289 
290 	if (proto != IPPROTO_UDP) {
291 		usnic_err("Protocol for fd %d is not UDP", sock_fd);
292 		err = -EPERM;
293 		goto out_put_sock;
294 	}
295 
296 	/* Create flow */
297 	usnic_fwd_init_udp_filter(&filter, addr, port_num);
298 	err = init_filter_action(qp_grp, &uaction);
299 	if (err)
300 		goto out_put_sock;
301 
302 	flow = usnic_fwd_alloc_flow(qp_grp->ufdev, &filter, &uaction);
303 	if (IS_ERR_OR_NULL(flow)) {
304 		err = flow ? PTR_ERR(flow) : -EFAULT;
305 		goto out_put_sock;
306 	}
307 
308 	/* Create qp_flow */
309 	qp_flow = kzalloc(sizeof(*qp_flow), GFP_ATOMIC);
310 	if (!qp_flow) {
311 		err = -ENOMEM;
312 		goto out_dealloc_flow;
313 	}
314 	qp_flow->flow = flow;
315 	qp_flow->trans_type = trans_type;
316 	qp_flow->udp.sock = sock;
317 	qp_flow->qp_grp = qp_grp;
318 	return qp_flow;
319 
320 out_dealloc_flow:
321 	usnic_fwd_dealloc_flow(flow);
322 out_put_sock:
323 	usnic_transport_put_socket(sock);
324 	return ERR_PTR(err);
325 }
326 
327 static void release_udp_flow(struct usnic_ib_qp_grp_flow *qp_flow)
328 {
329 	usnic_fwd_dealloc_flow(qp_flow->flow);
330 	usnic_transport_put_socket(qp_flow->udp.sock);
331 	kfree(qp_flow);
332 }
333 
334 static struct usnic_ib_qp_grp_flow*
335 create_and_add_flow(struct usnic_ib_qp_grp *qp_grp,
336 			struct usnic_transport_spec *trans_spec)
337 {
338 	struct usnic_ib_qp_grp_flow *qp_flow;
339 	enum usnic_transport_type trans_type;
340 
341 	trans_type = trans_spec->trans_type;
342 	switch (trans_type) {
343 	case USNIC_TRANSPORT_ROCE_CUSTOM:
344 		qp_flow = create_roce_custom_flow(qp_grp, trans_spec);
345 		break;
346 	case USNIC_TRANSPORT_IPV4_UDP:
347 		qp_flow = create_udp_flow(qp_grp, trans_spec);
348 		break;
349 	default:
350 		usnic_err("Unsupported transport %u\n",
351 				trans_spec->trans_type);
352 		return ERR_PTR(-EINVAL);
353 	}
354 
355 	if (!IS_ERR_OR_NULL(qp_flow)) {
356 		list_add_tail(&qp_flow->link, &qp_grp->flows_lst);
357 		usnic_debugfs_flow_add(qp_flow);
358 	}
359 
360 
361 	return qp_flow;
362 }
363 
364 static void release_and_remove_flow(struct usnic_ib_qp_grp_flow *qp_flow)
365 {
366 	usnic_debugfs_flow_remove(qp_flow);
367 	list_del(&qp_flow->link);
368 
369 	switch (qp_flow->trans_type) {
370 	case USNIC_TRANSPORT_ROCE_CUSTOM:
371 		release_roce_custom_flow(qp_flow);
372 		break;
373 	case USNIC_TRANSPORT_IPV4_UDP:
374 		release_udp_flow(qp_flow);
375 		break;
376 	default:
377 		WARN(1, "Unsupported transport %u\n",
378 				qp_flow->trans_type);
379 		break;
380 	}
381 }
382 
383 static void release_and_remove_all_flows(struct usnic_ib_qp_grp *qp_grp)
384 {
385 	struct usnic_ib_qp_grp_flow *qp_flow, *tmp;
386 	list_for_each_entry_safe(qp_flow, tmp, &qp_grp->flows_lst, link)
387 		release_and_remove_flow(qp_flow);
388 }
389 
390 int usnic_ib_qp_grp_modify(struct usnic_ib_qp_grp *qp_grp,
391 				enum ib_qp_state new_state,
392 				void *data)
393 {
394 	int status = 0;
395 	struct ib_event ib_event;
396 	enum ib_qp_state old_state;
397 	struct usnic_transport_spec *trans_spec;
398 	struct usnic_ib_qp_grp_flow *qp_flow;
399 
400 	old_state = qp_grp->state;
401 	trans_spec = (struct usnic_transport_spec *) data;
402 
403 	spin_lock(&qp_grp->lock);
404 	switch (new_state) {
405 	case IB_QPS_RESET:
406 		switch (old_state) {
407 		case IB_QPS_RESET:
408 			/* NO-OP */
409 			break;
410 		case IB_QPS_INIT:
411 			release_and_remove_all_flows(qp_grp);
412 			status = 0;
413 			break;
414 		case IB_QPS_RTR:
415 		case IB_QPS_RTS:
416 		case IB_QPS_ERR:
417 			status = disable_qp_grp(qp_grp);
418 			release_and_remove_all_flows(qp_grp);
419 			break;
420 		default:
421 			status = -EINVAL;
422 		}
423 		break;
424 	case IB_QPS_INIT:
425 		switch (old_state) {
426 		case IB_QPS_RESET:
427 			if (trans_spec) {
428 				qp_flow = create_and_add_flow(qp_grp,
429 								trans_spec);
430 				if (IS_ERR_OR_NULL(qp_flow)) {
431 					status = qp_flow ? PTR_ERR(qp_flow) : -EFAULT;
432 					break;
433 				}
434 			} else {
435 				/*
436 				 * Optional to specify filters.
437 				 */
438 				status = 0;
439 			}
440 			break;
441 		case IB_QPS_INIT:
442 			if (trans_spec) {
443 				qp_flow = create_and_add_flow(qp_grp,
444 								trans_spec);
445 				if (IS_ERR_OR_NULL(qp_flow)) {
446 					status = qp_flow ? PTR_ERR(qp_flow) : -EFAULT;
447 					break;
448 				}
449 			} else {
450 				/*
451 				 * Doesn't make sense to go into INIT state
452 				 * from INIT state w/o adding filters.
453 				 */
454 				status = -EINVAL;
455 			}
456 			break;
457 		case IB_QPS_RTR:
458 			status = disable_qp_grp(qp_grp);
459 			break;
460 		case IB_QPS_RTS:
461 			status = disable_qp_grp(qp_grp);
462 			break;
463 		default:
464 			status = -EINVAL;
465 		}
466 		break;
467 	case IB_QPS_RTR:
468 		switch (old_state) {
469 		case IB_QPS_INIT:
470 			status = enable_qp_grp(qp_grp);
471 			break;
472 		default:
473 			status = -EINVAL;
474 		}
475 		break;
476 	case IB_QPS_RTS:
477 		switch (old_state) {
478 		case IB_QPS_RTR:
479 			/* NO-OP FOR NOW */
480 			break;
481 		default:
482 			status = -EINVAL;
483 		}
484 		break;
485 	case IB_QPS_ERR:
486 		ib_event.device = &qp_grp->vf->pf->ib_dev;
487 		ib_event.element.qp = &qp_grp->ibqp;
488 		ib_event.event = IB_EVENT_QP_FATAL;
489 
490 		switch (old_state) {
491 		case IB_QPS_RESET:
492 			qp_grp->ibqp.event_handler(&ib_event,
493 					qp_grp->ibqp.qp_context);
494 			break;
495 		case IB_QPS_INIT:
496 			release_and_remove_all_flows(qp_grp);
497 			qp_grp->ibqp.event_handler(&ib_event,
498 					qp_grp->ibqp.qp_context);
499 			break;
500 		case IB_QPS_RTR:
501 		case IB_QPS_RTS:
502 			status = disable_qp_grp(qp_grp);
503 			release_and_remove_all_flows(qp_grp);
504 			qp_grp->ibqp.event_handler(&ib_event,
505 					qp_grp->ibqp.qp_context);
506 			break;
507 		default:
508 			status = -EINVAL;
509 		}
510 		break;
511 	default:
512 		status = -EINVAL;
513 	}
514 	spin_unlock(&qp_grp->lock);
515 
516 	if (!status) {
517 		qp_grp->state = new_state;
518 		usnic_info("Transitioned %u from %s to %s",
519 		qp_grp->grp_id,
520 		usnic_ib_qp_grp_state_to_string(old_state),
521 		usnic_ib_qp_grp_state_to_string(new_state));
522 	} else {
523 		usnic_err("Failed to transition %u from %s to %s",
524 		qp_grp->grp_id,
525 		usnic_ib_qp_grp_state_to_string(old_state),
526 		usnic_ib_qp_grp_state_to_string(new_state));
527 	}
528 
529 	return status;
530 }
531 
532 static struct usnic_vnic_res_chunk**
533 alloc_res_chunk_list(struct usnic_vnic *vnic,
534 			struct usnic_vnic_res_spec *res_spec, void *owner_obj)
535 {
536 	enum usnic_vnic_res_type res_type;
537 	struct usnic_vnic_res_chunk **res_chunk_list;
538 	int err, i, res_cnt, res_lst_sz;
539 
540 	for (res_lst_sz = 0;
541 		res_spec->resources[res_lst_sz].type != USNIC_VNIC_RES_TYPE_EOL;
542 		res_lst_sz++) {
543 		/* Do Nothing */
544 	}
545 
546 	res_chunk_list = kzalloc(sizeof(*res_chunk_list)*(res_lst_sz+1),
547 					GFP_ATOMIC);
548 	if (!res_chunk_list)
549 		return ERR_PTR(-ENOMEM);
550 
551 	for (i = 0; res_spec->resources[i].type != USNIC_VNIC_RES_TYPE_EOL;
552 		i++) {
553 		res_type = res_spec->resources[i].type;
554 		res_cnt = res_spec->resources[i].cnt;
555 
556 		res_chunk_list[i] = usnic_vnic_get_resources(vnic, res_type,
557 					res_cnt, owner_obj);
558 		if (IS_ERR_OR_NULL(res_chunk_list[i])) {
559 			err = res_chunk_list[i] ?
560 					PTR_ERR(res_chunk_list[i]) : -ENOMEM;
561 			usnic_err("Failed to get %s from %s with err %d\n",
562 				usnic_vnic_res_type_to_str(res_type),
563 				usnic_vnic_pci_name(vnic),
564 				err);
565 			goto out_free_res;
566 		}
567 	}
568 
569 	return res_chunk_list;
570 
571 out_free_res:
572 	for (i--; i >= 0; i--)
573 		usnic_vnic_put_resources(res_chunk_list[i]);
574 	kfree(res_chunk_list);
575 	return ERR_PTR(err);
576 }
577 
578 static void free_qp_grp_res(struct usnic_vnic_res_chunk **res_chunk_list)
579 {
580 	int i;
581 	for (i = 0; res_chunk_list[i]; i++)
582 		usnic_vnic_put_resources(res_chunk_list[i]);
583 	kfree(res_chunk_list);
584 }
585 
586 static int qp_grp_and_vf_bind(struct usnic_ib_vf *vf,
587 				struct usnic_ib_pd *pd,
588 				struct usnic_ib_qp_grp *qp_grp)
589 {
590 	int err;
591 	struct pci_dev *pdev;
592 
593 	lockdep_assert_held(&vf->lock);
594 
595 	pdev = usnic_vnic_get_pdev(vf->vnic);
596 	if (vf->qp_grp_ref_cnt == 0) {
597 		err = usnic_uiom_attach_dev_to_pd(pd->umem_pd, &pdev->dev);
598 		if (err) {
599 			usnic_err("Failed to attach %s to domain\n",
600 					pci_name(pdev));
601 			return err;
602 		}
603 		vf->pd = pd;
604 	}
605 	vf->qp_grp_ref_cnt++;
606 
607 	WARN_ON(vf->pd != pd);
608 	qp_grp->vf = vf;
609 
610 	return 0;
611 }
612 
613 static void qp_grp_and_vf_unbind(struct usnic_ib_qp_grp *qp_grp)
614 {
615 	struct pci_dev *pdev;
616 	struct usnic_ib_pd *pd;
617 
618 	lockdep_assert_held(&qp_grp->vf->lock);
619 
620 	pd = qp_grp->vf->pd;
621 	pdev = usnic_vnic_get_pdev(qp_grp->vf->vnic);
622 	if (--qp_grp->vf->qp_grp_ref_cnt == 0) {
623 		qp_grp->vf->pd = NULL;
624 		usnic_uiom_detach_dev_from_pd(pd->umem_pd, &pdev->dev);
625 	}
626 	qp_grp->vf = NULL;
627 }
628 
629 static void log_spec(struct usnic_vnic_res_spec *res_spec)
630 {
631 	char buf[512];
632 	usnic_vnic_spec_dump(buf, sizeof(buf), res_spec);
633 	usnic_dbg("%s\n", buf);
634 }
635 
636 static int qp_grp_id_from_flow(struct usnic_ib_qp_grp_flow *qp_flow,
637 				uint32_t *id)
638 {
639 	enum usnic_transport_type trans_type = qp_flow->trans_type;
640 	int err;
641 	uint16_t port_num = 0;
642 
643 	switch (trans_type) {
644 	case USNIC_TRANSPORT_ROCE_CUSTOM:
645 		*id = qp_flow->usnic_roce.port_num;
646 		break;
647 	case USNIC_TRANSPORT_IPV4_UDP:
648 		err = usnic_transport_sock_get_addr(qp_flow->udp.sock,
649 							NULL, NULL,
650 							&port_num);
651 		if (err)
652 			return err;
653 		/*
654 		 * Copy port_num to stack first and then to *id,
655 		 * so that the short to int cast works for little
656 		 * and big endian systems.
657 		 */
658 		*id = port_num;
659 		break;
660 	default:
661 		usnic_err("Unsupported transport %u\n", trans_type);
662 		return -EINVAL;
663 	}
664 
665 	return 0;
666 }
667 
668 struct usnic_ib_qp_grp *
669 usnic_ib_qp_grp_create(struct usnic_fwd_dev *ufdev, struct usnic_ib_vf *vf,
670 			struct usnic_ib_pd *pd,
671 			struct usnic_vnic_res_spec *res_spec,
672 			struct usnic_transport_spec *transport_spec)
673 {
674 	struct usnic_ib_qp_grp *qp_grp;
675 	int err;
676 	enum usnic_transport_type transport = transport_spec->trans_type;
677 	struct usnic_ib_qp_grp_flow *qp_flow;
678 
679 	lockdep_assert_held(&vf->lock);
680 
681 	err = usnic_vnic_res_spec_satisfied(&min_transport_spec[transport],
682 						res_spec);
683 	if (err) {
684 		usnic_err("Spec does not meet miniumum req for transport %d\n",
685 				transport);
686 		log_spec(res_spec);
687 		return ERR_PTR(err);
688 	}
689 
690 	qp_grp = kzalloc(sizeof(*qp_grp), GFP_ATOMIC);
691 	if (!qp_grp)
692 		return NULL;
693 
694 	qp_grp->res_chunk_list = alloc_res_chunk_list(vf->vnic, res_spec,
695 							qp_grp);
696 	if (IS_ERR_OR_NULL(qp_grp->res_chunk_list)) {
697 		err = qp_grp->res_chunk_list ?
698 				PTR_ERR(qp_grp->res_chunk_list) : -ENOMEM;
699 		goto out_free_qp_grp;
700 	}
701 
702 	err = qp_grp_and_vf_bind(vf, pd, qp_grp);
703 	if (err)
704 		goto out_free_res;
705 
706 	INIT_LIST_HEAD(&qp_grp->flows_lst);
707 	spin_lock_init(&qp_grp->lock);
708 	qp_grp->ufdev = ufdev;
709 	qp_grp->state = IB_QPS_RESET;
710 	qp_grp->owner_pid = current->pid;
711 
712 	qp_flow = create_and_add_flow(qp_grp, transport_spec);
713 	if (IS_ERR_OR_NULL(qp_flow)) {
714 		usnic_err("Unable to create and add flow with err %ld\n",
715 				PTR_ERR(qp_flow));
716 		err = qp_flow ? PTR_ERR(qp_flow) : -EFAULT;
717 		goto out_qp_grp_vf_unbind;
718 	}
719 
720 	err = qp_grp_id_from_flow(qp_flow, &qp_grp->grp_id);
721 	if (err)
722 		goto out_release_flow;
723 	qp_grp->ibqp.qp_num = qp_grp->grp_id;
724 
725 	usnic_ib_sysfs_qpn_add(qp_grp);
726 
727 	return qp_grp;
728 
729 out_release_flow:
730 	release_and_remove_flow(qp_flow);
731 out_qp_grp_vf_unbind:
732 	qp_grp_and_vf_unbind(qp_grp);
733 out_free_res:
734 	free_qp_grp_res(qp_grp->res_chunk_list);
735 out_free_qp_grp:
736 	kfree(qp_grp);
737 
738 	return ERR_PTR(err);
739 }
740 
741 void usnic_ib_qp_grp_destroy(struct usnic_ib_qp_grp *qp_grp)
742 {
743 
744 	WARN_ON(qp_grp->state != IB_QPS_RESET);
745 	lockdep_assert_held(&qp_grp->vf->lock);
746 
747 	release_and_remove_all_flows(qp_grp);
748 	usnic_ib_sysfs_qpn_remove(qp_grp);
749 	qp_grp_and_vf_unbind(qp_grp);
750 	free_qp_grp_res(qp_grp->res_chunk_list);
751 	kfree(qp_grp);
752 }
753 
754 struct usnic_vnic_res_chunk*
755 usnic_ib_qp_grp_get_chunk(struct usnic_ib_qp_grp *qp_grp,
756 				enum usnic_vnic_res_type res_type)
757 {
758 	int i;
759 
760 	for (i = 0; qp_grp->res_chunk_list[i]; i++) {
761 		if (qp_grp->res_chunk_list[i]->type == res_type)
762 			return qp_grp->res_chunk_list[i];
763 	}
764 
765 	return ERR_PTR(-EINVAL);
766 }
767