drivers/infiniband/core/uverbs_std_types_qp.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /*
   3  * Copyright (c) 2020, Mellanox Technologies inc.  All rights reserved.
   4  */
   5
   6 #include <rdma/uverbs_std_types.h>
   7 #include "rdma_core.h"
   8 #include "uverbs.h"
   9 #include "core_priv.h"
  10
  11 static int uverbs_free_qp(struct ib_uobject *uobject,
  12                           enum rdma_remove_reason why,
  13                           struct uverbs_attr_bundle *attrs)
  14 {
  15         struct ib_qp *qp = uobject->object;
  16         struct ib_uqp_object *uqp =
  17                 container_of(uobject, struct ib_uqp_object, uevent.uobject);
  18         int ret;
  19
  20         /*
  21          * If this is a user triggered destroy then do not allow destruction
  22          * until the user cleans up all the mcast bindings. Unlike in other
  23          * places we forcibly clean up the mcast attachments for !DESTROY
  24          * because the mcast attaches are not ubojects and will not be
  25          * destroyed by anything else during cleanup processing.
  26          */
  27         if (why == RDMA_REMOVE_DESTROY) {
  28                 if (!list_empty(&uqp->mcast_list))
  29                         return -EBUSY;
  30         } else if (qp == qp->real_qp) {
  31                 ib_uverbs_detach_umcast(qp, uqp);
  32         }
  33
  34         ret = ib_destroy_qp_user(qp, &attrs->driver_udata);
  35         if (ret)
  36                 return ret;
  37
  38         if (uqp->uxrcd)
  39                 atomic_dec(&uqp->uxrcd->refcnt);
  40
  41         ib_uverbs_release_uevent(&uqp->uevent);
  42         return 0;
  43 }
  44
  45 static int check_creation_flags(enum ib_qp_type qp_type,
  46                                 u32 create_flags)
  47 {
  48         create_flags &= ~IB_UVERBS_QP_CREATE_SQ_SIG_ALL;
  49
  50         if (!create_flags || qp_type == IB_QPT_DRIVER)
  51                 return 0;
  52
  53         if (qp_type != IB_QPT_RAW_PACKET && qp_type != IB_QPT_UD)
  54                 return -EINVAL;
  55
  56         if ((create_flags & IB_UVERBS_QP_CREATE_SCATTER_FCS ||
  57              create_flags & IB_UVERBS_QP_CREATE_CVLAN_STRIPPING) &&
  58              qp_type != IB_QPT_RAW_PACKET)
  59                 return -EINVAL;
  60
  61         return 0;
  62 }
  63
  64 static void set_caps(struct ib_qp_init_attr *attr,
  65                      struct ib_uverbs_qp_cap *cap, bool req)
  66 {
  67         if (req) {
  68                 attr->cap.max_send_wr = cap->max_send_wr;
  69                 attr->cap.max_recv_wr = cap->max_recv_wr;
  70                 attr->cap.max_send_sge = cap->max_send_sge;
  71                 attr->cap.max_recv_sge = cap->max_recv_sge;
  72                 attr->cap.max_inline_data = cap->max_inline_data;
  73         } else {
  74                 cap->max_send_wr = attr->cap.max_send_wr;
  75                 cap->max_recv_wr = attr->cap.max_recv_wr;
  76                 cap->max_send_sge = attr->cap.max_send_sge;
  77                 cap->max_recv_sge = attr->cap.max_recv_sge;
  78                 cap->max_inline_data = attr->cap.max_inline_data;
  79         }
  80 }
  81
  82 static int UVERBS_HANDLER(UVERBS_METHOD_QP_CREATE)(
  83         struct uverbs_attr_bundle *attrs)
  84 {
  85         struct ib_uqp_object *obj = container_of(
  86                 uverbs_attr_get_uobject(attrs, UVERBS_ATTR_CREATE_QP_HANDLE),
  87                 typeof(*obj), uevent.uobject);
  88         struct ib_qp_init_attr attr = {};
  89         struct ib_uverbs_qp_cap cap = {};
  90         struct ib_rwq_ind_table *rwq_ind_tbl = NULL;
  91         struct ib_qp *qp;
  92         struct ib_pd *pd = NULL;
  93         struct ib_srq *srq = NULL;
  94         struct ib_cq *recv_cq = NULL;
  95         struct ib_cq *send_cq = NULL;
  96         struct ib_xrcd *xrcd = NULL;
  97         struct ib_uobject *xrcd_uobj = NULL;
  98         struct ib_device *device;
  99         u64 user_handle;
 100         int ret;
 101
 102         ret = uverbs_copy_from_or_zero(&cap, attrs,
 103                                UVERBS_ATTR_CREATE_QP_CAP);
 104         if (!ret)
 105                 ret = uverbs_copy_from(&user_handle, attrs,
 106                                        UVERBS_ATTR_CREATE_QP_USER_HANDLE);
 107         if (!ret)
 108                 ret = uverbs_get_const(&attr.qp_type, attrs,
 109                                        UVERBS_ATTR_CREATE_QP_TYPE);
 110         if (ret)
 111                 return ret;
 112
 113         switch (attr.qp_type) {
 114         case IB_QPT_XRC_TGT:
 115                 if (uverbs_attr_is_valid(attrs,
 116                                 UVERBS_ATTR_CREATE_QP_RECV_CQ_HANDLE) ||
 117                     uverbs_attr_is_valid(attrs,
 118                                 UVERBS_ATTR_CREATE_QP_SEND_CQ_HANDLE) ||
 119                     uverbs_attr_is_valid(attrs,
 120                                 UVERBS_ATTR_CREATE_QP_PD_HANDLE) ||
 121                     uverbs_attr_is_valid(attrs,
 122                                 UVERBS_ATTR_CREATE_QP_IND_TABLE_HANDLE))
 123                         return -EINVAL;
 124
 125                 xrcd_uobj = uverbs_attr_get_uobject(attrs,
 126                                         UVERBS_ATTR_CREATE_QP_XRCD_HANDLE);
 127                 if (IS_ERR(xrcd_uobj))
 128                         return PTR_ERR(xrcd_uobj);
 129
 130                 xrcd = (struct ib_xrcd *)xrcd_uobj->object;
 131                 if (!xrcd)
 132                         return -EINVAL;
 133                 device = xrcd->device;
 134                 break;
 135         case IB_UVERBS_QPT_RAW_PACKET:
 136                 if (!capable(CAP_NET_RAW))
 137                         return -EPERM;
 138                 fallthrough;
 139         case IB_UVERBS_QPT_RC:
 140         case IB_UVERBS_QPT_UC:
 141         case IB_UVERBS_QPT_UD:
 142         case IB_UVERBS_QPT_XRC_INI:
 143         case IB_UVERBS_QPT_DRIVER:
 144                 if (uverbs_attr_is_valid(attrs,
 145                                          UVERBS_ATTR_CREATE_QP_XRCD_HANDLE) ||
 146                    (uverbs_attr_is_valid(attrs,
 147                                          UVERBS_ATTR_CREATE_QP_SRQ_HANDLE) &&
 148                         attr.qp_type == IB_QPT_XRC_INI))
 149                         return -EINVAL;
 150
 151                 pd = uverbs_attr_get_obj(attrs,
 152                                          UVERBS_ATTR_CREATE_QP_PD_HANDLE);
 153                 if (IS_ERR(pd))
 154                         return PTR_ERR(pd);
 155
 156                 rwq_ind_tbl = uverbs_attr_get_obj(attrs,
 157                         UVERBS_ATTR_CREATE_QP_IND_TABLE_HANDLE);
 158                 if (!IS_ERR(rwq_ind_tbl)) {
 159                         if (cap.max_recv_wr || cap.max_recv_sge ||
 160                             uverbs_attr_is_valid(attrs,
 161                                 UVERBS_ATTR_CREATE_QP_RECV_CQ_HANDLE) ||
 162                             uverbs_attr_is_valid(attrs,
 163                                         UVERBS_ATTR_CREATE_QP_SRQ_HANDLE))
 164                                 return -EINVAL;
 165
 166                         /* send_cq is optinal */
 167                         if (cap.max_send_wr) {
 168                                 send_cq = uverbs_attr_get_obj(attrs,
 169                                         UVERBS_ATTR_CREATE_QP_SEND_CQ_HANDLE);
 170                                 if (IS_ERR(send_cq))
 171                                         return PTR_ERR(send_cq);
 172                         }
 173                         attr.rwq_ind_tbl = rwq_ind_tbl;
 174                 } else {
 175                         send_cq = uverbs_attr_get_obj(attrs,
 176                                         UVERBS_ATTR_CREATE_QP_SEND_CQ_HANDLE);
 177                         if (IS_ERR(send_cq))
 178                                 return PTR_ERR(send_cq);
 179
 180                         if (attr.qp_type != IB_QPT_XRC_INI) {
 181                                 recv_cq = uverbs_attr_get_obj(attrs,
 182                                         UVERBS_ATTR_CREATE_QP_RECV_CQ_HANDLE);
 183                                 if (IS_ERR(recv_cq))
 184                                         return PTR_ERR(recv_cq);
 185                         }
 186                 }
 187
 188                 device = pd->device;
 189                 break;
 190         default:
 191                 return -EINVAL;
 192         }
 193
 194         ret = uverbs_get_flags32(&attr.create_flags, attrs,
 195                          UVERBS_ATTR_CREATE_QP_FLAGS,
 196                          IB_UVERBS_QP_CREATE_BLOCK_MULTICAST_LOOPBACK |
 197                          IB_UVERBS_QP_CREATE_SCATTER_FCS |
 198                          IB_UVERBS_QP_CREATE_CVLAN_STRIPPING |
 199                          IB_UVERBS_QP_CREATE_PCI_WRITE_END_PADDING |
 200                          IB_UVERBS_QP_CREATE_SQ_SIG_ALL);
 201         if (ret)
 202                 return ret;
 203
 204         ret = check_creation_flags(attr.qp_type, attr.create_flags);
 205         if (ret)
 206                 return ret;
 207
 208         if (uverbs_attr_is_valid(attrs,
 209                         UVERBS_ATTR_CREATE_QP_SOURCE_QPN)) {
 210                 ret = uverbs_copy_from(&attr.source_qpn, attrs,
 211                                        UVERBS_ATTR_CREATE_QP_SOURCE_QPN);
 212                 if (ret)
 213                         return ret;
 214                 attr.create_flags |= IB_QP_CREATE_SOURCE_QPN;
 215         }
 216
 217         srq = uverbs_attr_get_obj(attrs,
 218                                   UVERBS_ATTR_CREATE_QP_SRQ_HANDLE);
 219         if (!IS_ERR(srq)) {
 220                 if ((srq->srq_type == IB_SRQT_XRC &&
 221                         attr.qp_type != IB_QPT_XRC_TGT) ||
 222                     (srq->srq_type != IB_SRQT_XRC &&
 223                         attr.qp_type == IB_QPT_XRC_TGT))
 224                         return -EINVAL;
 225                 attr.srq = srq;
 226         }
 227
 228         obj->uevent.event_file = ib_uverbs_get_async_event(attrs,
 229                                         UVERBS_ATTR_CREATE_QP_EVENT_FD);
 230         INIT_LIST_HEAD(&obj->uevent.event_list);
 231         INIT_LIST_HEAD(&obj->mcast_list);
 232         obj->uevent.uobject.user_handle = user_handle;
 233         attr.event_handler = ib_uverbs_qp_event_handler;
 234         attr.send_cq = send_cq;
 235         attr.recv_cq = recv_cq;
 236         attr.xrcd = xrcd;
 237         if (attr.create_flags & IB_UVERBS_QP_CREATE_SQ_SIG_ALL) {
 238                 /* This creation bit is uverbs one, need to mask before
 239                  * calling drivers. It was added to prevent an extra user attr
 240                  * only for that when using ioctl.
 241                  */
 242                 attr.create_flags &= ~IB_UVERBS_QP_CREATE_SQ_SIG_ALL;
 243                 attr.sq_sig_type = IB_SIGNAL_ALL_WR;
 244         } else {
 245                 attr.sq_sig_type = IB_SIGNAL_REQ_WR;
 246         }
 247
 248         set_caps(&attr, &cap, true);
 249         mutex_init(&obj->mcast_lock);
 250
 251         if (attr.qp_type == IB_QPT_XRC_TGT)
 252                 qp = ib_create_qp(pd, &attr);
 253         else
 254                 qp = _ib_create_qp(device, pd, &attr, &attrs->driver_udata, obj,
 255                                    NULL);
 256
 257         if (IS_ERR(qp)) {
 258                 ret = PTR_ERR(qp);
 259                 goto err_put;
 260         }
 261
 262         if (attr.qp_type != IB_QPT_XRC_TGT) {
 263                 atomic_inc(&pd->usecnt);
 264                 if (attr.send_cq)
 265                         atomic_inc(&attr.send_cq->usecnt);
 266                 if (attr.recv_cq)
 267                         atomic_inc(&attr.recv_cq->usecnt);
 268                 if (attr.srq)
 269                         atomic_inc(&attr.srq->usecnt);
 270                 if (attr.rwq_ind_tbl)
 271                         atomic_inc(&attr.rwq_ind_tbl->usecnt);
 272         } else {
 273                 obj->uxrcd = container_of(xrcd_uobj, struct ib_uxrcd_object,
 274                                           uobject);
 275                 atomic_inc(&obj->uxrcd->refcnt);
 276                 /* It is done in _ib_create_qp for other QP types */
 277                 qp->uobject = obj;
 278         }
 279
 280         obj->uevent.uobject.object = qp;
 281         uverbs_finalize_uobj_create(attrs, UVERBS_ATTR_CREATE_QP_HANDLE);
 282
 283         if (attr.qp_type != IB_QPT_XRC_TGT) {
 284                 ret = ib_create_qp_security(qp, device);
 285                 if (ret)
 286                         return ret;
 287         }
 288
 289         set_caps(&attr, &cap, false);
 290         ret = uverbs_copy_to_struct_or_zero(attrs,
 291                                         UVERBS_ATTR_CREATE_QP_RESP_CAP, &cap,
 292                                         sizeof(cap));
 293         if (ret)
 294                 return ret;
 295
 296         ret = uverbs_copy_to(attrs, UVERBS_ATTR_CREATE_QP_RESP_QP_NUM,
 297                              &qp->qp_num,
 298                              sizeof(qp->qp_num));
 299
 300         return ret;
 301 err_put:
 302         if (obj->uevent.event_file)
 303                 uverbs_uobject_put(&obj->uevent.event_file->uobj);
 304         return ret;
 305 };
 306
 307 DECLARE_UVERBS_NAMED_METHOD(
 308         UVERBS_METHOD_QP_CREATE,
 309         UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_QP_HANDLE,
 310                         UVERBS_OBJECT_QP,
 311                         UVERBS_ACCESS_NEW,
 312                         UA_MANDATORY),
 313         UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_QP_XRCD_HANDLE,
 314                         UVERBS_OBJECT_XRCD,
 315                         UVERBS_ACCESS_READ,
 316                         UA_OPTIONAL),
 317         UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_QP_PD_HANDLE,
 318                         UVERBS_OBJECT_PD,
 319                         UVERBS_ACCESS_READ,
 320                         UA_OPTIONAL),
 321         UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_QP_SRQ_HANDLE,
 322                         UVERBS_OBJECT_SRQ,
 323                         UVERBS_ACCESS_READ,
 324                         UA_OPTIONAL),
 325         UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_QP_SEND_CQ_HANDLE,
 326                         UVERBS_OBJECT_CQ,
 327                         UVERBS_ACCESS_READ,
 328                         UA_OPTIONAL),
 329         UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_QP_RECV_CQ_HANDLE,
 330                         UVERBS_OBJECT_CQ,
 331                         UVERBS_ACCESS_READ,
 332                         UA_OPTIONAL),
 333         UVERBS_ATTR_IDR(UVERBS_ATTR_CREATE_QP_IND_TABLE_HANDLE,
 334                         UVERBS_OBJECT_RWQ_IND_TBL,
 335                         UVERBS_ACCESS_READ,
 336                         UA_OPTIONAL),
 337         UVERBS_ATTR_PTR_IN(UVERBS_ATTR_CREATE_QP_USER_HANDLE,
 338                            UVERBS_ATTR_TYPE(u64),
 339                            UA_MANDATORY),
 340         UVERBS_ATTR_PTR_IN(UVERBS_ATTR_CREATE_QP_CAP,
 341                            UVERBS_ATTR_STRUCT(struct ib_uverbs_qp_cap,
 342                                               max_inline_data),
 343                            UA_MANDATORY),
 344         UVERBS_ATTR_CONST_IN(UVERBS_ATTR_CREATE_QP_TYPE,
 345                              enum ib_uverbs_qp_type,
 346                              UA_MANDATORY),
 347         UVERBS_ATTR_FLAGS_IN(UVERBS_ATTR_CREATE_QP_FLAGS,
 348                              enum ib_uverbs_qp_create_flags,
 349                              UA_OPTIONAL),
 350         UVERBS_ATTR_PTR_IN(UVERBS_ATTR_CREATE_QP_SOURCE_QPN,
 351                            UVERBS_ATTR_TYPE(u32),
 352                            UA_OPTIONAL),
 353         UVERBS_ATTR_FD(UVERBS_ATTR_CREATE_QP_EVENT_FD,
 354                        UVERBS_OBJECT_ASYNC_EVENT,
 355                        UVERBS_ACCESS_READ,
 356                        UA_OPTIONAL),
 357         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_CREATE_QP_RESP_CAP,
 358                             UVERBS_ATTR_STRUCT(struct ib_uverbs_qp_cap,
 359                                                max_inline_data),
 360                            UA_MANDATORY),
 361         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_CREATE_QP_RESP_QP_NUM,
 362                            UVERBS_ATTR_TYPE(u32),
 363                            UA_MANDATORY),
 364         UVERBS_ATTR_UHW());
 365
 366 static int UVERBS_HANDLER(UVERBS_METHOD_QP_DESTROY)(
 367         struct uverbs_attr_bundle *attrs)
 368 {
 369         struct ib_uobject *uobj =
 370                 uverbs_attr_get_uobject(attrs, UVERBS_ATTR_DESTROY_QP_HANDLE);
 371         struct ib_uqp_object *obj =
 372                 container_of(uobj, struct ib_uqp_object, uevent.uobject);
 373         struct ib_uverbs_destroy_qp_resp resp = {
 374                 .events_reported = obj->uevent.events_reported
 375         };
 376
 377         return uverbs_copy_to(attrs, UVERBS_ATTR_DESTROY_QP_RESP, &resp,
 378                               sizeof(resp));
 379 }
 380
 381 DECLARE_UVERBS_NAMED_METHOD(
 382         UVERBS_METHOD_QP_DESTROY,
 383         UVERBS_ATTR_IDR(UVERBS_ATTR_DESTROY_QP_HANDLE,
 384                         UVERBS_OBJECT_QP,
 385                         UVERBS_ACCESS_DESTROY,
 386                         UA_MANDATORY),
 387         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_DESTROY_QP_RESP,
 388                             UVERBS_ATTR_TYPE(struct ib_uverbs_destroy_qp_resp),
 389                             UA_MANDATORY));
 390
 391 DECLARE_UVERBS_NAMED_OBJECT(
 392         UVERBS_OBJECT_QP,
 393         UVERBS_TYPE_ALLOC_IDR_SZ(sizeof(struct ib_uqp_object), uverbs_free_qp),
 394         &UVERBS_METHOD(UVERBS_METHOD_QP_CREATE),
 395         &UVERBS_METHOD(UVERBS_METHOD_QP_DESTROY));
 396
 397 const struct uapi_definition uverbs_def_obj_qp[] = {
 398         UAPI_DEF_CHAIN_OBJ_TREE_NAMED(UVERBS_OBJECT_QP,
 399                                       UAPI_DEF_OBJ_NEEDS_FN(destroy_qp)),
 400         {}
 401 };