1 /* 2 * Copyright (c) 2017, Mellanox Technologies 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 * OpenIB.org 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 <rdma/rdma_user_ioctl.h> 34 #include <rdma/uverbs_ioctl.h> 35 #include "rdma_core.h" 36 #include "uverbs.h" 37 38 struct bundle_alloc_head { 39 struct bundle_alloc_head *next; 40 u8 data[]; 41 }; 42 43 struct bundle_priv { 44 /* Must be first */ 45 struct bundle_alloc_head alloc_head; 46 struct bundle_alloc_head *allocated_mem; 47 size_t internal_avail; 48 size_t internal_used; 49 50 struct radix_tree_root *radix; 51 const struct uverbs_api_ioctl_method *method_elm; 52 void __rcu **radix_slots; 53 unsigned long radix_slots_len; 54 u32 method_key; 55 56 struct ib_uverbs_attr __user *user_attrs; 57 struct ib_uverbs_attr *uattrs; 58 59 DECLARE_BITMAP(uobj_finalize, UVERBS_API_ATTR_BKEY_LEN); 60 DECLARE_BITMAP(spec_finalize, UVERBS_API_ATTR_BKEY_LEN); 61 62 /* 63 * Must be last. bundle ends in a flex array which overlaps 64 * internal_buffer. 65 */ 66 struct uverbs_attr_bundle bundle; 67 u64 internal_buffer[32]; 68 }; 69 70 /* 71 * Each method has an absolute minimum amount of memory it needs to allocate, 72 * precompute that amount and determine if the onstack memory can be used or 73 * if allocation is need. 74 */ 75 void uapi_compute_bundle_size(struct uverbs_api_ioctl_method *method_elm, 76 unsigned int num_attrs) 77 { 78 struct bundle_priv *pbundle; 79 size_t bundle_size = 80 offsetof(struct bundle_priv, internal_buffer) + 81 sizeof(*pbundle->bundle.attrs) * method_elm->key_bitmap_len + 82 sizeof(*pbundle->uattrs) * num_attrs; 83 84 method_elm->use_stack = bundle_size <= sizeof(*pbundle); 85 method_elm->bundle_size = 86 ALIGN(bundle_size + 256, sizeof(*pbundle->internal_buffer)); 87 88 /* Do not want order-2 allocations for this. */ 89 WARN_ON_ONCE(method_elm->bundle_size > PAGE_SIZE); 90 } 91 92 /** 93 * uverbs_alloc() - Quickly allocate memory for use with a bundle 94 * @bundle: The bundle 95 * @size: Number of bytes to allocate 96 * @flags: Allocator flags 97 * 98 * The bundle allocator is intended for allocations that are connected with 99 * processing the system call related to the bundle. The allocated memory is 100 * always freed once the system call completes, and cannot be freed any other 101 * way. 102 * 103 * This tries to use a small pool of pre-allocated memory for performance. 104 */ 105 __malloc void *_uverbs_alloc(struct uverbs_attr_bundle *bundle, size_t size, 106 gfp_t flags) 107 { 108 struct bundle_priv *pbundle = 109 container_of(bundle, struct bundle_priv, bundle); 110 size_t new_used; 111 void *res; 112 113 if (check_add_overflow(size, pbundle->internal_used, &new_used)) 114 return ERR_PTR(-EOVERFLOW); 115 116 if (new_used > pbundle->internal_avail) { 117 struct bundle_alloc_head *buf; 118 119 buf = kvmalloc(struct_size(buf, data, size), flags); 120 if (!buf) 121 return ERR_PTR(-ENOMEM); 122 buf->next = pbundle->allocated_mem; 123 pbundle->allocated_mem = buf; 124 return buf->data; 125 } 126 127 res = (void *)pbundle->internal_buffer + pbundle->internal_used; 128 pbundle->internal_used = 129 ALIGN(new_used, sizeof(*pbundle->internal_buffer)); 130 if (flags & __GFP_ZERO) 131 memset(res, 0, size); 132 return res; 133 } 134 EXPORT_SYMBOL(_uverbs_alloc); 135 136 static bool uverbs_is_attr_cleared(const struct ib_uverbs_attr *uattr, 137 u16 len) 138 { 139 if (uattr->len > sizeof(((struct ib_uverbs_attr *)0)->data)) 140 return ib_is_buffer_cleared(u64_to_user_ptr(uattr->data) + len, 141 uattr->len - len); 142 143 return !memchr_inv((const void *)&uattr->data + len, 144 0, uattr->len - len); 145 } 146 147 static int uverbs_set_output(const struct uverbs_attr_bundle *bundle, 148 const struct uverbs_attr *attr) 149 { 150 struct bundle_priv *pbundle = 151 container_of(bundle, struct bundle_priv, bundle); 152 u16 flags; 153 154 flags = pbundle->uattrs[attr->ptr_attr.uattr_idx].flags | 155 UVERBS_ATTR_F_VALID_OUTPUT; 156 if (put_user(flags, 157 &pbundle->user_attrs[attr->ptr_attr.uattr_idx].flags)) 158 return -EFAULT; 159 return 0; 160 } 161 162 static int uverbs_process_idrs_array(struct bundle_priv *pbundle, 163 const struct uverbs_api_attr *attr_uapi, 164 struct uverbs_objs_arr_attr *attr, 165 struct ib_uverbs_attr *uattr, 166 u32 attr_bkey) 167 { 168 const struct uverbs_attr_spec *spec = &attr_uapi->spec; 169 size_t array_len; 170 u32 *idr_vals; 171 int ret = 0; 172 size_t i; 173 174 if (uattr->attr_data.reserved) 175 return -EINVAL; 176 177 if (uattr->len % sizeof(u32)) 178 return -EINVAL; 179 180 array_len = uattr->len / sizeof(u32); 181 if (array_len < spec->u2.objs_arr.min_len || 182 array_len > spec->u2.objs_arr.max_len) 183 return -EINVAL; 184 185 attr->uobjects = 186 uverbs_alloc(&pbundle->bundle, 187 array_size(array_len, sizeof(*attr->uobjects))); 188 if (IS_ERR(attr->uobjects)) 189 return PTR_ERR(attr->uobjects); 190 191 /* 192 * Since idr is 4B and *uobjects is >= 4B, we can use attr->uobjects 193 * to store idrs array and avoid additional memory allocation. The 194 * idrs array is offset to the end of the uobjects array so we will be 195 * able to read idr and replace with a pointer. 196 */ 197 idr_vals = (u32 *)(attr->uobjects + array_len) - array_len; 198 199 if (uattr->len > sizeof(uattr->data)) { 200 ret = copy_from_user(idr_vals, u64_to_user_ptr(uattr->data), 201 uattr->len); 202 if (ret) 203 return -EFAULT; 204 } else { 205 memcpy(idr_vals, &uattr->data, uattr->len); 206 } 207 208 for (i = 0; i != array_len; i++) { 209 attr->uobjects[i] = uverbs_get_uobject_from_file( 210 spec->u2.objs_arr.obj_type, pbundle->bundle.ufile, 211 spec->u2.objs_arr.access, idr_vals[i]); 212 if (IS_ERR(attr->uobjects[i])) { 213 ret = PTR_ERR(attr->uobjects[i]); 214 break; 215 } 216 } 217 218 attr->len = i; 219 __set_bit(attr_bkey, pbundle->spec_finalize); 220 return ret; 221 } 222 223 static int uverbs_free_idrs_array(const struct uverbs_api_attr *attr_uapi, 224 struct uverbs_objs_arr_attr *attr, 225 bool commit) 226 { 227 const struct uverbs_attr_spec *spec = &attr_uapi->spec; 228 int current_ret; 229 int ret = 0; 230 size_t i; 231 232 for (i = 0; i != attr->len; i++) { 233 current_ret = uverbs_finalize_object( 234 attr->uobjects[i], spec->u2.objs_arr.access, commit); 235 if (!ret) 236 ret = current_ret; 237 } 238 239 return ret; 240 } 241 242 static int uverbs_process_attr(struct bundle_priv *pbundle, 243 const struct uverbs_api_attr *attr_uapi, 244 struct ib_uverbs_attr *uattr, u32 attr_bkey) 245 { 246 const struct uverbs_attr_spec *spec = &attr_uapi->spec; 247 struct uverbs_attr *e = &pbundle->bundle.attrs[attr_bkey]; 248 const struct uverbs_attr_spec *val_spec = spec; 249 struct uverbs_obj_attr *o_attr; 250 251 switch (spec->type) { 252 case UVERBS_ATTR_TYPE_ENUM_IN: 253 if (uattr->attr_data.enum_data.elem_id >= spec->u.enum_def.num_elems) 254 return -EOPNOTSUPP; 255 256 if (uattr->attr_data.enum_data.reserved) 257 return -EINVAL; 258 259 val_spec = &spec->u2.enum_def.ids[uattr->attr_data.enum_data.elem_id]; 260 261 /* Currently we only support PTR_IN based enums */ 262 if (val_spec->type != UVERBS_ATTR_TYPE_PTR_IN) 263 return -EOPNOTSUPP; 264 265 e->ptr_attr.enum_id = uattr->attr_data.enum_data.elem_id; 266 /* fall through */ 267 case UVERBS_ATTR_TYPE_PTR_IN: 268 /* Ensure that any data provided by userspace beyond the known 269 * struct is zero. Userspace that knows how to use some future 270 * longer struct will fail here if used with an old kernel and 271 * non-zero content, making ABI compat/discovery simpler. 272 */ 273 if (uattr->len > val_spec->u.ptr.len && 274 val_spec->zero_trailing && 275 !uverbs_is_attr_cleared(uattr, val_spec->u.ptr.len)) 276 return -EOPNOTSUPP; 277 278 /* fall through */ 279 case UVERBS_ATTR_TYPE_PTR_OUT: 280 if (uattr->len < val_spec->u.ptr.min_len || 281 (!val_spec->zero_trailing && 282 uattr->len > val_spec->u.ptr.len)) 283 return -EINVAL; 284 285 if (spec->type != UVERBS_ATTR_TYPE_ENUM_IN && 286 uattr->attr_data.reserved) 287 return -EINVAL; 288 289 e->ptr_attr.uattr_idx = uattr - pbundle->uattrs; 290 e->ptr_attr.len = uattr->len; 291 292 if (val_spec->alloc_and_copy && !uverbs_attr_ptr_is_inline(e)) { 293 void *p; 294 295 p = uverbs_alloc(&pbundle->bundle, uattr->len); 296 if (IS_ERR(p)) 297 return PTR_ERR(p); 298 299 e->ptr_attr.ptr = p; 300 301 if (copy_from_user(p, u64_to_user_ptr(uattr->data), 302 uattr->len)) 303 return -EFAULT; 304 } else { 305 e->ptr_attr.data = uattr->data; 306 } 307 break; 308 309 case UVERBS_ATTR_TYPE_IDR: 310 case UVERBS_ATTR_TYPE_FD: 311 if (uattr->attr_data.reserved) 312 return -EINVAL; 313 314 if (uattr->len != 0) 315 return -EINVAL; 316 317 o_attr = &e->obj_attr; 318 o_attr->attr_elm = attr_uapi; 319 320 /* 321 * The type of uattr->data is u64 for UVERBS_ATTR_TYPE_IDR and 322 * s64 for UVERBS_ATTR_TYPE_FD. We can cast the u64 to s64 323 * here without caring about truncation as we know that the 324 * IDR implementation today rejects negative IDs 325 */ 326 o_attr->uobject = uverbs_get_uobject_from_file( 327 spec->u.obj.obj_type, 328 pbundle->bundle.ufile, 329 spec->u.obj.access, 330 uattr->data_s64); 331 if (IS_ERR(o_attr->uobject)) 332 return PTR_ERR(o_attr->uobject); 333 __set_bit(attr_bkey, pbundle->uobj_finalize); 334 335 if (spec->u.obj.access == UVERBS_ACCESS_NEW) { 336 unsigned int uattr_idx = uattr - pbundle->uattrs; 337 s64 id = o_attr->uobject->id; 338 339 /* Copy the allocated id to the user-space */ 340 if (put_user(id, &pbundle->user_attrs[uattr_idx].data)) 341 return -EFAULT; 342 } 343 344 break; 345 346 case UVERBS_ATTR_TYPE_IDRS_ARRAY: 347 return uverbs_process_idrs_array(pbundle, attr_uapi, 348 &e->objs_arr_attr, uattr, 349 attr_bkey); 350 default: 351 return -EOPNOTSUPP; 352 } 353 354 return 0; 355 } 356 357 /* 358 * We search the radix tree with the method prefix and now we want to fast 359 * search the suffix bits to get a particular attribute pointer. It is not 360 * totally clear to me if this breaks the radix tree encasulation or not, but 361 * it uses the iter data to determine if the method iter points at the same 362 * chunk that will store the attribute, if so it just derefs it directly. By 363 * construction in most kernel configs the method and attrs will all fit in a 364 * single radix chunk, so in most cases this will have no search. Other cases 365 * this falls back to a full search. 366 */ 367 static void __rcu **uapi_get_attr_for_method(struct bundle_priv *pbundle, 368 u32 attr_key) 369 { 370 void __rcu **slot; 371 372 if (likely(attr_key < pbundle->radix_slots_len)) { 373 void *entry; 374 375 slot = pbundle->radix_slots + attr_key; 376 entry = rcu_dereference_raw(*slot); 377 if (likely(!radix_tree_is_internal_node(entry) && entry)) 378 return slot; 379 } 380 381 return radix_tree_lookup_slot(pbundle->radix, 382 pbundle->method_key | attr_key); 383 } 384 385 static int uverbs_set_attr(struct bundle_priv *pbundle, 386 struct ib_uverbs_attr *uattr) 387 { 388 u32 attr_key = uapi_key_attr(uattr->attr_id); 389 u32 attr_bkey = uapi_bkey_attr(attr_key); 390 const struct uverbs_api_attr *attr; 391 void __rcu **slot; 392 int ret; 393 394 slot = uapi_get_attr_for_method(pbundle, attr_key); 395 if (!slot) { 396 /* 397 * Kernel does not support the attribute but user-space says it 398 * is mandatory 399 */ 400 if (uattr->flags & UVERBS_ATTR_F_MANDATORY) 401 return -EPROTONOSUPPORT; 402 return 0; 403 } 404 attr = rcu_dereference_protected(*slot, true); 405 406 /* Reject duplicate attributes from user-space */ 407 if (test_bit(attr_bkey, pbundle->bundle.attr_present)) 408 return -EINVAL; 409 410 ret = uverbs_process_attr(pbundle, attr, uattr, attr_bkey); 411 if (ret) 412 return ret; 413 414 __set_bit(attr_bkey, pbundle->bundle.attr_present); 415 416 return 0; 417 } 418 419 static int ib_uverbs_run_method(struct bundle_priv *pbundle, 420 unsigned int num_attrs) 421 { 422 int (*handler)(struct uverbs_attr_bundle *attrs); 423 size_t uattrs_size = array_size(sizeof(*pbundle->uattrs), num_attrs); 424 unsigned int destroy_bkey = pbundle->method_elm->destroy_bkey; 425 unsigned int i; 426 int ret; 427 428 /* See uverbs_disassociate_api() */ 429 handler = srcu_dereference( 430 pbundle->method_elm->handler, 431 &pbundle->bundle.ufile->device->disassociate_srcu); 432 if (!handler) 433 return -EIO; 434 435 pbundle->uattrs = uverbs_alloc(&pbundle->bundle, uattrs_size); 436 if (IS_ERR(pbundle->uattrs)) 437 return PTR_ERR(pbundle->uattrs); 438 if (copy_from_user(pbundle->uattrs, pbundle->user_attrs, uattrs_size)) 439 return -EFAULT; 440 441 for (i = 0; i != num_attrs; i++) { 442 ret = uverbs_set_attr(pbundle, &pbundle->uattrs[i]); 443 if (unlikely(ret)) 444 return ret; 445 } 446 447 /* User space did not provide all the mandatory attributes */ 448 if (unlikely(!bitmap_subset(pbundle->method_elm->attr_mandatory, 449 pbundle->bundle.attr_present, 450 pbundle->method_elm->key_bitmap_len))) 451 return -EINVAL; 452 453 if (pbundle->method_elm->has_udata) 454 uverbs_fill_udata(&pbundle->bundle, 455 &pbundle->bundle.driver_udata, 456 UVERBS_ATTR_UHW_IN, UVERBS_ATTR_UHW_OUT); 457 458 if (destroy_bkey != UVERBS_API_ATTR_BKEY_LEN) { 459 struct uverbs_obj_attr *destroy_attr = 460 &pbundle->bundle.attrs[destroy_bkey].obj_attr; 461 462 ret = uobj_destroy(destroy_attr->uobject); 463 if (ret) 464 return ret; 465 __clear_bit(destroy_bkey, pbundle->uobj_finalize); 466 467 ret = handler(&pbundle->bundle); 468 uobj_put_destroy(destroy_attr->uobject); 469 } else { 470 ret = handler(&pbundle->bundle); 471 } 472 473 /* 474 * Until the drivers are revised to use the bundle directly we have to 475 * assume that the driver wrote to its UHW_OUT and flag userspace 476 * appropriately. 477 */ 478 if (!ret && pbundle->method_elm->has_udata) { 479 const struct uverbs_attr *attr = 480 uverbs_attr_get(&pbundle->bundle, UVERBS_ATTR_UHW_OUT); 481 482 if (!IS_ERR(attr)) 483 ret = uverbs_set_output(&pbundle->bundle, attr); 484 } 485 486 /* 487 * EPROTONOSUPPORT is ONLY to be returned if the ioctl framework can 488 * not invoke the method because the request is not supported. No 489 * other cases should return this code. 490 */ 491 if (WARN_ON_ONCE(ret == -EPROTONOSUPPORT)) 492 return -EINVAL; 493 494 return ret; 495 } 496 497 static int bundle_destroy(struct bundle_priv *pbundle, bool commit) 498 { 499 unsigned int key_bitmap_len = pbundle->method_elm->key_bitmap_len; 500 struct bundle_alloc_head *memblock; 501 unsigned int i; 502 int ret = 0; 503 504 /* fast path for simple uobjects */ 505 i = -1; 506 while ((i = find_next_bit(pbundle->uobj_finalize, key_bitmap_len, 507 i + 1)) < key_bitmap_len) { 508 struct uverbs_attr *attr = &pbundle->bundle.attrs[i]; 509 int current_ret; 510 511 current_ret = uverbs_finalize_object( 512 attr->obj_attr.uobject, 513 attr->obj_attr.attr_elm->spec.u.obj.access, commit); 514 if (!ret) 515 ret = current_ret; 516 } 517 518 i = -1; 519 while ((i = find_next_bit(pbundle->spec_finalize, key_bitmap_len, 520 i + 1)) < key_bitmap_len) { 521 struct uverbs_attr *attr = &pbundle->bundle.attrs[i]; 522 const struct uverbs_api_attr *attr_uapi; 523 void __rcu **slot; 524 int current_ret; 525 526 slot = uapi_get_attr_for_method( 527 pbundle, 528 pbundle->method_key | uapi_bkey_to_key_attr(i)); 529 if (WARN_ON(!slot)) 530 continue; 531 532 attr_uapi = rcu_dereference_protected(*slot, true); 533 534 if (attr_uapi->spec.type == UVERBS_ATTR_TYPE_IDRS_ARRAY) { 535 current_ret = uverbs_free_idrs_array( 536 attr_uapi, &attr->objs_arr_attr, commit); 537 if (!ret) 538 ret = current_ret; 539 } 540 } 541 542 for (memblock = pbundle->allocated_mem; memblock;) { 543 struct bundle_alloc_head *tmp = memblock; 544 545 memblock = memblock->next; 546 kvfree(tmp); 547 } 548 549 return ret; 550 } 551 552 static int ib_uverbs_cmd_verbs(struct ib_uverbs_file *ufile, 553 struct ib_uverbs_ioctl_hdr *hdr, 554 struct ib_uverbs_attr __user *user_attrs) 555 { 556 const struct uverbs_api_ioctl_method *method_elm; 557 struct uverbs_api *uapi = ufile->device->uapi; 558 struct radix_tree_iter attrs_iter; 559 struct bundle_priv *pbundle; 560 struct bundle_priv onstack; 561 void __rcu **slot; 562 int destroy_ret; 563 int ret; 564 565 if (unlikely(hdr->driver_id != uapi->driver_id)) 566 return -EINVAL; 567 568 slot = radix_tree_iter_lookup( 569 &uapi->radix, &attrs_iter, 570 uapi_key_obj(hdr->object_id) | 571 uapi_key_ioctl_method(hdr->method_id)); 572 if (unlikely(!slot)) 573 return -EPROTONOSUPPORT; 574 method_elm = rcu_dereference_protected(*slot, true); 575 576 if (!method_elm->use_stack) { 577 pbundle = kmalloc(method_elm->bundle_size, GFP_KERNEL); 578 if (!pbundle) 579 return -ENOMEM; 580 pbundle->internal_avail = 581 method_elm->bundle_size - 582 offsetof(struct bundle_priv, internal_buffer); 583 pbundle->alloc_head.next = NULL; 584 pbundle->allocated_mem = &pbundle->alloc_head; 585 } else { 586 pbundle = &onstack; 587 pbundle->internal_avail = sizeof(pbundle->internal_buffer); 588 pbundle->allocated_mem = NULL; 589 } 590 591 /* Space for the pbundle->bundle.attrs flex array */ 592 pbundle->method_elm = method_elm; 593 pbundle->method_key = attrs_iter.index; 594 pbundle->bundle.ufile = ufile; 595 pbundle->radix = &uapi->radix; 596 pbundle->radix_slots = slot; 597 pbundle->radix_slots_len = radix_tree_chunk_size(&attrs_iter); 598 pbundle->user_attrs = user_attrs; 599 600 pbundle->internal_used = ALIGN(pbundle->method_elm->key_bitmap_len * 601 sizeof(*pbundle->bundle.attrs), 602 sizeof(*pbundle->internal_buffer)); 603 memset(pbundle->bundle.attr_present, 0, 604 sizeof(pbundle->bundle.attr_present)); 605 memset(pbundle->uobj_finalize, 0, sizeof(pbundle->uobj_finalize)); 606 memset(pbundle->spec_finalize, 0, sizeof(pbundle->spec_finalize)); 607 608 ret = ib_uverbs_run_method(pbundle, hdr->num_attrs); 609 destroy_ret = bundle_destroy(pbundle, ret == 0); 610 if (unlikely(destroy_ret && !ret)) 611 return destroy_ret; 612 613 return ret; 614 } 615 616 long ib_uverbs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 617 { 618 struct ib_uverbs_file *file = filp->private_data; 619 struct ib_uverbs_ioctl_hdr __user *user_hdr = 620 (struct ib_uverbs_ioctl_hdr __user *)arg; 621 struct ib_uverbs_ioctl_hdr hdr; 622 int srcu_key; 623 int err; 624 625 if (unlikely(cmd != RDMA_VERBS_IOCTL)) 626 return -ENOIOCTLCMD; 627 628 err = copy_from_user(&hdr, user_hdr, sizeof(hdr)); 629 if (err) 630 return -EFAULT; 631 632 if (hdr.length > PAGE_SIZE || 633 hdr.length != struct_size(&hdr, attrs, hdr.num_attrs)) 634 return -EINVAL; 635 636 if (hdr.reserved1 || hdr.reserved2) 637 return -EPROTONOSUPPORT; 638 639 srcu_key = srcu_read_lock(&file->device->disassociate_srcu); 640 err = ib_uverbs_cmd_verbs(file, &hdr, user_hdr->attrs); 641 srcu_read_unlock(&file->device->disassociate_srcu, srcu_key); 642 return err; 643 } 644 645 int uverbs_get_flags64(u64 *to, const struct uverbs_attr_bundle *attrs_bundle, 646 size_t idx, u64 allowed_bits) 647 { 648 const struct uverbs_attr *attr; 649 u64 flags; 650 651 attr = uverbs_attr_get(attrs_bundle, idx); 652 /* Missing attribute means 0 flags */ 653 if (IS_ERR(attr)) { 654 *to = 0; 655 return 0; 656 } 657 658 /* 659 * New userspace code should use 8 bytes to pass flags, but we 660 * transparently support old userspaces that were using 4 bytes as 661 * well. 662 */ 663 if (attr->ptr_attr.len == 8) 664 flags = attr->ptr_attr.data; 665 else if (attr->ptr_attr.len == 4) 666 flags = *(u32 *)&attr->ptr_attr.data; 667 else 668 return -EINVAL; 669 670 if (flags & ~allowed_bits) 671 return -EINVAL; 672 673 *to = flags; 674 return 0; 675 } 676 EXPORT_SYMBOL(uverbs_get_flags64); 677 678 int uverbs_get_flags32(u32 *to, const struct uverbs_attr_bundle *attrs_bundle, 679 size_t idx, u64 allowed_bits) 680 { 681 u64 flags; 682 int ret; 683 684 ret = uverbs_get_flags64(&flags, attrs_bundle, idx, allowed_bits); 685 if (ret) 686 return ret; 687 688 if (flags > U32_MAX) 689 return -EINVAL; 690 *to = flags; 691 692 return 0; 693 } 694 EXPORT_SYMBOL(uverbs_get_flags32); 695 696 /* 697 * Fill a ib_udata struct (core or uhw) using the given attribute IDs. 698 * This is primarily used to convert the UVERBS_ATTR_UHW() into the 699 * ib_udata format used by the drivers. 700 */ 701 void uverbs_fill_udata(struct uverbs_attr_bundle *bundle, 702 struct ib_udata *udata, unsigned int attr_in, 703 unsigned int attr_out) 704 { 705 struct bundle_priv *pbundle = 706 container_of(bundle, struct bundle_priv, bundle); 707 const struct uverbs_attr *in = 708 uverbs_attr_get(&pbundle->bundle, attr_in); 709 const struct uverbs_attr *out = 710 uverbs_attr_get(&pbundle->bundle, attr_out); 711 712 if (!IS_ERR(in)) { 713 udata->inlen = in->ptr_attr.len; 714 if (uverbs_attr_ptr_is_inline(in)) 715 udata->inbuf = 716 &pbundle->user_attrs[in->ptr_attr.uattr_idx] 717 .data; 718 else 719 udata->inbuf = u64_to_user_ptr(in->ptr_attr.data); 720 } else { 721 udata->inbuf = NULL; 722 udata->inlen = 0; 723 } 724 725 if (!IS_ERR(out)) { 726 udata->outbuf = u64_to_user_ptr(out->ptr_attr.data); 727 udata->outlen = out->ptr_attr.len; 728 } else { 729 udata->outbuf = NULL; 730 udata->outlen = 0; 731 } 732 } 733 734 int uverbs_copy_to(const struct uverbs_attr_bundle *bundle, size_t idx, 735 const void *from, size_t size) 736 { 737 const struct uverbs_attr *attr = uverbs_attr_get(bundle, idx); 738 size_t min_size; 739 740 if (IS_ERR(attr)) 741 return PTR_ERR(attr); 742 743 min_size = min_t(size_t, attr->ptr_attr.len, size); 744 if (copy_to_user(u64_to_user_ptr(attr->ptr_attr.data), from, min_size)) 745 return -EFAULT; 746 747 return uverbs_set_output(bundle, attr); 748 } 749 EXPORT_SYMBOL(uverbs_copy_to); 750 751 752 /* 753 * This is only used if the caller has directly used copy_to_use to write the 754 * data. It signals to user space that the buffer is filled in. 755 */ 756 int uverbs_output_written(const struct uverbs_attr_bundle *bundle, size_t idx) 757 { 758 const struct uverbs_attr *attr = uverbs_attr_get(bundle, idx); 759 760 if (IS_ERR(attr)) 761 return PTR_ERR(attr); 762 763 return uverbs_set_output(bundle, attr); 764 } 765 766 int _uverbs_get_const(s64 *to, const struct uverbs_attr_bundle *attrs_bundle, 767 size_t idx, s64 lower_bound, u64 upper_bound, 768 s64 *def_val) 769 { 770 const struct uverbs_attr *attr; 771 772 attr = uverbs_attr_get(attrs_bundle, idx); 773 if (IS_ERR(attr)) { 774 if ((PTR_ERR(attr) != -ENOENT) || !def_val) 775 return PTR_ERR(attr); 776 777 *to = *def_val; 778 } else { 779 *to = attr->ptr_attr.data; 780 } 781 782 if (*to < lower_bound || (*to > 0 && (u64)*to > upper_bound)) 783 return -EINVAL; 784 785 return 0; 786 } 787 EXPORT_SYMBOL(_uverbs_get_const); 788 789 int uverbs_copy_to_struct_or_zero(const struct uverbs_attr_bundle *bundle, 790 size_t idx, const void *from, size_t size) 791 { 792 const struct uverbs_attr *attr = uverbs_attr_get(bundle, idx); 793 794 if (size < attr->ptr_attr.len) { 795 if (clear_user(u64_to_user_ptr(attr->ptr_attr.data) + size, 796 attr->ptr_attr.len - size)) 797 return -EFAULT; 798 } 799 return uverbs_copy_to(bundle, idx, from, size); 800 } 801