drivers/infiniband/core/uverbs_std_types_device.c

   1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
   2 /*
   3  * Copyright (c) 2018, Mellanox Technologies inc.  All rights reserved.
   4  */
   5
   6 #include <linux/overflow.h>
   7 #include <rdma/uverbs_std_types.h>
   8 #include "rdma_core.h"
   9 #include "uverbs.h"
  10 #include <rdma/uverbs_ioctl.h>
  11 #include <rdma/opa_addr.h>
  12 #include <rdma/ib_cache.h>
  13
  14 /*
  15  * This ioctl method allows calling any defined write or write_ex
  16  * handler. This essentially replaces the hdr/ex_hdr system with the ioctl
  17  * marshalling, and brings the non-ex path into the same marshalling as the ex
  18  * path.
  19  */
  20 static int UVERBS_HANDLER(UVERBS_METHOD_INVOKE_WRITE)(
  21         struct uverbs_attr_bundle *attrs)
  22 {
  23         struct uverbs_api *uapi = attrs->ufile->device->uapi;
  24         const struct uverbs_api_write_method *method_elm;
  25         u32 cmd;
  26         int rc;
  27
  28         rc = uverbs_get_const(&cmd, attrs, UVERBS_ATTR_WRITE_CMD);
  29         if (rc)
  30                 return rc;
  31
  32         method_elm = uapi_get_method(uapi, cmd);
  33         if (IS_ERR(method_elm))
  34                 return PTR_ERR(method_elm);
  35
  36         uverbs_fill_udata(attrs, &attrs->ucore, UVERBS_ATTR_CORE_IN,
  37                           UVERBS_ATTR_CORE_OUT);
  38
  39         if (attrs->ucore.inlen < method_elm->req_size ||
  40             attrs->ucore.outlen < method_elm->resp_size)
  41                 return -ENOSPC;
  42
  43         attrs->uobject = NULL;
  44         rc = method_elm->handler(attrs);
  45         if (attrs->uobject)
  46                 uverbs_finalize_object(attrs->uobject, UVERBS_ACCESS_NEW, true,
  47                                        !rc, attrs);
  48         return rc;
  49 }
  50
  51 DECLARE_UVERBS_NAMED_METHOD(UVERBS_METHOD_INVOKE_WRITE,
  52                             UVERBS_ATTR_CONST_IN(UVERBS_ATTR_WRITE_CMD,
  53                                                  enum ib_uverbs_write_cmds,
  54                                                  UA_MANDATORY),
  55                             UVERBS_ATTR_PTR_IN(UVERBS_ATTR_CORE_IN,
  56                                                UVERBS_ATTR_MIN_SIZE(sizeof(u32)),
  57                                                UA_OPTIONAL),
  58                             UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_CORE_OUT,
  59                                                 UVERBS_ATTR_MIN_SIZE(0),
  60                                                 UA_OPTIONAL),
  61                             UVERBS_ATTR_UHW());
  62
  63 static uint32_t *
  64 gather_objects_handle(struct ib_uverbs_file *ufile,
  65                       const struct uverbs_api_object *uapi_object,
  66                       struct uverbs_attr_bundle *attrs,
  67                       ssize_t out_len,
  68                       u64 *total)
  69 {
  70         u64 max_count = out_len / sizeof(u32);
  71         struct ib_uobject *obj;
  72         u64 count = 0;
  73         u32 *handles;
  74
  75         /* Allocated memory that cannot page out where we gather
  76          * all object ids under a spin_lock.
  77          */
  78         handles = uverbs_zalloc(attrs, out_len);
  79         if (IS_ERR(handles))
  80                 return handles;
  81
  82         spin_lock_irq(&ufile->uobjects_lock);
  83         list_for_each_entry(obj, &ufile->uobjects, list) {
  84                 u32 obj_id = obj->id;
  85
  86                 if (obj->uapi_object != uapi_object)
  87                         continue;
  88
  89                 if (count >= max_count)
  90                         break;
  91
  92                 handles[count] = obj_id;
  93                 count++;
  94         }
  95         spin_unlock_irq(&ufile->uobjects_lock);
  96
  97         *total = count;
  98         return handles;
  99 }
 100
 101 static int UVERBS_HANDLER(UVERBS_METHOD_INFO_HANDLES)(
 102         struct uverbs_attr_bundle *attrs)
 103 {
 104         const struct uverbs_api_object *uapi_object;
 105         ssize_t out_len;
 106         u64 total = 0;
 107         u16 object_id;
 108         u32 *handles;
 109         int ret;
 110
 111         out_len = uverbs_attr_get_len(attrs, UVERBS_ATTR_INFO_HANDLES_LIST);
 112         if (out_len <= 0 || (out_len % sizeof(u32) != 0))
 113                 return -EINVAL;
 114
 115         ret = uverbs_get_const(&object_id, attrs, UVERBS_ATTR_INFO_OBJECT_ID);
 116         if (ret)
 117                 return ret;
 118
 119         uapi_object = uapi_get_object(attrs->ufile->device->uapi, object_id);
 120         if (!uapi_object)
 121                 return -EINVAL;
 122
 123         handles = gather_objects_handle(attrs->ufile, uapi_object, attrs,
 124                                         out_len, &total);
 125         if (IS_ERR(handles))
 126                 return PTR_ERR(handles);
 127
 128         ret = uverbs_copy_to(attrs, UVERBS_ATTR_INFO_HANDLES_LIST, handles,
 129                              sizeof(u32) * total);
 130         if (ret)
 131                 goto err;
 132
 133         ret = uverbs_copy_to(attrs, UVERBS_ATTR_INFO_TOTAL_HANDLES, &total,
 134                              sizeof(total));
 135 err:
 136         return ret;
 137 }
 138
 139 void copy_port_attr_to_resp(struct ib_port_attr *attr,
 140                             struct ib_uverbs_query_port_resp *resp,
 141                             struct ib_device *ib_dev, u8 port_num)
 142 {
 143         resp->state = attr->state;
 144         resp->max_mtu = attr->max_mtu;
 145         resp->active_mtu = attr->active_mtu;
 146         resp->gid_tbl_len = attr->gid_tbl_len;
 147         resp->port_cap_flags = make_port_cap_flags(attr);
 148         resp->max_msg_sz = attr->max_msg_sz;
 149         resp->bad_pkey_cntr = attr->bad_pkey_cntr;
 150         resp->qkey_viol_cntr = attr->qkey_viol_cntr;
 151         resp->pkey_tbl_len = attr->pkey_tbl_len;
 152
 153         if (rdma_is_grh_required(ib_dev, port_num))
 154                 resp->flags |= IB_UVERBS_QPF_GRH_REQUIRED;
 155
 156         if (rdma_cap_opa_ah(ib_dev, port_num)) {
 157                 resp->lid = OPA_TO_IB_UCAST_LID(attr->lid);
 158                 resp->sm_lid = OPA_TO_IB_UCAST_LID(attr->sm_lid);
 159         } else {
 160                 resp->lid = ib_lid_cpu16(attr->lid);
 161                 resp->sm_lid = ib_lid_cpu16(attr->sm_lid);
 162         }
 163
 164         resp->lmc = attr->lmc;
 165         resp->max_vl_num = attr->max_vl_num;
 166         resp->sm_sl = attr->sm_sl;
 167         resp->subnet_timeout = attr->subnet_timeout;
 168         resp->init_type_reply = attr->init_type_reply;
 169         resp->active_width = attr->active_width;
 170         /* This ABI needs to be extended to provide any speed more than IB_SPEED_NDR */
 171         resp->active_speed = min_t(u16, attr->active_speed, IB_SPEED_NDR);
 172         resp->phys_state = attr->phys_state;
 173         resp->link_layer = rdma_port_get_link_layer(ib_dev, port_num);
 174 }
 175
 176 static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_PORT)(
 177         struct uverbs_attr_bundle *attrs)
 178 {
 179         struct ib_device *ib_dev;
 180         struct ib_port_attr attr = {};
 181         struct ib_uverbs_query_port_resp_ex resp = {};
 182         struct ib_ucontext *ucontext;
 183         int ret;
 184         u8 port_num;
 185
 186         ucontext = ib_uverbs_get_ucontext(attrs);
 187         if (IS_ERR(ucontext))
 188                 return PTR_ERR(ucontext);
 189         ib_dev = ucontext->device;
 190
 191         /* FIXME: Extend the UAPI_DEF_OBJ_NEEDS_FN stuff.. */
 192         if (!ib_dev->ops.query_port)
 193                 return -EOPNOTSUPP;
 194
 195         ret = uverbs_get_const(&port_num, attrs,
 196                                UVERBS_ATTR_QUERY_PORT_PORT_NUM);
 197         if (ret)
 198                 return ret;
 199
 200         ret = ib_query_port(ib_dev, port_num, &attr);
 201         if (ret)
 202                 return ret;
 203
 204         copy_port_attr_to_resp(&attr, &resp.legacy_resp, ib_dev, port_num);
 205         resp.port_cap_flags2 = attr.port_cap_flags2;
 206
 207         return uverbs_copy_to_struct_or_zero(attrs, UVERBS_ATTR_QUERY_PORT_RESP,
 208                                              &resp, sizeof(resp));
 209 }
 210
 211 static int UVERBS_HANDLER(UVERBS_METHOD_GET_CONTEXT)(
 212         struct uverbs_attr_bundle *attrs)
 213 {
 214         u32 num_comp = attrs->ufile->device->num_comp_vectors;
 215         u64 core_support = IB_UVERBS_CORE_SUPPORT_OPTIONAL_MR_ACCESS;
 216         int ret;
 217
 218         ret = uverbs_copy_to(attrs, UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
 219                              &num_comp, sizeof(num_comp));
 220         if (IS_UVERBS_COPY_ERR(ret))
 221                 return ret;
 222
 223         ret = uverbs_copy_to(attrs, UVERBS_ATTR_GET_CONTEXT_CORE_SUPPORT,
 224                              &core_support, sizeof(core_support));
 225         if (IS_UVERBS_COPY_ERR(ret))
 226                 return ret;
 227
 228         ret = ib_alloc_ucontext(attrs);
 229         if (ret)
 230                 return ret;
 231         ret = ib_init_ucontext(attrs);
 232         if (ret) {
 233                 kfree(attrs->context);
 234                 attrs->context = NULL;
 235                 return ret;
 236         }
 237         return 0;
 238 }
 239
 240 static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_CONTEXT)(
 241         struct uverbs_attr_bundle *attrs)
 242 {
 243         u64 core_support = IB_UVERBS_CORE_SUPPORT_OPTIONAL_MR_ACCESS;
 244         struct ib_ucontext *ucontext;
 245         struct ib_device *ib_dev;
 246         u32 num_comp;
 247         int ret;
 248
 249         ucontext = ib_uverbs_get_ucontext(attrs);
 250         if (IS_ERR(ucontext))
 251                 return PTR_ERR(ucontext);
 252         ib_dev = ucontext->device;
 253
 254         if (!ib_dev->ops.query_ucontext)
 255                 return -EOPNOTSUPP;
 256
 257         num_comp = attrs->ufile->device->num_comp_vectors;
 258         ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_CONTEXT_NUM_COMP_VECTORS,
 259                              &num_comp, sizeof(num_comp));
 260         if (IS_UVERBS_COPY_ERR(ret))
 261                 return ret;
 262
 263         ret = uverbs_copy_to(attrs, UVERBS_ATTR_QUERY_CONTEXT_CORE_SUPPORT,
 264                              &core_support, sizeof(core_support));
 265         if (IS_UVERBS_COPY_ERR(ret))
 266                 return ret;
 267
 268         return ucontext->device->ops.query_ucontext(ucontext, attrs);
 269 }
 270
 271 static int copy_gid_entries_to_user(struct uverbs_attr_bundle *attrs,
 272                                     struct ib_uverbs_gid_entry *entries,
 273                                     size_t num_entries, size_t user_entry_size)
 274 {
 275         const struct uverbs_attr *attr;
 276         void __user *user_entries;
 277         size_t copy_len;
 278         int ret;
 279         int i;
 280
 281         if (user_entry_size == sizeof(*entries)) {
 282                 ret = uverbs_copy_to(attrs,
 283                                      UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
 284                                      entries, sizeof(*entries) * num_entries);
 285                 return ret;
 286         }
 287
 288         copy_len = min_t(size_t, user_entry_size, sizeof(*entries));
 289         attr = uverbs_attr_get(attrs, UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES);
 290         if (IS_ERR(attr))
 291                 return PTR_ERR(attr);
 292
 293         user_entries = u64_to_user_ptr(attr->ptr_attr.data);
 294         for (i = 0; i < num_entries; i++) {
 295                 if (copy_to_user(user_entries, entries, copy_len))
 296                         return -EFAULT;
 297
 298                 if (user_entry_size > sizeof(*entries)) {
 299                         if (clear_user(user_entries + sizeof(*entries),
 300                                        user_entry_size - sizeof(*entries)))
 301                                 return -EFAULT;
 302                 }
 303
 304                 entries++;
 305                 user_entries += user_entry_size;
 306         }
 307
 308         return uverbs_output_written(attrs,
 309                                      UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES);
 310 }
 311
 312 static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_GID_TABLE)(
 313         struct uverbs_attr_bundle *attrs)
 314 {
 315         struct ib_uverbs_gid_entry *entries;
 316         struct ib_ucontext *ucontext;
 317         struct ib_device *ib_dev;
 318         size_t user_entry_size;
 319         ssize_t num_entries;
 320         int max_entries;
 321         u32 flags;
 322         int ret;
 323
 324         ret = uverbs_get_flags32(&flags, attrs,
 325                                  UVERBS_ATTR_QUERY_GID_TABLE_FLAGS, 0);
 326         if (ret)
 327                 return ret;
 328
 329         ret = uverbs_get_const(&user_entry_size, attrs,
 330                                UVERBS_ATTR_QUERY_GID_TABLE_ENTRY_SIZE);
 331         if (ret)
 332                 return ret;
 333
 334         max_entries = uverbs_attr_ptr_get_array_size(
 335                 attrs, UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
 336                 user_entry_size);
 337         if (max_entries <= 0)
 338                 return max_entries ?: -EINVAL;
 339
 340         ucontext = ib_uverbs_get_ucontext(attrs);
 341         if (IS_ERR(ucontext))
 342                 return PTR_ERR(ucontext);
 343         ib_dev = ucontext->device;
 344
 345         entries = uverbs_kcalloc(attrs, max_entries, sizeof(*entries));
 346         if (IS_ERR(entries))
 347                 return PTR_ERR(entries);
 348
 349         num_entries = rdma_query_gid_table(ib_dev, entries, max_entries);
 350         if (num_entries < 0)
 351                 return -EINVAL;
 352
 353         ret = copy_gid_entries_to_user(attrs, entries, num_entries,
 354                                        user_entry_size);
 355         if (ret)
 356                 return ret;
 357
 358         ret = uverbs_copy_to(attrs,
 359                              UVERBS_ATTR_QUERY_GID_TABLE_RESP_NUM_ENTRIES,
 360                              &num_entries, sizeof(num_entries));
 361         return ret;
 362 }
 363
 364 static int UVERBS_HANDLER(UVERBS_METHOD_QUERY_GID_ENTRY)(
 365         struct uverbs_attr_bundle *attrs)
 366 {
 367         struct ib_uverbs_gid_entry entry = {};
 368         const struct ib_gid_attr *gid_attr;
 369         struct ib_ucontext *ucontext;
 370         struct ib_device *ib_dev;
 371         struct net_device *ndev;
 372         u32 gid_index;
 373         u32 port_num;
 374         u32 flags;
 375         int ret;
 376
 377         ret = uverbs_get_flags32(&flags, attrs,
 378                                  UVERBS_ATTR_QUERY_GID_ENTRY_FLAGS, 0);
 379         if (ret)
 380                 return ret;
 381
 382         ret = uverbs_get_const(&port_num, attrs,
 383                                UVERBS_ATTR_QUERY_GID_ENTRY_PORT);
 384         if (ret)
 385                 return ret;
 386
 387         ret = uverbs_get_const(&gid_index, attrs,
 388                                UVERBS_ATTR_QUERY_GID_ENTRY_GID_INDEX);
 389         if (ret)
 390                 return ret;
 391
 392         ucontext = ib_uverbs_get_ucontext(attrs);
 393         if (IS_ERR(ucontext))
 394                 return PTR_ERR(ucontext);
 395         ib_dev = ucontext->device;
 396
 397         if (!rdma_is_port_valid(ib_dev, port_num))
 398                 return -EINVAL;
 399
 400         gid_attr = rdma_get_gid_attr(ib_dev, port_num, gid_index);
 401         if (IS_ERR(gid_attr))
 402                 return PTR_ERR(gid_attr);
 403
 404         memcpy(&entry.gid, &gid_attr->gid, sizeof(gid_attr->gid));
 405         entry.gid_index = gid_attr->index;
 406         entry.port_num = gid_attr->port_num;
 407         entry.gid_type = gid_attr->gid_type;
 408
 409         rcu_read_lock();
 410         ndev = rdma_read_gid_attr_ndev_rcu(gid_attr);
 411         if (IS_ERR(ndev)) {
 412                 if (PTR_ERR(ndev) != -ENODEV) {
 413                         ret = PTR_ERR(ndev);
 414                         rcu_read_unlock();
 415                         goto out;
 416                 }
 417         } else {
 418                 entry.netdev_ifindex = ndev->ifindex;
 419         }
 420         rcu_read_unlock();
 421
 422         ret = uverbs_copy_to_struct_or_zero(
 423                 attrs, UVERBS_ATTR_QUERY_GID_ENTRY_RESP_ENTRY, &entry,
 424                 sizeof(entry));
 425 out:
 426         rdma_put_gid_attr(gid_attr);
 427         return ret;
 428 }
 429
 430 DECLARE_UVERBS_NAMED_METHOD(
 431         UVERBS_METHOD_GET_CONTEXT,
 432         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_GET_CONTEXT_NUM_COMP_VECTORS,
 433                             UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
 434         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_GET_CONTEXT_CORE_SUPPORT,
 435                             UVERBS_ATTR_TYPE(u64), UA_OPTIONAL),
 436         UVERBS_ATTR_UHW());
 437
 438 DECLARE_UVERBS_NAMED_METHOD(
 439         UVERBS_METHOD_QUERY_CONTEXT,
 440         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_CONTEXT_NUM_COMP_VECTORS,
 441                             UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
 442         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_CONTEXT_CORE_SUPPORT,
 443                             UVERBS_ATTR_TYPE(u64), UA_OPTIONAL));
 444
 445 DECLARE_UVERBS_NAMED_METHOD(
 446         UVERBS_METHOD_INFO_HANDLES,
 447         /* Also includes any device specific object ids */
 448         UVERBS_ATTR_CONST_IN(UVERBS_ATTR_INFO_OBJECT_ID,
 449                              enum uverbs_default_objects, UA_MANDATORY),
 450         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_INFO_TOTAL_HANDLES,
 451                             UVERBS_ATTR_TYPE(u32), UA_OPTIONAL),
 452         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_INFO_HANDLES_LIST,
 453                             UVERBS_ATTR_MIN_SIZE(sizeof(u32)), UA_OPTIONAL));
 454
 455 DECLARE_UVERBS_NAMED_METHOD(
 456         UVERBS_METHOD_QUERY_PORT,
 457         UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_PORT_PORT_NUM, u8, UA_MANDATORY),
 458         UVERBS_ATTR_PTR_OUT(
 459                 UVERBS_ATTR_QUERY_PORT_RESP,
 460                 UVERBS_ATTR_STRUCT(struct ib_uverbs_query_port_resp_ex,
 461                                    reserved),
 462                 UA_MANDATORY));
 463
 464 DECLARE_UVERBS_NAMED_METHOD(
 465         UVERBS_METHOD_QUERY_GID_TABLE,
 466         UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_TABLE_ENTRY_SIZE, u64,
 467                              UA_MANDATORY),
 468         UVERBS_ATTR_FLAGS_IN(UVERBS_ATTR_QUERY_GID_TABLE_FLAGS, u32,
 469                              UA_OPTIONAL),
 470         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_TABLE_RESP_ENTRIES,
 471                             UVERBS_ATTR_MIN_SIZE(0), UA_MANDATORY),
 472         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_TABLE_RESP_NUM_ENTRIES,
 473                             UVERBS_ATTR_TYPE(u64), UA_MANDATORY));
 474
 475 DECLARE_UVERBS_NAMED_METHOD(
 476         UVERBS_METHOD_QUERY_GID_ENTRY,
 477         UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_ENTRY_PORT, u32,
 478                              UA_MANDATORY),
 479         UVERBS_ATTR_CONST_IN(UVERBS_ATTR_QUERY_GID_ENTRY_GID_INDEX, u32,
 480                              UA_MANDATORY),
 481         UVERBS_ATTR_FLAGS_IN(UVERBS_ATTR_QUERY_GID_ENTRY_FLAGS, u32,
 482                              UA_MANDATORY),
 483         UVERBS_ATTR_PTR_OUT(UVERBS_ATTR_QUERY_GID_ENTRY_RESP_ENTRY,
 484                             UVERBS_ATTR_STRUCT(struct ib_uverbs_gid_entry,
 485                                                netdev_ifindex),
 486                             UA_MANDATORY));
 487
 488 DECLARE_UVERBS_GLOBAL_METHODS(UVERBS_OBJECT_DEVICE,
 489                               &UVERBS_METHOD(UVERBS_METHOD_GET_CONTEXT),
 490                               &UVERBS_METHOD(UVERBS_METHOD_INVOKE_WRITE),
 491                               &UVERBS_METHOD(UVERBS_METHOD_INFO_HANDLES),
 492                               &UVERBS_METHOD(UVERBS_METHOD_QUERY_PORT),
 493                               &UVERBS_METHOD(UVERBS_METHOD_QUERY_CONTEXT),
 494                               &UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_TABLE),
 495                               &UVERBS_METHOD(UVERBS_METHOD_QUERY_GID_ENTRY));
 496
 497 const struct uapi_definition uverbs_def_obj_device[] = {
 498         UAPI_DEF_CHAIN_OBJ_TREE_NAMED(UVERBS_OBJECT_DEVICE),
 499         {},
 500 };