drivers/infiniband/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/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 "UNKOWN 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("Transistioned %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 }