hw/usnic/usnic_ib_qp_grp.c

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