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 }; 501