2 * Copyright (c) 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005, 2006, 2007 Cisco Systems. All rights reserved.
4 * Copyright (c) 2005 PathScale, Inc. All rights reserved.
5 * Copyright (c) 2006 Mellanox Technologies. All rights reserved.
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
36 #include <linux/file.h>
38 #include <linux/slab.h>
40 #include <asm/uaccess.h>
43 #include "core_priv.h"
45 struct uverbs_lock_class
{
46 struct lock_class_key key
;
50 static struct uverbs_lock_class pd_lock_class
= { .name
= "PD-uobj" };
51 static struct uverbs_lock_class mr_lock_class
= { .name
= "MR-uobj" };
52 static struct uverbs_lock_class mw_lock_class
= { .name
= "MW-uobj" };
53 static struct uverbs_lock_class cq_lock_class
= { .name
= "CQ-uobj" };
54 static struct uverbs_lock_class qp_lock_class
= { .name
= "QP-uobj" };
55 static struct uverbs_lock_class ah_lock_class
= { .name
= "AH-uobj" };
56 static struct uverbs_lock_class srq_lock_class
= { .name
= "SRQ-uobj" };
57 static struct uverbs_lock_class xrcd_lock_class
= { .name
= "XRCD-uobj" };
58 static struct uverbs_lock_class rule_lock_class
= { .name
= "RULE-uobj" };
61 * The ib_uobject locking scheme is as follows:
63 * - ib_uverbs_idr_lock protects the uverbs idrs themselves, so it
64 * needs to be held during all idr operations. When an object is
65 * looked up, a reference must be taken on the object's kref before
68 * - Each object also has an rwsem. This rwsem must be held for
69 * reading while an operation that uses the object is performed.
70 * For example, while registering an MR, the associated PD's
71 * uobject.mutex must be held for reading. The rwsem must be held
72 * for writing while initializing or destroying an object.
74 * - In addition, each object has a "live" flag. If this flag is not
75 * set, then lookups of the object will fail even if it is found in
76 * the idr. This handles a reader that blocks and does not acquire
77 * the rwsem until after the object is destroyed. The destroy
78 * operation will set the live flag to 0 and then drop the rwsem;
79 * this will allow the reader to acquire the rwsem, see that the
80 * live flag is 0, and then drop the rwsem and its reference to
81 * object. The underlying storage will not be freed until the last
82 * reference to the object is dropped.
85 static void init_uobj(struct ib_uobject
*uobj
, u64 user_handle
,
86 struct ib_ucontext
*context
, struct uverbs_lock_class
*c
)
88 uobj
->user_handle
= user_handle
;
89 uobj
->context
= context
;
90 kref_init(&uobj
->ref
);
91 init_rwsem(&uobj
->mutex
);
92 lockdep_set_class_and_name(&uobj
->mutex
, &c
->key
, c
->name
);
96 static void release_uobj(struct kref
*kref
)
98 kfree(container_of(kref
, struct ib_uobject
, ref
));
101 static void put_uobj(struct ib_uobject
*uobj
)
103 kref_put(&uobj
->ref
, release_uobj
);
106 static void put_uobj_read(struct ib_uobject
*uobj
)
108 up_read(&uobj
->mutex
);
112 static void put_uobj_write(struct ib_uobject
*uobj
)
114 up_write(&uobj
->mutex
);
118 static int idr_add_uobj(struct idr
*idr
, struct ib_uobject
*uobj
)
122 idr_preload(GFP_KERNEL
);
123 spin_lock(&ib_uverbs_idr_lock
);
125 ret
= idr_alloc(idr
, uobj
, 0, 0, GFP_NOWAIT
);
129 spin_unlock(&ib_uverbs_idr_lock
);
132 return ret
< 0 ? ret
: 0;
135 void idr_remove_uobj(struct idr
*idr
, struct ib_uobject
*uobj
)
137 spin_lock(&ib_uverbs_idr_lock
);
138 idr_remove(idr
, uobj
->id
);
139 spin_unlock(&ib_uverbs_idr_lock
);
142 static struct ib_uobject
*__idr_get_uobj(struct idr
*idr
, int id
,
143 struct ib_ucontext
*context
)
145 struct ib_uobject
*uobj
;
147 spin_lock(&ib_uverbs_idr_lock
);
148 uobj
= idr_find(idr
, id
);
150 if (uobj
->context
== context
)
151 kref_get(&uobj
->ref
);
155 spin_unlock(&ib_uverbs_idr_lock
);
160 static struct ib_uobject
*idr_read_uobj(struct idr
*idr
, int id
,
161 struct ib_ucontext
*context
, int nested
)
163 struct ib_uobject
*uobj
;
165 uobj
= __idr_get_uobj(idr
, id
, context
);
170 down_read_nested(&uobj
->mutex
, SINGLE_DEPTH_NESTING
);
172 down_read(&uobj
->mutex
);
181 static struct ib_uobject
*idr_write_uobj(struct idr
*idr
, int id
,
182 struct ib_ucontext
*context
)
184 struct ib_uobject
*uobj
;
186 uobj
= __idr_get_uobj(idr
, id
, context
);
190 down_write(&uobj
->mutex
);
192 put_uobj_write(uobj
);
199 static void *idr_read_obj(struct idr
*idr
, int id
, struct ib_ucontext
*context
,
202 struct ib_uobject
*uobj
;
204 uobj
= idr_read_uobj(idr
, id
, context
, nested
);
205 return uobj
? uobj
->object
: NULL
;
208 static struct ib_pd
*idr_read_pd(int pd_handle
, struct ib_ucontext
*context
)
210 return idr_read_obj(&ib_uverbs_pd_idr
, pd_handle
, context
, 0);
213 static void put_pd_read(struct ib_pd
*pd
)
215 put_uobj_read(pd
->uobject
);
218 static struct ib_cq
*idr_read_cq(int cq_handle
, struct ib_ucontext
*context
, int nested
)
220 return idr_read_obj(&ib_uverbs_cq_idr
, cq_handle
, context
, nested
);
223 static void put_cq_read(struct ib_cq
*cq
)
225 put_uobj_read(cq
->uobject
);
228 static struct ib_ah
*idr_read_ah(int ah_handle
, struct ib_ucontext
*context
)
230 return idr_read_obj(&ib_uverbs_ah_idr
, ah_handle
, context
, 0);
233 static void put_ah_read(struct ib_ah
*ah
)
235 put_uobj_read(ah
->uobject
);
238 static struct ib_qp
*idr_read_qp(int qp_handle
, struct ib_ucontext
*context
)
240 return idr_read_obj(&ib_uverbs_qp_idr
, qp_handle
, context
, 0);
243 static struct ib_qp
*idr_write_qp(int qp_handle
, struct ib_ucontext
*context
)
245 struct ib_uobject
*uobj
;
247 uobj
= idr_write_uobj(&ib_uverbs_qp_idr
, qp_handle
, context
);
248 return uobj
? uobj
->object
: NULL
;
251 static void put_qp_read(struct ib_qp
*qp
)
253 put_uobj_read(qp
->uobject
);
256 static void put_qp_write(struct ib_qp
*qp
)
258 put_uobj_write(qp
->uobject
);
261 static struct ib_srq
*idr_read_srq(int srq_handle
, struct ib_ucontext
*context
)
263 return idr_read_obj(&ib_uverbs_srq_idr
, srq_handle
, context
, 0);
266 static void put_srq_read(struct ib_srq
*srq
)
268 put_uobj_read(srq
->uobject
);
271 static struct ib_xrcd
*idr_read_xrcd(int xrcd_handle
, struct ib_ucontext
*context
,
272 struct ib_uobject
**uobj
)
274 *uobj
= idr_read_uobj(&ib_uverbs_xrcd_idr
, xrcd_handle
, context
, 0);
275 return *uobj
? (*uobj
)->object
: NULL
;
278 static void put_xrcd_read(struct ib_uobject
*uobj
)
283 ssize_t
ib_uverbs_get_context(struct ib_uverbs_file
*file
,
284 const char __user
*buf
,
285 int in_len
, int out_len
)
287 struct ib_uverbs_get_context cmd
;
288 struct ib_uverbs_get_context_resp resp
;
289 struct ib_udata udata
;
290 struct ib_device
*ibdev
= file
->device
->ib_dev
;
291 struct ib_ucontext
*ucontext
;
295 if (out_len
< sizeof resp
)
298 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
301 mutex_lock(&file
->mutex
);
303 if (file
->ucontext
) {
308 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
309 (unsigned long) cmd
.response
+ sizeof resp
,
310 in_len
- sizeof cmd
, out_len
- sizeof resp
);
312 ucontext
= ibdev
->alloc_ucontext(ibdev
, &udata
);
313 if (IS_ERR(ucontext
)) {
314 ret
= PTR_ERR(ucontext
);
318 ucontext
->device
= ibdev
;
319 INIT_LIST_HEAD(&ucontext
->pd_list
);
320 INIT_LIST_HEAD(&ucontext
->mr_list
);
321 INIT_LIST_HEAD(&ucontext
->mw_list
);
322 INIT_LIST_HEAD(&ucontext
->cq_list
);
323 INIT_LIST_HEAD(&ucontext
->qp_list
);
324 INIT_LIST_HEAD(&ucontext
->srq_list
);
325 INIT_LIST_HEAD(&ucontext
->ah_list
);
326 INIT_LIST_HEAD(&ucontext
->xrcd_list
);
327 INIT_LIST_HEAD(&ucontext
->rule_list
);
328 ucontext
->closing
= 0;
330 resp
.num_comp_vectors
= file
->device
->num_comp_vectors
;
332 ret
= get_unused_fd_flags(O_CLOEXEC
);
337 filp
= ib_uverbs_alloc_event_file(file
, 1);
343 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
344 &resp
, sizeof resp
)) {
349 file
->async_file
= filp
->private_data
;
351 INIT_IB_EVENT_HANDLER(&file
->event_handler
, file
->device
->ib_dev
,
352 ib_uverbs_event_handler
);
353 ret
= ib_register_event_handler(&file
->event_handler
);
357 kref_get(&file
->async_file
->ref
);
358 kref_get(&file
->ref
);
359 file
->ucontext
= ucontext
;
361 fd_install(resp
.async_fd
, filp
);
363 mutex_unlock(&file
->mutex
);
371 put_unused_fd(resp
.async_fd
);
374 ibdev
->dealloc_ucontext(ucontext
);
377 mutex_unlock(&file
->mutex
);
381 static void copy_query_dev_fields(struct ib_uverbs_file
*file
,
382 struct ib_uverbs_query_device_resp
*resp
,
383 struct ib_device_attr
*attr
)
385 resp
->fw_ver
= attr
->fw_ver
;
386 resp
->node_guid
= file
->device
->ib_dev
->node_guid
;
387 resp
->sys_image_guid
= attr
->sys_image_guid
;
388 resp
->max_mr_size
= attr
->max_mr_size
;
389 resp
->page_size_cap
= attr
->page_size_cap
;
390 resp
->vendor_id
= attr
->vendor_id
;
391 resp
->vendor_part_id
= attr
->vendor_part_id
;
392 resp
->hw_ver
= attr
->hw_ver
;
393 resp
->max_qp
= attr
->max_qp
;
394 resp
->max_qp_wr
= attr
->max_qp_wr
;
395 resp
->device_cap_flags
= attr
->device_cap_flags
;
396 resp
->max_sge
= attr
->max_sge
;
397 resp
->max_sge_rd
= attr
->max_sge_rd
;
398 resp
->max_cq
= attr
->max_cq
;
399 resp
->max_cqe
= attr
->max_cqe
;
400 resp
->max_mr
= attr
->max_mr
;
401 resp
->max_pd
= attr
->max_pd
;
402 resp
->max_qp_rd_atom
= attr
->max_qp_rd_atom
;
403 resp
->max_ee_rd_atom
= attr
->max_ee_rd_atom
;
404 resp
->max_res_rd_atom
= attr
->max_res_rd_atom
;
405 resp
->max_qp_init_rd_atom
= attr
->max_qp_init_rd_atom
;
406 resp
->max_ee_init_rd_atom
= attr
->max_ee_init_rd_atom
;
407 resp
->atomic_cap
= attr
->atomic_cap
;
408 resp
->max_ee
= attr
->max_ee
;
409 resp
->max_rdd
= attr
->max_rdd
;
410 resp
->max_mw
= attr
->max_mw
;
411 resp
->max_raw_ipv6_qp
= attr
->max_raw_ipv6_qp
;
412 resp
->max_raw_ethy_qp
= attr
->max_raw_ethy_qp
;
413 resp
->max_mcast_grp
= attr
->max_mcast_grp
;
414 resp
->max_mcast_qp_attach
= attr
->max_mcast_qp_attach
;
415 resp
->max_total_mcast_qp_attach
= attr
->max_total_mcast_qp_attach
;
416 resp
->max_ah
= attr
->max_ah
;
417 resp
->max_fmr
= attr
->max_fmr
;
418 resp
->max_map_per_fmr
= attr
->max_map_per_fmr
;
419 resp
->max_srq
= attr
->max_srq
;
420 resp
->max_srq_wr
= attr
->max_srq_wr
;
421 resp
->max_srq_sge
= attr
->max_srq_sge
;
422 resp
->max_pkeys
= attr
->max_pkeys
;
423 resp
->local_ca_ack_delay
= attr
->local_ca_ack_delay
;
424 resp
->phys_port_cnt
= file
->device
->ib_dev
->phys_port_cnt
;
427 ssize_t
ib_uverbs_query_device(struct ib_uverbs_file
*file
,
428 const char __user
*buf
,
429 int in_len
, int out_len
)
431 struct ib_uverbs_query_device cmd
;
432 struct ib_uverbs_query_device_resp resp
;
433 struct ib_device_attr attr
;
436 if (out_len
< sizeof resp
)
439 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
442 ret
= ib_query_device(file
->device
->ib_dev
, &attr
);
446 memset(&resp
, 0, sizeof resp
);
447 copy_query_dev_fields(file
, &resp
, &attr
);
449 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
456 ssize_t
ib_uverbs_query_port(struct ib_uverbs_file
*file
,
457 const char __user
*buf
,
458 int in_len
, int out_len
)
460 struct ib_uverbs_query_port cmd
;
461 struct ib_uverbs_query_port_resp resp
;
462 struct ib_port_attr attr
;
465 if (out_len
< sizeof resp
)
468 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
471 ret
= ib_query_port(file
->device
->ib_dev
, cmd
.port_num
, &attr
);
475 memset(&resp
, 0, sizeof resp
);
477 resp
.state
= attr
.state
;
478 resp
.max_mtu
= attr
.max_mtu
;
479 resp
.active_mtu
= attr
.active_mtu
;
480 resp
.gid_tbl_len
= attr
.gid_tbl_len
;
481 resp
.port_cap_flags
= attr
.port_cap_flags
;
482 resp
.max_msg_sz
= attr
.max_msg_sz
;
483 resp
.bad_pkey_cntr
= attr
.bad_pkey_cntr
;
484 resp
.qkey_viol_cntr
= attr
.qkey_viol_cntr
;
485 resp
.pkey_tbl_len
= attr
.pkey_tbl_len
;
487 resp
.sm_lid
= attr
.sm_lid
;
489 resp
.max_vl_num
= attr
.max_vl_num
;
490 resp
.sm_sl
= attr
.sm_sl
;
491 resp
.subnet_timeout
= attr
.subnet_timeout
;
492 resp
.init_type_reply
= attr
.init_type_reply
;
493 resp
.active_width
= attr
.active_width
;
494 resp
.active_speed
= attr
.active_speed
;
495 resp
.phys_state
= attr
.phys_state
;
496 resp
.link_layer
= rdma_port_get_link_layer(file
->device
->ib_dev
,
499 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
506 ssize_t
ib_uverbs_alloc_pd(struct ib_uverbs_file
*file
,
507 const char __user
*buf
,
508 int in_len
, int out_len
)
510 struct ib_uverbs_alloc_pd cmd
;
511 struct ib_uverbs_alloc_pd_resp resp
;
512 struct ib_udata udata
;
513 struct ib_uobject
*uobj
;
517 if (out_len
< sizeof resp
)
520 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
523 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
524 (unsigned long) cmd
.response
+ sizeof resp
,
525 in_len
- sizeof cmd
, out_len
- sizeof resp
);
527 uobj
= kmalloc(sizeof *uobj
, GFP_KERNEL
);
531 init_uobj(uobj
, 0, file
->ucontext
, &pd_lock_class
);
532 down_write(&uobj
->mutex
);
534 pd
= file
->device
->ib_dev
->alloc_pd(file
->device
->ib_dev
,
535 file
->ucontext
, &udata
);
541 pd
->device
= file
->device
->ib_dev
;
543 atomic_set(&pd
->usecnt
, 0);
546 ret
= idr_add_uobj(&ib_uverbs_pd_idr
, uobj
);
550 memset(&resp
, 0, sizeof resp
);
551 resp
.pd_handle
= uobj
->id
;
553 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
554 &resp
, sizeof resp
)) {
559 mutex_lock(&file
->mutex
);
560 list_add_tail(&uobj
->list
, &file
->ucontext
->pd_list
);
561 mutex_unlock(&file
->mutex
);
565 up_write(&uobj
->mutex
);
570 idr_remove_uobj(&ib_uverbs_pd_idr
, uobj
);
576 put_uobj_write(uobj
);
580 ssize_t
ib_uverbs_dealloc_pd(struct ib_uverbs_file
*file
,
581 const char __user
*buf
,
582 int in_len
, int out_len
)
584 struct ib_uverbs_dealloc_pd cmd
;
585 struct ib_uobject
*uobj
;
588 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
591 uobj
= idr_write_uobj(&ib_uverbs_pd_idr
, cmd
.pd_handle
, file
->ucontext
);
595 ret
= ib_dealloc_pd(uobj
->object
);
599 put_uobj_write(uobj
);
604 idr_remove_uobj(&ib_uverbs_pd_idr
, uobj
);
606 mutex_lock(&file
->mutex
);
607 list_del(&uobj
->list
);
608 mutex_unlock(&file
->mutex
);
615 struct xrcd_table_entry
{
617 struct ib_xrcd
*xrcd
;
621 static int xrcd_table_insert(struct ib_uverbs_device
*dev
,
623 struct ib_xrcd
*xrcd
)
625 struct xrcd_table_entry
*entry
, *scan
;
626 struct rb_node
**p
= &dev
->xrcd_tree
.rb_node
;
627 struct rb_node
*parent
= NULL
;
629 entry
= kmalloc(sizeof *entry
, GFP_KERNEL
);
634 entry
->inode
= inode
;
638 scan
= rb_entry(parent
, struct xrcd_table_entry
, node
);
640 if (inode
< scan
->inode
) {
642 } else if (inode
> scan
->inode
) {
650 rb_link_node(&entry
->node
, parent
, p
);
651 rb_insert_color(&entry
->node
, &dev
->xrcd_tree
);
656 static struct xrcd_table_entry
*xrcd_table_search(struct ib_uverbs_device
*dev
,
659 struct xrcd_table_entry
*entry
;
660 struct rb_node
*p
= dev
->xrcd_tree
.rb_node
;
663 entry
= rb_entry(p
, struct xrcd_table_entry
, node
);
665 if (inode
< entry
->inode
)
667 else if (inode
> entry
->inode
)
676 static struct ib_xrcd
*find_xrcd(struct ib_uverbs_device
*dev
, struct inode
*inode
)
678 struct xrcd_table_entry
*entry
;
680 entry
= xrcd_table_search(dev
, inode
);
687 static void xrcd_table_delete(struct ib_uverbs_device
*dev
,
690 struct xrcd_table_entry
*entry
;
692 entry
= xrcd_table_search(dev
, inode
);
695 rb_erase(&entry
->node
, &dev
->xrcd_tree
);
700 ssize_t
ib_uverbs_open_xrcd(struct ib_uverbs_file
*file
,
701 const char __user
*buf
, int in_len
,
704 struct ib_uverbs_open_xrcd cmd
;
705 struct ib_uverbs_open_xrcd_resp resp
;
706 struct ib_udata udata
;
707 struct ib_uxrcd_object
*obj
;
708 struct ib_xrcd
*xrcd
= NULL
;
709 struct fd f
= {NULL
, 0};
710 struct inode
*inode
= NULL
;
714 if (out_len
< sizeof resp
)
717 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
720 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
721 (unsigned long) cmd
.response
+ sizeof resp
,
722 in_len
- sizeof cmd
, out_len
- sizeof resp
);
724 mutex_lock(&file
->device
->xrcd_tree_mutex
);
727 /* search for file descriptor */
731 goto err_tree_mutex_unlock
;
734 inode
= file_inode(f
.file
);
735 xrcd
= find_xrcd(file
->device
, inode
);
736 if (!xrcd
&& !(cmd
.oflags
& O_CREAT
)) {
737 /* no file descriptor. Need CREATE flag */
739 goto err_tree_mutex_unlock
;
742 if (xrcd
&& cmd
.oflags
& O_EXCL
) {
744 goto err_tree_mutex_unlock
;
748 obj
= kmalloc(sizeof *obj
, GFP_KERNEL
);
751 goto err_tree_mutex_unlock
;
754 init_uobj(&obj
->uobject
, 0, file
->ucontext
, &xrcd_lock_class
);
756 down_write(&obj
->uobject
.mutex
);
759 xrcd
= file
->device
->ib_dev
->alloc_xrcd(file
->device
->ib_dev
,
760 file
->ucontext
, &udata
);
767 xrcd
->device
= file
->device
->ib_dev
;
768 atomic_set(&xrcd
->usecnt
, 0);
769 mutex_init(&xrcd
->tgt_qp_mutex
);
770 INIT_LIST_HEAD(&xrcd
->tgt_qp_list
);
774 atomic_set(&obj
->refcnt
, 0);
775 obj
->uobject
.object
= xrcd
;
776 ret
= idr_add_uobj(&ib_uverbs_xrcd_idr
, &obj
->uobject
);
780 memset(&resp
, 0, sizeof resp
);
781 resp
.xrcd_handle
= obj
->uobject
.id
;
785 /* create new inode/xrcd table entry */
786 ret
= xrcd_table_insert(file
->device
, inode
, xrcd
);
788 goto err_insert_xrcd
;
790 atomic_inc(&xrcd
->usecnt
);
793 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
794 &resp
, sizeof resp
)) {
802 mutex_lock(&file
->mutex
);
803 list_add_tail(&obj
->uobject
.list
, &file
->ucontext
->xrcd_list
);
804 mutex_unlock(&file
->mutex
);
806 obj
->uobject
.live
= 1;
807 up_write(&obj
->uobject
.mutex
);
809 mutex_unlock(&file
->device
->xrcd_tree_mutex
);
815 xrcd_table_delete(file
->device
, inode
);
816 atomic_dec(&xrcd
->usecnt
);
820 idr_remove_uobj(&ib_uverbs_xrcd_idr
, &obj
->uobject
);
823 ib_dealloc_xrcd(xrcd
);
826 put_uobj_write(&obj
->uobject
);
828 err_tree_mutex_unlock
:
832 mutex_unlock(&file
->device
->xrcd_tree_mutex
);
837 ssize_t
ib_uverbs_close_xrcd(struct ib_uverbs_file
*file
,
838 const char __user
*buf
, int in_len
,
841 struct ib_uverbs_close_xrcd cmd
;
842 struct ib_uobject
*uobj
;
843 struct ib_xrcd
*xrcd
= NULL
;
844 struct inode
*inode
= NULL
;
845 struct ib_uxrcd_object
*obj
;
849 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
852 mutex_lock(&file
->device
->xrcd_tree_mutex
);
853 uobj
= idr_write_uobj(&ib_uverbs_xrcd_idr
, cmd
.xrcd_handle
, file
->ucontext
);
861 obj
= container_of(uobj
, struct ib_uxrcd_object
, uobject
);
862 if (atomic_read(&obj
->refcnt
)) {
863 put_uobj_write(uobj
);
868 if (!inode
|| atomic_dec_and_test(&xrcd
->usecnt
)) {
869 ret
= ib_dealloc_xrcd(uobj
->object
);
876 atomic_inc(&xrcd
->usecnt
);
878 put_uobj_write(uobj
);
884 xrcd_table_delete(file
->device
, inode
);
886 idr_remove_uobj(&ib_uverbs_xrcd_idr
, uobj
);
887 mutex_lock(&file
->mutex
);
888 list_del(&uobj
->list
);
889 mutex_unlock(&file
->mutex
);
895 mutex_unlock(&file
->device
->xrcd_tree_mutex
);
899 void ib_uverbs_dealloc_xrcd(struct ib_uverbs_device
*dev
,
900 struct ib_xrcd
*xrcd
)
905 if (inode
&& !atomic_dec_and_test(&xrcd
->usecnt
))
908 ib_dealloc_xrcd(xrcd
);
911 xrcd_table_delete(dev
, inode
);
914 ssize_t
ib_uverbs_reg_mr(struct ib_uverbs_file
*file
,
915 const char __user
*buf
, int in_len
,
918 struct ib_uverbs_reg_mr cmd
;
919 struct ib_uverbs_reg_mr_resp resp
;
920 struct ib_udata udata
;
921 struct ib_uobject
*uobj
;
926 if (out_len
< sizeof resp
)
929 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
932 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
933 (unsigned long) cmd
.response
+ sizeof resp
,
934 in_len
- sizeof cmd
, out_len
- sizeof resp
);
936 if ((cmd
.start
& ~PAGE_MASK
) != (cmd
.hca_va
& ~PAGE_MASK
))
939 ret
= ib_check_mr_access(cmd
.access_flags
);
943 uobj
= kmalloc(sizeof *uobj
, GFP_KERNEL
);
947 init_uobj(uobj
, 0, file
->ucontext
, &mr_lock_class
);
948 down_write(&uobj
->mutex
);
950 pd
= idr_read_pd(cmd
.pd_handle
, file
->ucontext
);
956 if (cmd
.access_flags
& IB_ACCESS_ON_DEMAND
) {
957 struct ib_device_attr attr
;
959 ret
= ib_query_device(pd
->device
, &attr
);
960 if (ret
|| !(attr
.device_cap_flags
&
961 IB_DEVICE_ON_DEMAND_PAGING
)) {
962 pr_debug("ODP support not available\n");
968 mr
= pd
->device
->reg_user_mr(pd
, cmd
.start
, cmd
.length
, cmd
.hca_va
,
969 cmd
.access_flags
, &udata
);
975 mr
->device
= pd
->device
;
978 atomic_inc(&pd
->usecnt
);
979 atomic_set(&mr
->usecnt
, 0);
982 ret
= idr_add_uobj(&ib_uverbs_mr_idr
, uobj
);
986 memset(&resp
, 0, sizeof resp
);
987 resp
.lkey
= mr
->lkey
;
988 resp
.rkey
= mr
->rkey
;
989 resp
.mr_handle
= uobj
->id
;
991 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
992 &resp
, sizeof resp
)) {
999 mutex_lock(&file
->mutex
);
1000 list_add_tail(&uobj
->list
, &file
->ucontext
->mr_list
);
1001 mutex_unlock(&file
->mutex
);
1005 up_write(&uobj
->mutex
);
1010 idr_remove_uobj(&ib_uverbs_mr_idr
, uobj
);
1019 put_uobj_write(uobj
);
1023 ssize_t
ib_uverbs_rereg_mr(struct ib_uverbs_file
*file
,
1024 const char __user
*buf
, int in_len
,
1027 struct ib_uverbs_rereg_mr cmd
;
1028 struct ib_uverbs_rereg_mr_resp resp
;
1029 struct ib_udata udata
;
1030 struct ib_pd
*pd
= NULL
;
1032 struct ib_pd
*old_pd
;
1034 struct ib_uobject
*uobj
;
1036 if (out_len
< sizeof(resp
))
1039 if (copy_from_user(&cmd
, buf
, sizeof(cmd
)))
1042 INIT_UDATA(&udata
, buf
+ sizeof(cmd
),
1043 (unsigned long) cmd
.response
+ sizeof(resp
),
1044 in_len
- sizeof(cmd
), out_len
- sizeof(resp
));
1046 if (cmd
.flags
& ~IB_MR_REREG_SUPPORTED
|| !cmd
.flags
)
1049 if ((cmd
.flags
& IB_MR_REREG_TRANS
) &&
1050 (!cmd
.start
|| !cmd
.hca_va
|| 0 >= cmd
.length
||
1051 (cmd
.start
& ~PAGE_MASK
) != (cmd
.hca_va
& ~PAGE_MASK
)))
1054 uobj
= idr_write_uobj(&ib_uverbs_mr_idr
, cmd
.mr_handle
,
1062 if (cmd
.flags
& IB_MR_REREG_ACCESS
) {
1063 ret
= ib_check_mr_access(cmd
.access_flags
);
1068 if (cmd
.flags
& IB_MR_REREG_PD
) {
1069 pd
= idr_read_pd(cmd
.pd_handle
, file
->ucontext
);
1076 if (atomic_read(&mr
->usecnt
)) {
1082 ret
= mr
->device
->rereg_user_mr(mr
, cmd
.flags
, cmd
.start
,
1083 cmd
.length
, cmd
.hca_va
,
1084 cmd
.access_flags
, pd
, &udata
);
1086 if (cmd
.flags
& IB_MR_REREG_PD
) {
1087 atomic_inc(&pd
->usecnt
);
1089 atomic_dec(&old_pd
->usecnt
);
1095 memset(&resp
, 0, sizeof(resp
));
1096 resp
.lkey
= mr
->lkey
;
1097 resp
.rkey
= mr
->rkey
;
1099 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
1100 &resp
, sizeof(resp
)))
1106 if (cmd
.flags
& IB_MR_REREG_PD
)
1111 put_uobj_write(mr
->uobject
);
1116 ssize_t
ib_uverbs_dereg_mr(struct ib_uverbs_file
*file
,
1117 const char __user
*buf
, int in_len
,
1120 struct ib_uverbs_dereg_mr cmd
;
1122 struct ib_uobject
*uobj
;
1125 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1128 uobj
= idr_write_uobj(&ib_uverbs_mr_idr
, cmd
.mr_handle
, file
->ucontext
);
1134 ret
= ib_dereg_mr(mr
);
1138 put_uobj_write(uobj
);
1143 idr_remove_uobj(&ib_uverbs_mr_idr
, uobj
);
1145 mutex_lock(&file
->mutex
);
1146 list_del(&uobj
->list
);
1147 mutex_unlock(&file
->mutex
);
1154 ssize_t
ib_uverbs_alloc_mw(struct ib_uverbs_file
*file
,
1155 const char __user
*buf
, int in_len
,
1158 struct ib_uverbs_alloc_mw cmd
;
1159 struct ib_uverbs_alloc_mw_resp resp
;
1160 struct ib_uobject
*uobj
;
1165 if (out_len
< sizeof(resp
))
1168 if (copy_from_user(&cmd
, buf
, sizeof(cmd
)))
1171 uobj
= kmalloc(sizeof(*uobj
), GFP_KERNEL
);
1175 init_uobj(uobj
, 0, file
->ucontext
, &mw_lock_class
);
1176 down_write(&uobj
->mutex
);
1178 pd
= idr_read_pd(cmd
.pd_handle
, file
->ucontext
);
1184 mw
= pd
->device
->alloc_mw(pd
, cmd
.mw_type
);
1190 mw
->device
= pd
->device
;
1193 atomic_inc(&pd
->usecnt
);
1196 ret
= idr_add_uobj(&ib_uverbs_mw_idr
, uobj
);
1200 memset(&resp
, 0, sizeof(resp
));
1201 resp
.rkey
= mw
->rkey
;
1202 resp
.mw_handle
= uobj
->id
;
1204 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
1205 &resp
, sizeof(resp
))) {
1212 mutex_lock(&file
->mutex
);
1213 list_add_tail(&uobj
->list
, &file
->ucontext
->mw_list
);
1214 mutex_unlock(&file
->mutex
);
1218 up_write(&uobj
->mutex
);
1223 idr_remove_uobj(&ib_uverbs_mw_idr
, uobj
);
1232 put_uobj_write(uobj
);
1236 ssize_t
ib_uverbs_dealloc_mw(struct ib_uverbs_file
*file
,
1237 const char __user
*buf
, int in_len
,
1240 struct ib_uverbs_dealloc_mw cmd
;
1242 struct ib_uobject
*uobj
;
1245 if (copy_from_user(&cmd
, buf
, sizeof(cmd
)))
1248 uobj
= idr_write_uobj(&ib_uverbs_mw_idr
, cmd
.mw_handle
, file
->ucontext
);
1254 ret
= ib_dealloc_mw(mw
);
1258 put_uobj_write(uobj
);
1263 idr_remove_uobj(&ib_uverbs_mw_idr
, uobj
);
1265 mutex_lock(&file
->mutex
);
1266 list_del(&uobj
->list
);
1267 mutex_unlock(&file
->mutex
);
1274 ssize_t
ib_uverbs_create_comp_channel(struct ib_uverbs_file
*file
,
1275 const char __user
*buf
, int in_len
,
1278 struct ib_uverbs_create_comp_channel cmd
;
1279 struct ib_uverbs_create_comp_channel_resp resp
;
1283 if (out_len
< sizeof resp
)
1286 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1289 ret
= get_unused_fd_flags(O_CLOEXEC
);
1294 filp
= ib_uverbs_alloc_event_file(file
, 0);
1296 put_unused_fd(resp
.fd
);
1297 return PTR_ERR(filp
);
1300 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
1301 &resp
, sizeof resp
)) {
1302 put_unused_fd(resp
.fd
);
1307 fd_install(resp
.fd
, filp
);
1311 ssize_t
ib_uverbs_create_cq(struct ib_uverbs_file
*file
,
1312 const char __user
*buf
, int in_len
,
1315 struct ib_uverbs_create_cq cmd
;
1316 struct ib_uverbs_create_cq_resp resp
;
1317 struct ib_udata udata
;
1318 struct ib_ucq_object
*obj
;
1319 struct ib_uverbs_event_file
*ev_file
= NULL
;
1323 if (out_len
< sizeof resp
)
1326 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1329 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
1330 (unsigned long) cmd
.response
+ sizeof resp
,
1331 in_len
- sizeof cmd
, out_len
- sizeof resp
);
1333 if (cmd
.comp_vector
>= file
->device
->num_comp_vectors
)
1336 obj
= kmalloc(sizeof *obj
, GFP_KERNEL
);
1340 init_uobj(&obj
->uobject
, cmd
.user_handle
, file
->ucontext
, &cq_lock_class
);
1341 down_write(&obj
->uobject
.mutex
);
1343 if (cmd
.comp_channel
>= 0) {
1344 ev_file
= ib_uverbs_lookup_comp_file(cmd
.comp_channel
);
1351 obj
->uverbs_file
= file
;
1352 obj
->comp_events_reported
= 0;
1353 obj
->async_events_reported
= 0;
1354 INIT_LIST_HEAD(&obj
->comp_list
);
1355 INIT_LIST_HEAD(&obj
->async_list
);
1357 cq
= file
->device
->ib_dev
->create_cq(file
->device
->ib_dev
, cmd
.cqe
,
1359 file
->ucontext
, &udata
);
1365 cq
->device
= file
->device
->ib_dev
;
1366 cq
->uobject
= &obj
->uobject
;
1367 cq
->comp_handler
= ib_uverbs_comp_handler
;
1368 cq
->event_handler
= ib_uverbs_cq_event_handler
;
1369 cq
->cq_context
= ev_file
;
1370 atomic_set(&cq
->usecnt
, 0);
1372 obj
->uobject
.object
= cq
;
1373 ret
= idr_add_uobj(&ib_uverbs_cq_idr
, &obj
->uobject
);
1377 memset(&resp
, 0, sizeof resp
);
1378 resp
.cq_handle
= obj
->uobject
.id
;
1381 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
1382 &resp
, sizeof resp
)) {
1387 mutex_lock(&file
->mutex
);
1388 list_add_tail(&obj
->uobject
.list
, &file
->ucontext
->cq_list
);
1389 mutex_unlock(&file
->mutex
);
1391 obj
->uobject
.live
= 1;
1393 up_write(&obj
->uobject
.mutex
);
1398 idr_remove_uobj(&ib_uverbs_cq_idr
, &obj
->uobject
);
1405 ib_uverbs_release_ucq(file
, ev_file
, obj
);
1408 put_uobj_write(&obj
->uobject
);
1412 ssize_t
ib_uverbs_resize_cq(struct ib_uverbs_file
*file
,
1413 const char __user
*buf
, int in_len
,
1416 struct ib_uverbs_resize_cq cmd
;
1417 struct ib_uverbs_resize_cq_resp resp
;
1418 struct ib_udata udata
;
1422 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1425 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
1426 (unsigned long) cmd
.response
+ sizeof resp
,
1427 in_len
- sizeof cmd
, out_len
- sizeof resp
);
1429 cq
= idr_read_cq(cmd
.cq_handle
, file
->ucontext
, 0);
1433 ret
= cq
->device
->resize_cq(cq
, cmd
.cqe
, &udata
);
1439 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
1440 &resp
, sizeof resp
.cqe
))
1446 return ret
? ret
: in_len
;
1449 static int copy_wc_to_user(void __user
*dest
, struct ib_wc
*wc
)
1451 struct ib_uverbs_wc tmp
;
1453 tmp
.wr_id
= wc
->wr_id
;
1454 tmp
.status
= wc
->status
;
1455 tmp
.opcode
= wc
->opcode
;
1456 tmp
.vendor_err
= wc
->vendor_err
;
1457 tmp
.byte_len
= wc
->byte_len
;
1458 tmp
.ex
.imm_data
= (__u32 __force
) wc
->ex
.imm_data
;
1459 tmp
.qp_num
= wc
->qp
->qp_num
;
1460 tmp
.src_qp
= wc
->src_qp
;
1461 tmp
.wc_flags
= wc
->wc_flags
;
1462 tmp
.pkey_index
= wc
->pkey_index
;
1463 tmp
.slid
= wc
->slid
;
1465 tmp
.dlid_path_bits
= wc
->dlid_path_bits
;
1466 tmp
.port_num
= wc
->port_num
;
1469 if (copy_to_user(dest
, &tmp
, sizeof tmp
))
1475 ssize_t
ib_uverbs_poll_cq(struct ib_uverbs_file
*file
,
1476 const char __user
*buf
, int in_len
,
1479 struct ib_uverbs_poll_cq cmd
;
1480 struct ib_uverbs_poll_cq_resp resp
;
1481 u8 __user
*header_ptr
;
1482 u8 __user
*data_ptr
;
1487 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1490 cq
= idr_read_cq(cmd
.cq_handle
, file
->ucontext
, 0);
1494 /* we copy a struct ib_uverbs_poll_cq_resp to user space */
1495 header_ptr
= (void __user
*)(unsigned long) cmd
.response
;
1496 data_ptr
= header_ptr
+ sizeof resp
;
1498 memset(&resp
, 0, sizeof resp
);
1499 while (resp
.count
< cmd
.ne
) {
1500 ret
= ib_poll_cq(cq
, 1, &wc
);
1506 ret
= copy_wc_to_user(data_ptr
, &wc
);
1510 data_ptr
+= sizeof(struct ib_uverbs_wc
);
1514 if (copy_to_user(header_ptr
, &resp
, sizeof resp
)) {
1526 ssize_t
ib_uverbs_req_notify_cq(struct ib_uverbs_file
*file
,
1527 const char __user
*buf
, int in_len
,
1530 struct ib_uverbs_req_notify_cq cmd
;
1533 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1536 cq
= idr_read_cq(cmd
.cq_handle
, file
->ucontext
, 0);
1540 ib_req_notify_cq(cq
, cmd
.solicited_only
?
1541 IB_CQ_SOLICITED
: IB_CQ_NEXT_COMP
);
1548 ssize_t
ib_uverbs_destroy_cq(struct ib_uverbs_file
*file
,
1549 const char __user
*buf
, int in_len
,
1552 struct ib_uverbs_destroy_cq cmd
;
1553 struct ib_uverbs_destroy_cq_resp resp
;
1554 struct ib_uobject
*uobj
;
1556 struct ib_ucq_object
*obj
;
1557 struct ib_uverbs_event_file
*ev_file
;
1560 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1563 uobj
= idr_write_uobj(&ib_uverbs_cq_idr
, cmd
.cq_handle
, file
->ucontext
);
1567 ev_file
= cq
->cq_context
;
1568 obj
= container_of(cq
->uobject
, struct ib_ucq_object
, uobject
);
1570 ret
= ib_destroy_cq(cq
);
1574 put_uobj_write(uobj
);
1579 idr_remove_uobj(&ib_uverbs_cq_idr
, uobj
);
1581 mutex_lock(&file
->mutex
);
1582 list_del(&uobj
->list
);
1583 mutex_unlock(&file
->mutex
);
1585 ib_uverbs_release_ucq(file
, ev_file
, obj
);
1587 memset(&resp
, 0, sizeof resp
);
1588 resp
.comp_events_reported
= obj
->comp_events_reported
;
1589 resp
.async_events_reported
= obj
->async_events_reported
;
1593 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
1594 &resp
, sizeof resp
))
1600 ssize_t
ib_uverbs_create_qp(struct ib_uverbs_file
*file
,
1601 const char __user
*buf
, int in_len
,
1604 struct ib_uverbs_create_qp cmd
;
1605 struct ib_uverbs_create_qp_resp resp
;
1606 struct ib_udata udata
;
1607 struct ib_uqp_object
*obj
;
1608 struct ib_device
*device
;
1609 struct ib_pd
*pd
= NULL
;
1610 struct ib_xrcd
*xrcd
= NULL
;
1611 struct ib_uobject
*uninitialized_var(xrcd_uobj
);
1612 struct ib_cq
*scq
= NULL
, *rcq
= NULL
;
1613 struct ib_srq
*srq
= NULL
;
1615 struct ib_qp_init_attr attr
;
1618 if (out_len
< sizeof resp
)
1621 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1624 if (cmd
.qp_type
== IB_QPT_RAW_PACKET
&& !capable(CAP_NET_RAW
))
1627 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
1628 (unsigned long) cmd
.response
+ sizeof resp
,
1629 in_len
- sizeof cmd
, out_len
- sizeof resp
);
1631 obj
= kzalloc(sizeof *obj
, GFP_KERNEL
);
1635 init_uobj(&obj
->uevent
.uobject
, cmd
.user_handle
, file
->ucontext
, &qp_lock_class
);
1636 down_write(&obj
->uevent
.uobject
.mutex
);
1638 if (cmd
.qp_type
== IB_QPT_XRC_TGT
) {
1639 xrcd
= idr_read_xrcd(cmd
.pd_handle
, file
->ucontext
, &xrcd_uobj
);
1644 device
= xrcd
->device
;
1646 if (cmd
.qp_type
== IB_QPT_XRC_INI
) {
1647 cmd
.max_recv_wr
= cmd
.max_recv_sge
= 0;
1650 srq
= idr_read_srq(cmd
.srq_handle
, file
->ucontext
);
1651 if (!srq
|| srq
->srq_type
!= IB_SRQT_BASIC
) {
1657 if (cmd
.recv_cq_handle
!= cmd
.send_cq_handle
) {
1658 rcq
= idr_read_cq(cmd
.recv_cq_handle
, file
->ucontext
, 0);
1666 scq
= idr_read_cq(cmd
.send_cq_handle
, file
->ucontext
, !!rcq
);
1668 pd
= idr_read_pd(cmd
.pd_handle
, file
->ucontext
);
1674 device
= pd
->device
;
1677 attr
.event_handler
= ib_uverbs_qp_event_handler
;
1678 attr
.qp_context
= file
;
1683 attr
.sq_sig_type
= cmd
.sq_sig_all
? IB_SIGNAL_ALL_WR
: IB_SIGNAL_REQ_WR
;
1684 attr
.qp_type
= cmd
.qp_type
;
1685 attr
.create_flags
= 0;
1687 attr
.cap
.max_send_wr
= cmd
.max_send_wr
;
1688 attr
.cap
.max_recv_wr
= cmd
.max_recv_wr
;
1689 attr
.cap
.max_send_sge
= cmd
.max_send_sge
;
1690 attr
.cap
.max_recv_sge
= cmd
.max_recv_sge
;
1691 attr
.cap
.max_inline_data
= cmd
.max_inline_data
;
1693 obj
->uevent
.events_reported
= 0;
1694 INIT_LIST_HEAD(&obj
->uevent
.event_list
);
1695 INIT_LIST_HEAD(&obj
->mcast_list
);
1697 if (cmd
.qp_type
== IB_QPT_XRC_TGT
)
1698 qp
= ib_create_qp(pd
, &attr
);
1700 qp
= device
->create_qp(pd
, &attr
, &udata
);
1707 if (cmd
.qp_type
!= IB_QPT_XRC_TGT
) {
1709 qp
->device
= device
;
1711 qp
->send_cq
= attr
.send_cq
;
1712 qp
->recv_cq
= attr
.recv_cq
;
1714 qp
->event_handler
= attr
.event_handler
;
1715 qp
->qp_context
= attr
.qp_context
;
1716 qp
->qp_type
= attr
.qp_type
;
1717 atomic_set(&qp
->usecnt
, 0);
1718 atomic_inc(&pd
->usecnt
);
1719 atomic_inc(&attr
.send_cq
->usecnt
);
1721 atomic_inc(&attr
.recv_cq
->usecnt
);
1723 atomic_inc(&attr
.srq
->usecnt
);
1725 qp
->uobject
= &obj
->uevent
.uobject
;
1727 obj
->uevent
.uobject
.object
= qp
;
1728 ret
= idr_add_uobj(&ib_uverbs_qp_idr
, &obj
->uevent
.uobject
);
1732 memset(&resp
, 0, sizeof resp
);
1733 resp
.qpn
= qp
->qp_num
;
1734 resp
.qp_handle
= obj
->uevent
.uobject
.id
;
1735 resp
.max_recv_sge
= attr
.cap
.max_recv_sge
;
1736 resp
.max_send_sge
= attr
.cap
.max_send_sge
;
1737 resp
.max_recv_wr
= attr
.cap
.max_recv_wr
;
1738 resp
.max_send_wr
= attr
.cap
.max_send_wr
;
1739 resp
.max_inline_data
= attr
.cap
.max_inline_data
;
1741 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
1742 &resp
, sizeof resp
)) {
1748 obj
->uxrcd
= container_of(xrcd_uobj
, struct ib_uxrcd_object
,
1750 atomic_inc(&obj
->uxrcd
->refcnt
);
1751 put_xrcd_read(xrcd_uobj
);
1758 if (rcq
&& rcq
!= scq
)
1763 mutex_lock(&file
->mutex
);
1764 list_add_tail(&obj
->uevent
.uobject
.list
, &file
->ucontext
->qp_list
);
1765 mutex_unlock(&file
->mutex
);
1767 obj
->uevent
.uobject
.live
= 1;
1769 up_write(&obj
->uevent
.uobject
.mutex
);
1774 idr_remove_uobj(&ib_uverbs_qp_idr
, &obj
->uevent
.uobject
);
1781 put_xrcd_read(xrcd_uobj
);
1786 if (rcq
&& rcq
!= scq
)
1791 put_uobj_write(&obj
->uevent
.uobject
);
1795 ssize_t
ib_uverbs_open_qp(struct ib_uverbs_file
*file
,
1796 const char __user
*buf
, int in_len
, int out_len
)
1798 struct ib_uverbs_open_qp cmd
;
1799 struct ib_uverbs_create_qp_resp resp
;
1800 struct ib_udata udata
;
1801 struct ib_uqp_object
*obj
;
1802 struct ib_xrcd
*xrcd
;
1803 struct ib_uobject
*uninitialized_var(xrcd_uobj
);
1805 struct ib_qp_open_attr attr
;
1808 if (out_len
< sizeof resp
)
1811 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1814 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
1815 (unsigned long) cmd
.response
+ sizeof resp
,
1816 in_len
- sizeof cmd
, out_len
- sizeof resp
);
1818 obj
= kmalloc(sizeof *obj
, GFP_KERNEL
);
1822 init_uobj(&obj
->uevent
.uobject
, cmd
.user_handle
, file
->ucontext
, &qp_lock_class
);
1823 down_write(&obj
->uevent
.uobject
.mutex
);
1825 xrcd
= idr_read_xrcd(cmd
.pd_handle
, file
->ucontext
, &xrcd_uobj
);
1831 attr
.event_handler
= ib_uverbs_qp_event_handler
;
1832 attr
.qp_context
= file
;
1833 attr
.qp_num
= cmd
.qpn
;
1834 attr
.qp_type
= cmd
.qp_type
;
1836 obj
->uevent
.events_reported
= 0;
1837 INIT_LIST_HEAD(&obj
->uevent
.event_list
);
1838 INIT_LIST_HEAD(&obj
->mcast_list
);
1840 qp
= ib_open_qp(xrcd
, &attr
);
1846 qp
->uobject
= &obj
->uevent
.uobject
;
1848 obj
->uevent
.uobject
.object
= qp
;
1849 ret
= idr_add_uobj(&ib_uverbs_qp_idr
, &obj
->uevent
.uobject
);
1853 memset(&resp
, 0, sizeof resp
);
1854 resp
.qpn
= qp
->qp_num
;
1855 resp
.qp_handle
= obj
->uevent
.uobject
.id
;
1857 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
1858 &resp
, sizeof resp
)) {
1863 obj
->uxrcd
= container_of(xrcd_uobj
, struct ib_uxrcd_object
, uobject
);
1864 atomic_inc(&obj
->uxrcd
->refcnt
);
1865 put_xrcd_read(xrcd_uobj
);
1867 mutex_lock(&file
->mutex
);
1868 list_add_tail(&obj
->uevent
.uobject
.list
, &file
->ucontext
->qp_list
);
1869 mutex_unlock(&file
->mutex
);
1871 obj
->uevent
.uobject
.live
= 1;
1873 up_write(&obj
->uevent
.uobject
.mutex
);
1878 idr_remove_uobj(&ib_uverbs_qp_idr
, &obj
->uevent
.uobject
);
1884 put_xrcd_read(xrcd_uobj
);
1885 put_uobj_write(&obj
->uevent
.uobject
);
1889 ssize_t
ib_uverbs_query_qp(struct ib_uverbs_file
*file
,
1890 const char __user
*buf
, int in_len
,
1893 struct ib_uverbs_query_qp cmd
;
1894 struct ib_uverbs_query_qp_resp resp
;
1896 struct ib_qp_attr
*attr
;
1897 struct ib_qp_init_attr
*init_attr
;
1900 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
1903 attr
= kmalloc(sizeof *attr
, GFP_KERNEL
);
1904 init_attr
= kmalloc(sizeof *init_attr
, GFP_KERNEL
);
1905 if (!attr
|| !init_attr
) {
1910 qp
= idr_read_qp(cmd
.qp_handle
, file
->ucontext
);
1916 ret
= ib_query_qp(qp
, attr
, cmd
.attr_mask
, init_attr
);
1923 memset(&resp
, 0, sizeof resp
);
1925 resp
.qp_state
= attr
->qp_state
;
1926 resp
.cur_qp_state
= attr
->cur_qp_state
;
1927 resp
.path_mtu
= attr
->path_mtu
;
1928 resp
.path_mig_state
= attr
->path_mig_state
;
1929 resp
.qkey
= attr
->qkey
;
1930 resp
.rq_psn
= attr
->rq_psn
;
1931 resp
.sq_psn
= attr
->sq_psn
;
1932 resp
.dest_qp_num
= attr
->dest_qp_num
;
1933 resp
.qp_access_flags
= attr
->qp_access_flags
;
1934 resp
.pkey_index
= attr
->pkey_index
;
1935 resp
.alt_pkey_index
= attr
->alt_pkey_index
;
1936 resp
.sq_draining
= attr
->sq_draining
;
1937 resp
.max_rd_atomic
= attr
->max_rd_atomic
;
1938 resp
.max_dest_rd_atomic
= attr
->max_dest_rd_atomic
;
1939 resp
.min_rnr_timer
= attr
->min_rnr_timer
;
1940 resp
.port_num
= attr
->port_num
;
1941 resp
.timeout
= attr
->timeout
;
1942 resp
.retry_cnt
= attr
->retry_cnt
;
1943 resp
.rnr_retry
= attr
->rnr_retry
;
1944 resp
.alt_port_num
= attr
->alt_port_num
;
1945 resp
.alt_timeout
= attr
->alt_timeout
;
1947 memcpy(resp
.dest
.dgid
, attr
->ah_attr
.grh
.dgid
.raw
, 16);
1948 resp
.dest
.flow_label
= attr
->ah_attr
.grh
.flow_label
;
1949 resp
.dest
.sgid_index
= attr
->ah_attr
.grh
.sgid_index
;
1950 resp
.dest
.hop_limit
= attr
->ah_attr
.grh
.hop_limit
;
1951 resp
.dest
.traffic_class
= attr
->ah_attr
.grh
.traffic_class
;
1952 resp
.dest
.dlid
= attr
->ah_attr
.dlid
;
1953 resp
.dest
.sl
= attr
->ah_attr
.sl
;
1954 resp
.dest
.src_path_bits
= attr
->ah_attr
.src_path_bits
;
1955 resp
.dest
.static_rate
= attr
->ah_attr
.static_rate
;
1956 resp
.dest
.is_global
= !!(attr
->ah_attr
.ah_flags
& IB_AH_GRH
);
1957 resp
.dest
.port_num
= attr
->ah_attr
.port_num
;
1959 memcpy(resp
.alt_dest
.dgid
, attr
->alt_ah_attr
.grh
.dgid
.raw
, 16);
1960 resp
.alt_dest
.flow_label
= attr
->alt_ah_attr
.grh
.flow_label
;
1961 resp
.alt_dest
.sgid_index
= attr
->alt_ah_attr
.grh
.sgid_index
;
1962 resp
.alt_dest
.hop_limit
= attr
->alt_ah_attr
.grh
.hop_limit
;
1963 resp
.alt_dest
.traffic_class
= attr
->alt_ah_attr
.grh
.traffic_class
;
1964 resp
.alt_dest
.dlid
= attr
->alt_ah_attr
.dlid
;
1965 resp
.alt_dest
.sl
= attr
->alt_ah_attr
.sl
;
1966 resp
.alt_dest
.src_path_bits
= attr
->alt_ah_attr
.src_path_bits
;
1967 resp
.alt_dest
.static_rate
= attr
->alt_ah_attr
.static_rate
;
1968 resp
.alt_dest
.is_global
= !!(attr
->alt_ah_attr
.ah_flags
& IB_AH_GRH
);
1969 resp
.alt_dest
.port_num
= attr
->alt_ah_attr
.port_num
;
1971 resp
.max_send_wr
= init_attr
->cap
.max_send_wr
;
1972 resp
.max_recv_wr
= init_attr
->cap
.max_recv_wr
;
1973 resp
.max_send_sge
= init_attr
->cap
.max_send_sge
;
1974 resp
.max_recv_sge
= init_attr
->cap
.max_recv_sge
;
1975 resp
.max_inline_data
= init_attr
->cap
.max_inline_data
;
1976 resp
.sq_sig_all
= init_attr
->sq_sig_type
== IB_SIGNAL_ALL_WR
;
1978 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
1979 &resp
, sizeof resp
))
1986 return ret
? ret
: in_len
;
1989 /* Remove ignored fields set in the attribute mask */
1990 static int modify_qp_mask(enum ib_qp_type qp_type
, int mask
)
1993 case IB_QPT_XRC_INI
:
1994 return mask
& ~(IB_QP_MAX_DEST_RD_ATOMIC
| IB_QP_MIN_RNR_TIMER
);
1995 case IB_QPT_XRC_TGT
:
1996 return mask
& ~(IB_QP_MAX_QP_RD_ATOMIC
| IB_QP_RETRY_CNT
|
2003 ssize_t
ib_uverbs_modify_qp(struct ib_uverbs_file
*file
,
2004 const char __user
*buf
, int in_len
,
2007 struct ib_uverbs_modify_qp cmd
;
2008 struct ib_udata udata
;
2010 struct ib_qp_attr
*attr
;
2013 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2016 INIT_UDATA(&udata
, buf
+ sizeof cmd
, NULL
, in_len
- sizeof cmd
,
2019 attr
= kmalloc(sizeof *attr
, GFP_KERNEL
);
2023 qp
= idr_read_qp(cmd
.qp_handle
, file
->ucontext
);
2029 attr
->qp_state
= cmd
.qp_state
;
2030 attr
->cur_qp_state
= cmd
.cur_qp_state
;
2031 attr
->path_mtu
= cmd
.path_mtu
;
2032 attr
->path_mig_state
= cmd
.path_mig_state
;
2033 attr
->qkey
= cmd
.qkey
;
2034 attr
->rq_psn
= cmd
.rq_psn
;
2035 attr
->sq_psn
= cmd
.sq_psn
;
2036 attr
->dest_qp_num
= cmd
.dest_qp_num
;
2037 attr
->qp_access_flags
= cmd
.qp_access_flags
;
2038 attr
->pkey_index
= cmd
.pkey_index
;
2039 attr
->alt_pkey_index
= cmd
.alt_pkey_index
;
2040 attr
->en_sqd_async_notify
= cmd
.en_sqd_async_notify
;
2041 attr
->max_rd_atomic
= cmd
.max_rd_atomic
;
2042 attr
->max_dest_rd_atomic
= cmd
.max_dest_rd_atomic
;
2043 attr
->min_rnr_timer
= cmd
.min_rnr_timer
;
2044 attr
->port_num
= cmd
.port_num
;
2045 attr
->timeout
= cmd
.timeout
;
2046 attr
->retry_cnt
= cmd
.retry_cnt
;
2047 attr
->rnr_retry
= cmd
.rnr_retry
;
2048 attr
->alt_port_num
= cmd
.alt_port_num
;
2049 attr
->alt_timeout
= cmd
.alt_timeout
;
2051 memcpy(attr
->ah_attr
.grh
.dgid
.raw
, cmd
.dest
.dgid
, 16);
2052 attr
->ah_attr
.grh
.flow_label
= cmd
.dest
.flow_label
;
2053 attr
->ah_attr
.grh
.sgid_index
= cmd
.dest
.sgid_index
;
2054 attr
->ah_attr
.grh
.hop_limit
= cmd
.dest
.hop_limit
;
2055 attr
->ah_attr
.grh
.traffic_class
= cmd
.dest
.traffic_class
;
2056 attr
->ah_attr
.dlid
= cmd
.dest
.dlid
;
2057 attr
->ah_attr
.sl
= cmd
.dest
.sl
;
2058 attr
->ah_attr
.src_path_bits
= cmd
.dest
.src_path_bits
;
2059 attr
->ah_attr
.static_rate
= cmd
.dest
.static_rate
;
2060 attr
->ah_attr
.ah_flags
= cmd
.dest
.is_global
? IB_AH_GRH
: 0;
2061 attr
->ah_attr
.port_num
= cmd
.dest
.port_num
;
2063 memcpy(attr
->alt_ah_attr
.grh
.dgid
.raw
, cmd
.alt_dest
.dgid
, 16);
2064 attr
->alt_ah_attr
.grh
.flow_label
= cmd
.alt_dest
.flow_label
;
2065 attr
->alt_ah_attr
.grh
.sgid_index
= cmd
.alt_dest
.sgid_index
;
2066 attr
->alt_ah_attr
.grh
.hop_limit
= cmd
.alt_dest
.hop_limit
;
2067 attr
->alt_ah_attr
.grh
.traffic_class
= cmd
.alt_dest
.traffic_class
;
2068 attr
->alt_ah_attr
.dlid
= cmd
.alt_dest
.dlid
;
2069 attr
->alt_ah_attr
.sl
= cmd
.alt_dest
.sl
;
2070 attr
->alt_ah_attr
.src_path_bits
= cmd
.alt_dest
.src_path_bits
;
2071 attr
->alt_ah_attr
.static_rate
= cmd
.alt_dest
.static_rate
;
2072 attr
->alt_ah_attr
.ah_flags
= cmd
.alt_dest
.is_global
? IB_AH_GRH
: 0;
2073 attr
->alt_ah_attr
.port_num
= cmd
.alt_dest
.port_num
;
2075 if (qp
->real_qp
== qp
) {
2076 ret
= ib_resolve_eth_l2_attrs(qp
, attr
, &cmd
.attr_mask
);
2079 ret
= qp
->device
->modify_qp(qp
, attr
,
2080 modify_qp_mask(qp
->qp_type
, cmd
.attr_mask
), &udata
);
2082 ret
= ib_modify_qp(qp
, attr
, modify_qp_mask(qp
->qp_type
, cmd
.attr_mask
));
2098 ssize_t
ib_uverbs_destroy_qp(struct ib_uverbs_file
*file
,
2099 const char __user
*buf
, int in_len
,
2102 struct ib_uverbs_destroy_qp cmd
;
2103 struct ib_uverbs_destroy_qp_resp resp
;
2104 struct ib_uobject
*uobj
;
2106 struct ib_uqp_object
*obj
;
2109 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2112 memset(&resp
, 0, sizeof resp
);
2114 uobj
= idr_write_uobj(&ib_uverbs_qp_idr
, cmd
.qp_handle
, file
->ucontext
);
2118 obj
= container_of(uobj
, struct ib_uqp_object
, uevent
.uobject
);
2120 if (!list_empty(&obj
->mcast_list
)) {
2121 put_uobj_write(uobj
);
2125 ret
= ib_destroy_qp(qp
);
2129 put_uobj_write(uobj
);
2135 atomic_dec(&obj
->uxrcd
->refcnt
);
2137 idr_remove_uobj(&ib_uverbs_qp_idr
, uobj
);
2139 mutex_lock(&file
->mutex
);
2140 list_del(&uobj
->list
);
2141 mutex_unlock(&file
->mutex
);
2143 ib_uverbs_release_uevent(file
, &obj
->uevent
);
2145 resp
.events_reported
= obj
->uevent
.events_reported
;
2149 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
2150 &resp
, sizeof resp
))
2156 ssize_t
ib_uverbs_post_send(struct ib_uverbs_file
*file
,
2157 const char __user
*buf
, int in_len
,
2160 struct ib_uverbs_post_send cmd
;
2161 struct ib_uverbs_post_send_resp resp
;
2162 struct ib_uverbs_send_wr
*user_wr
;
2163 struct ib_send_wr
*wr
= NULL
, *last
, *next
, *bad_wr
;
2167 ssize_t ret
= -EINVAL
;
2169 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2172 if (in_len
< sizeof cmd
+ cmd
.wqe_size
* cmd
.wr_count
+
2173 cmd
.sge_count
* sizeof (struct ib_uverbs_sge
))
2176 if (cmd
.wqe_size
< sizeof (struct ib_uverbs_send_wr
))
2179 user_wr
= kmalloc(cmd
.wqe_size
, GFP_KERNEL
);
2183 qp
= idr_read_qp(cmd
.qp_handle
, file
->ucontext
);
2187 is_ud
= qp
->qp_type
== IB_QPT_UD
;
2190 for (i
= 0; i
< cmd
.wr_count
; ++i
) {
2191 if (copy_from_user(user_wr
,
2192 buf
+ sizeof cmd
+ i
* cmd
.wqe_size
,
2198 if (user_wr
->num_sge
+ sg_ind
> cmd
.sge_count
) {
2203 next
= kmalloc(ALIGN(sizeof *next
, sizeof (struct ib_sge
)) +
2204 user_wr
->num_sge
* sizeof (struct ib_sge
),
2218 next
->wr_id
= user_wr
->wr_id
;
2219 next
->num_sge
= user_wr
->num_sge
;
2220 next
->opcode
= user_wr
->opcode
;
2221 next
->send_flags
= user_wr
->send_flags
;
2224 next
->wr
.ud
.ah
= idr_read_ah(user_wr
->wr
.ud
.ah
,
2226 if (!next
->wr
.ud
.ah
) {
2230 next
->wr
.ud
.remote_qpn
= user_wr
->wr
.ud
.remote_qpn
;
2231 next
->wr
.ud
.remote_qkey
= user_wr
->wr
.ud
.remote_qkey
;
2232 if (next
->opcode
== IB_WR_SEND_WITH_IMM
)
2234 (__be32 __force
) user_wr
->ex
.imm_data
;
2236 switch (next
->opcode
) {
2237 case IB_WR_RDMA_WRITE_WITH_IMM
:
2239 (__be32 __force
) user_wr
->ex
.imm_data
;
2240 case IB_WR_RDMA_WRITE
:
2241 case IB_WR_RDMA_READ
:
2242 next
->wr
.rdma
.remote_addr
=
2243 user_wr
->wr
.rdma
.remote_addr
;
2244 next
->wr
.rdma
.rkey
=
2245 user_wr
->wr
.rdma
.rkey
;
2247 case IB_WR_SEND_WITH_IMM
:
2249 (__be32 __force
) user_wr
->ex
.imm_data
;
2251 case IB_WR_SEND_WITH_INV
:
2252 next
->ex
.invalidate_rkey
=
2253 user_wr
->ex
.invalidate_rkey
;
2255 case IB_WR_ATOMIC_CMP_AND_SWP
:
2256 case IB_WR_ATOMIC_FETCH_AND_ADD
:
2257 next
->wr
.atomic
.remote_addr
=
2258 user_wr
->wr
.atomic
.remote_addr
;
2259 next
->wr
.atomic
.compare_add
=
2260 user_wr
->wr
.atomic
.compare_add
;
2261 next
->wr
.atomic
.swap
= user_wr
->wr
.atomic
.swap
;
2262 next
->wr
.atomic
.rkey
= user_wr
->wr
.atomic
.rkey
;
2269 if (next
->num_sge
) {
2270 next
->sg_list
= (void *) next
+
2271 ALIGN(sizeof *next
, sizeof (struct ib_sge
));
2272 if (copy_from_user(next
->sg_list
,
2274 cmd
.wr_count
* cmd
.wqe_size
+
2275 sg_ind
* sizeof (struct ib_sge
),
2276 next
->num_sge
* sizeof (struct ib_sge
))) {
2280 sg_ind
+= next
->num_sge
;
2282 next
->sg_list
= NULL
;
2286 ret
= qp
->device
->post_send(qp
->real_qp
, wr
, &bad_wr
);
2288 for (next
= wr
; next
; next
= next
->next
) {
2294 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
2295 &resp
, sizeof resp
))
2302 if (is_ud
&& wr
->wr
.ud
.ah
)
2303 put_ah_read(wr
->wr
.ud
.ah
);
2312 return ret
? ret
: in_len
;
2315 static struct ib_recv_wr
*ib_uverbs_unmarshall_recv(const char __user
*buf
,
2321 struct ib_uverbs_recv_wr
*user_wr
;
2322 struct ib_recv_wr
*wr
= NULL
, *last
, *next
;
2327 if (in_len
< wqe_size
* wr_count
+
2328 sge_count
* sizeof (struct ib_uverbs_sge
))
2329 return ERR_PTR(-EINVAL
);
2331 if (wqe_size
< sizeof (struct ib_uverbs_recv_wr
))
2332 return ERR_PTR(-EINVAL
);
2334 user_wr
= kmalloc(wqe_size
, GFP_KERNEL
);
2336 return ERR_PTR(-ENOMEM
);
2340 for (i
= 0; i
< wr_count
; ++i
) {
2341 if (copy_from_user(user_wr
, buf
+ i
* wqe_size
,
2347 if (user_wr
->num_sge
+ sg_ind
> sge_count
) {
2352 next
= kmalloc(ALIGN(sizeof *next
, sizeof (struct ib_sge
)) +
2353 user_wr
->num_sge
* sizeof (struct ib_sge
),
2367 next
->wr_id
= user_wr
->wr_id
;
2368 next
->num_sge
= user_wr
->num_sge
;
2370 if (next
->num_sge
) {
2371 next
->sg_list
= (void *) next
+
2372 ALIGN(sizeof *next
, sizeof (struct ib_sge
));
2373 if (copy_from_user(next
->sg_list
,
2374 buf
+ wr_count
* wqe_size
+
2375 sg_ind
* sizeof (struct ib_sge
),
2376 next
->num_sge
* sizeof (struct ib_sge
))) {
2380 sg_ind
+= next
->num_sge
;
2382 next
->sg_list
= NULL
;
2397 return ERR_PTR(ret
);
2400 ssize_t
ib_uverbs_post_recv(struct ib_uverbs_file
*file
,
2401 const char __user
*buf
, int in_len
,
2404 struct ib_uverbs_post_recv cmd
;
2405 struct ib_uverbs_post_recv_resp resp
;
2406 struct ib_recv_wr
*wr
, *next
, *bad_wr
;
2408 ssize_t ret
= -EINVAL
;
2410 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2413 wr
= ib_uverbs_unmarshall_recv(buf
+ sizeof cmd
,
2414 in_len
- sizeof cmd
, cmd
.wr_count
,
2415 cmd
.sge_count
, cmd
.wqe_size
);
2419 qp
= idr_read_qp(cmd
.qp_handle
, file
->ucontext
);
2424 ret
= qp
->device
->post_recv(qp
->real_qp
, wr
, &bad_wr
);
2429 for (next
= wr
; next
; next
= next
->next
) {
2435 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
2436 &resp
, sizeof resp
))
2446 return ret
? ret
: in_len
;
2449 ssize_t
ib_uverbs_post_srq_recv(struct ib_uverbs_file
*file
,
2450 const char __user
*buf
, int in_len
,
2453 struct ib_uverbs_post_srq_recv cmd
;
2454 struct ib_uverbs_post_srq_recv_resp resp
;
2455 struct ib_recv_wr
*wr
, *next
, *bad_wr
;
2457 ssize_t ret
= -EINVAL
;
2459 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2462 wr
= ib_uverbs_unmarshall_recv(buf
+ sizeof cmd
,
2463 in_len
- sizeof cmd
, cmd
.wr_count
,
2464 cmd
.sge_count
, cmd
.wqe_size
);
2468 srq
= idr_read_srq(cmd
.srq_handle
, file
->ucontext
);
2473 ret
= srq
->device
->post_srq_recv(srq
, wr
, &bad_wr
);
2478 for (next
= wr
; next
; next
= next
->next
) {
2484 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
2485 &resp
, sizeof resp
))
2495 return ret
? ret
: in_len
;
2498 ssize_t
ib_uverbs_create_ah(struct ib_uverbs_file
*file
,
2499 const char __user
*buf
, int in_len
,
2502 struct ib_uverbs_create_ah cmd
;
2503 struct ib_uverbs_create_ah_resp resp
;
2504 struct ib_uobject
*uobj
;
2507 struct ib_ah_attr attr
;
2510 if (out_len
< sizeof resp
)
2513 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2516 uobj
= kmalloc(sizeof *uobj
, GFP_KERNEL
);
2520 init_uobj(uobj
, cmd
.user_handle
, file
->ucontext
, &ah_lock_class
);
2521 down_write(&uobj
->mutex
);
2523 pd
= idr_read_pd(cmd
.pd_handle
, file
->ucontext
);
2529 attr
.dlid
= cmd
.attr
.dlid
;
2530 attr
.sl
= cmd
.attr
.sl
;
2531 attr
.src_path_bits
= cmd
.attr
.src_path_bits
;
2532 attr
.static_rate
= cmd
.attr
.static_rate
;
2533 attr
.ah_flags
= cmd
.attr
.is_global
? IB_AH_GRH
: 0;
2534 attr
.port_num
= cmd
.attr
.port_num
;
2535 attr
.grh
.flow_label
= cmd
.attr
.grh
.flow_label
;
2536 attr
.grh
.sgid_index
= cmd
.attr
.grh
.sgid_index
;
2537 attr
.grh
.hop_limit
= cmd
.attr
.grh
.hop_limit
;
2538 attr
.grh
.traffic_class
= cmd
.attr
.grh
.traffic_class
;
2540 memset(&attr
.dmac
, 0, sizeof(attr
.dmac
));
2541 memcpy(attr
.grh
.dgid
.raw
, cmd
.attr
.grh
.dgid
, 16);
2543 ah
= ib_create_ah(pd
, &attr
);
2552 ret
= idr_add_uobj(&ib_uverbs_ah_idr
, uobj
);
2556 resp
.ah_handle
= uobj
->id
;
2558 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
2559 &resp
, sizeof resp
)) {
2566 mutex_lock(&file
->mutex
);
2567 list_add_tail(&uobj
->list
, &file
->ucontext
->ah_list
);
2568 mutex_unlock(&file
->mutex
);
2572 up_write(&uobj
->mutex
);
2577 idr_remove_uobj(&ib_uverbs_ah_idr
, uobj
);
2586 put_uobj_write(uobj
);
2590 ssize_t
ib_uverbs_destroy_ah(struct ib_uverbs_file
*file
,
2591 const char __user
*buf
, int in_len
, int out_len
)
2593 struct ib_uverbs_destroy_ah cmd
;
2595 struct ib_uobject
*uobj
;
2598 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2601 uobj
= idr_write_uobj(&ib_uverbs_ah_idr
, cmd
.ah_handle
, file
->ucontext
);
2606 ret
= ib_destroy_ah(ah
);
2610 put_uobj_write(uobj
);
2615 idr_remove_uobj(&ib_uverbs_ah_idr
, uobj
);
2617 mutex_lock(&file
->mutex
);
2618 list_del(&uobj
->list
);
2619 mutex_unlock(&file
->mutex
);
2626 ssize_t
ib_uverbs_attach_mcast(struct ib_uverbs_file
*file
,
2627 const char __user
*buf
, int in_len
,
2630 struct ib_uverbs_attach_mcast cmd
;
2632 struct ib_uqp_object
*obj
;
2633 struct ib_uverbs_mcast_entry
*mcast
;
2636 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2639 qp
= idr_write_qp(cmd
.qp_handle
, file
->ucontext
);
2643 obj
= container_of(qp
->uobject
, struct ib_uqp_object
, uevent
.uobject
);
2645 list_for_each_entry(mcast
, &obj
->mcast_list
, list
)
2646 if (cmd
.mlid
== mcast
->lid
&&
2647 !memcmp(cmd
.gid
, mcast
->gid
.raw
, sizeof mcast
->gid
.raw
)) {
2652 mcast
= kmalloc(sizeof *mcast
, GFP_KERNEL
);
2658 mcast
->lid
= cmd
.mlid
;
2659 memcpy(mcast
->gid
.raw
, cmd
.gid
, sizeof mcast
->gid
.raw
);
2661 ret
= ib_attach_mcast(qp
, &mcast
->gid
, cmd
.mlid
);
2663 list_add_tail(&mcast
->list
, &obj
->mcast_list
);
2670 return ret
? ret
: in_len
;
2673 ssize_t
ib_uverbs_detach_mcast(struct ib_uverbs_file
*file
,
2674 const char __user
*buf
, int in_len
,
2677 struct ib_uverbs_detach_mcast cmd
;
2678 struct ib_uqp_object
*obj
;
2680 struct ib_uverbs_mcast_entry
*mcast
;
2683 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
2686 qp
= idr_write_qp(cmd
.qp_handle
, file
->ucontext
);
2690 ret
= ib_detach_mcast(qp
, (union ib_gid
*) cmd
.gid
, cmd
.mlid
);
2694 obj
= container_of(qp
->uobject
, struct ib_uqp_object
, uevent
.uobject
);
2696 list_for_each_entry(mcast
, &obj
->mcast_list
, list
)
2697 if (cmd
.mlid
== mcast
->lid
&&
2698 !memcmp(cmd
.gid
, mcast
->gid
.raw
, sizeof mcast
->gid
.raw
)) {
2699 list_del(&mcast
->list
);
2707 return ret
? ret
: in_len
;
2710 static int kern_spec_to_ib_spec(struct ib_uverbs_flow_spec
*kern_spec
,
2711 union ib_flow_spec
*ib_spec
)
2713 if (kern_spec
->reserved
)
2716 ib_spec
->type
= kern_spec
->type
;
2718 switch (ib_spec
->type
) {
2719 case IB_FLOW_SPEC_ETH
:
2720 ib_spec
->eth
.size
= sizeof(struct ib_flow_spec_eth
);
2721 if (ib_spec
->eth
.size
!= kern_spec
->eth
.size
)
2723 memcpy(&ib_spec
->eth
.val
, &kern_spec
->eth
.val
,
2724 sizeof(struct ib_flow_eth_filter
));
2725 memcpy(&ib_spec
->eth
.mask
, &kern_spec
->eth
.mask
,
2726 sizeof(struct ib_flow_eth_filter
));
2728 case IB_FLOW_SPEC_IPV4
:
2729 ib_spec
->ipv4
.size
= sizeof(struct ib_flow_spec_ipv4
);
2730 if (ib_spec
->ipv4
.size
!= kern_spec
->ipv4
.size
)
2732 memcpy(&ib_spec
->ipv4
.val
, &kern_spec
->ipv4
.val
,
2733 sizeof(struct ib_flow_ipv4_filter
));
2734 memcpy(&ib_spec
->ipv4
.mask
, &kern_spec
->ipv4
.mask
,
2735 sizeof(struct ib_flow_ipv4_filter
));
2737 case IB_FLOW_SPEC_TCP
:
2738 case IB_FLOW_SPEC_UDP
:
2739 ib_spec
->tcp_udp
.size
= sizeof(struct ib_flow_spec_tcp_udp
);
2740 if (ib_spec
->tcp_udp
.size
!= kern_spec
->tcp_udp
.size
)
2742 memcpy(&ib_spec
->tcp_udp
.val
, &kern_spec
->tcp_udp
.val
,
2743 sizeof(struct ib_flow_tcp_udp_filter
));
2744 memcpy(&ib_spec
->tcp_udp
.mask
, &kern_spec
->tcp_udp
.mask
,
2745 sizeof(struct ib_flow_tcp_udp_filter
));
2753 int ib_uverbs_ex_create_flow(struct ib_uverbs_file
*file
,
2754 struct ib_udata
*ucore
,
2755 struct ib_udata
*uhw
)
2757 struct ib_uverbs_create_flow cmd
;
2758 struct ib_uverbs_create_flow_resp resp
;
2759 struct ib_uobject
*uobj
;
2760 struct ib_flow
*flow_id
;
2761 struct ib_uverbs_flow_attr
*kern_flow_attr
;
2762 struct ib_flow_attr
*flow_attr
;
2769 if (ucore
->inlen
< sizeof(cmd
))
2772 if (ucore
->outlen
< sizeof(resp
))
2775 err
= ib_copy_from_udata(&cmd
, ucore
, sizeof(cmd
));
2779 ucore
->inbuf
+= sizeof(cmd
);
2780 ucore
->inlen
-= sizeof(cmd
);
2785 if ((cmd
.flow_attr
.type
== IB_FLOW_ATTR_SNIFFER
&&
2786 !capable(CAP_NET_ADMIN
)) || !capable(CAP_NET_RAW
))
2789 if (cmd
.flow_attr
.num_of_specs
> IB_FLOW_SPEC_SUPPORT_LAYERS
)
2792 if (cmd
.flow_attr
.size
> ucore
->inlen
||
2793 cmd
.flow_attr
.size
>
2794 (cmd
.flow_attr
.num_of_specs
* sizeof(struct ib_uverbs_flow_spec
)))
2797 if (cmd
.flow_attr
.reserved
[0] ||
2798 cmd
.flow_attr
.reserved
[1])
2801 if (cmd
.flow_attr
.num_of_specs
) {
2802 kern_flow_attr
= kmalloc(sizeof(*kern_flow_attr
) + cmd
.flow_attr
.size
,
2804 if (!kern_flow_attr
)
2807 memcpy(kern_flow_attr
, &cmd
.flow_attr
, sizeof(*kern_flow_attr
));
2808 err
= ib_copy_from_udata(kern_flow_attr
+ 1, ucore
,
2809 cmd
.flow_attr
.size
);
2813 kern_flow_attr
= &cmd
.flow_attr
;
2816 uobj
= kmalloc(sizeof(*uobj
), GFP_KERNEL
);
2821 init_uobj(uobj
, 0, file
->ucontext
, &rule_lock_class
);
2822 down_write(&uobj
->mutex
);
2824 qp
= idr_read_qp(cmd
.qp_handle
, file
->ucontext
);
2830 flow_attr
= kmalloc(sizeof(*flow_attr
) + cmd
.flow_attr
.size
, GFP_KERNEL
);
2836 flow_attr
->type
= kern_flow_attr
->type
;
2837 flow_attr
->priority
= kern_flow_attr
->priority
;
2838 flow_attr
->num_of_specs
= kern_flow_attr
->num_of_specs
;
2839 flow_attr
->port
= kern_flow_attr
->port
;
2840 flow_attr
->flags
= kern_flow_attr
->flags
;
2841 flow_attr
->size
= sizeof(*flow_attr
);
2843 kern_spec
= kern_flow_attr
+ 1;
2844 ib_spec
= flow_attr
+ 1;
2845 for (i
= 0; i
< flow_attr
->num_of_specs
&&
2846 cmd
.flow_attr
.size
> offsetof(struct ib_uverbs_flow_spec
, reserved
) &&
2847 cmd
.flow_attr
.size
>=
2848 ((struct ib_uverbs_flow_spec
*)kern_spec
)->size
; i
++) {
2849 err
= kern_spec_to_ib_spec(kern_spec
, ib_spec
);
2853 ((union ib_flow_spec
*) ib_spec
)->size
;
2854 cmd
.flow_attr
.size
-= ((struct ib_uverbs_flow_spec
*)kern_spec
)->size
;
2855 kern_spec
+= ((struct ib_uverbs_flow_spec
*) kern_spec
)->size
;
2856 ib_spec
+= ((union ib_flow_spec
*) ib_spec
)->size
;
2858 if (cmd
.flow_attr
.size
|| (i
!= flow_attr
->num_of_specs
)) {
2859 pr_warn("create flow failed, flow %d: %d bytes left from uverb cmd\n",
2860 i
, cmd
.flow_attr
.size
);
2864 flow_id
= ib_create_flow(qp
, flow_attr
, IB_FLOW_DOMAIN_USER
);
2865 if (IS_ERR(flow_id
)) {
2866 err
= PTR_ERR(flow_id
);
2870 flow_id
->uobject
= uobj
;
2871 uobj
->object
= flow_id
;
2873 err
= idr_add_uobj(&ib_uverbs_rule_idr
, uobj
);
2877 memset(&resp
, 0, sizeof(resp
));
2878 resp
.flow_handle
= uobj
->id
;
2880 err
= ib_copy_to_udata(ucore
,
2881 &resp
, sizeof(resp
));
2886 mutex_lock(&file
->mutex
);
2887 list_add_tail(&uobj
->list
, &file
->ucontext
->rule_list
);
2888 mutex_unlock(&file
->mutex
);
2892 up_write(&uobj
->mutex
);
2894 if (cmd
.flow_attr
.num_of_specs
)
2895 kfree(kern_flow_attr
);
2898 idr_remove_uobj(&ib_uverbs_rule_idr
, uobj
);
2900 ib_destroy_flow(flow_id
);
2906 put_uobj_write(uobj
);
2908 if (cmd
.flow_attr
.num_of_specs
)
2909 kfree(kern_flow_attr
);
2913 int ib_uverbs_ex_destroy_flow(struct ib_uverbs_file
*file
,
2914 struct ib_udata
*ucore
,
2915 struct ib_udata
*uhw
)
2917 struct ib_uverbs_destroy_flow cmd
;
2918 struct ib_flow
*flow_id
;
2919 struct ib_uobject
*uobj
;
2922 if (ucore
->inlen
< sizeof(cmd
))
2925 ret
= ib_copy_from_udata(&cmd
, ucore
, sizeof(cmd
));
2932 uobj
= idr_write_uobj(&ib_uverbs_rule_idr
, cmd
.flow_handle
,
2936 flow_id
= uobj
->object
;
2938 ret
= ib_destroy_flow(flow_id
);
2942 put_uobj_write(uobj
);
2944 idr_remove_uobj(&ib_uverbs_rule_idr
, uobj
);
2946 mutex_lock(&file
->mutex
);
2947 list_del(&uobj
->list
);
2948 mutex_unlock(&file
->mutex
);
2955 static int __uverbs_create_xsrq(struct ib_uverbs_file
*file
,
2956 struct ib_uverbs_create_xsrq
*cmd
,
2957 struct ib_udata
*udata
)
2959 struct ib_uverbs_create_srq_resp resp
;
2960 struct ib_usrq_object
*obj
;
2963 struct ib_uobject
*uninitialized_var(xrcd_uobj
);
2964 struct ib_srq_init_attr attr
;
2967 obj
= kmalloc(sizeof *obj
, GFP_KERNEL
);
2971 init_uobj(&obj
->uevent
.uobject
, cmd
->user_handle
, file
->ucontext
, &srq_lock_class
);
2972 down_write(&obj
->uevent
.uobject
.mutex
);
2974 if (cmd
->srq_type
== IB_SRQT_XRC
) {
2975 attr
.ext
.xrc
.xrcd
= idr_read_xrcd(cmd
->xrcd_handle
, file
->ucontext
, &xrcd_uobj
);
2976 if (!attr
.ext
.xrc
.xrcd
) {
2981 obj
->uxrcd
= container_of(xrcd_uobj
, struct ib_uxrcd_object
, uobject
);
2982 atomic_inc(&obj
->uxrcd
->refcnt
);
2984 attr
.ext
.xrc
.cq
= idr_read_cq(cmd
->cq_handle
, file
->ucontext
, 0);
2985 if (!attr
.ext
.xrc
.cq
) {
2991 pd
= idr_read_pd(cmd
->pd_handle
, file
->ucontext
);
2997 attr
.event_handler
= ib_uverbs_srq_event_handler
;
2998 attr
.srq_context
= file
;
2999 attr
.srq_type
= cmd
->srq_type
;
3000 attr
.attr
.max_wr
= cmd
->max_wr
;
3001 attr
.attr
.max_sge
= cmd
->max_sge
;
3002 attr
.attr
.srq_limit
= cmd
->srq_limit
;
3004 obj
->uevent
.events_reported
= 0;
3005 INIT_LIST_HEAD(&obj
->uevent
.event_list
);
3007 srq
= pd
->device
->create_srq(pd
, &attr
, udata
);
3013 srq
->device
= pd
->device
;
3015 srq
->srq_type
= cmd
->srq_type
;
3016 srq
->uobject
= &obj
->uevent
.uobject
;
3017 srq
->event_handler
= attr
.event_handler
;
3018 srq
->srq_context
= attr
.srq_context
;
3020 if (cmd
->srq_type
== IB_SRQT_XRC
) {
3021 srq
->ext
.xrc
.cq
= attr
.ext
.xrc
.cq
;
3022 srq
->ext
.xrc
.xrcd
= attr
.ext
.xrc
.xrcd
;
3023 atomic_inc(&attr
.ext
.xrc
.cq
->usecnt
);
3024 atomic_inc(&attr
.ext
.xrc
.xrcd
->usecnt
);
3027 atomic_inc(&pd
->usecnt
);
3028 atomic_set(&srq
->usecnt
, 0);
3030 obj
->uevent
.uobject
.object
= srq
;
3031 ret
= idr_add_uobj(&ib_uverbs_srq_idr
, &obj
->uevent
.uobject
);
3035 memset(&resp
, 0, sizeof resp
);
3036 resp
.srq_handle
= obj
->uevent
.uobject
.id
;
3037 resp
.max_wr
= attr
.attr
.max_wr
;
3038 resp
.max_sge
= attr
.attr
.max_sge
;
3039 if (cmd
->srq_type
== IB_SRQT_XRC
)
3040 resp
.srqn
= srq
->ext
.xrc
.srq_num
;
3042 if (copy_to_user((void __user
*) (unsigned long) cmd
->response
,
3043 &resp
, sizeof resp
)) {
3048 if (cmd
->srq_type
== IB_SRQT_XRC
) {
3049 put_uobj_read(xrcd_uobj
);
3050 put_cq_read(attr
.ext
.xrc
.cq
);
3054 mutex_lock(&file
->mutex
);
3055 list_add_tail(&obj
->uevent
.uobject
.list
, &file
->ucontext
->srq_list
);
3056 mutex_unlock(&file
->mutex
);
3058 obj
->uevent
.uobject
.live
= 1;
3060 up_write(&obj
->uevent
.uobject
.mutex
);
3065 idr_remove_uobj(&ib_uverbs_srq_idr
, &obj
->uevent
.uobject
);
3068 ib_destroy_srq(srq
);
3074 if (cmd
->srq_type
== IB_SRQT_XRC
)
3075 put_cq_read(attr
.ext
.xrc
.cq
);
3078 if (cmd
->srq_type
== IB_SRQT_XRC
) {
3079 atomic_dec(&obj
->uxrcd
->refcnt
);
3080 put_uobj_read(xrcd_uobj
);
3084 put_uobj_write(&obj
->uevent
.uobject
);
3088 ssize_t
ib_uverbs_create_srq(struct ib_uverbs_file
*file
,
3089 const char __user
*buf
, int in_len
,
3092 struct ib_uverbs_create_srq cmd
;
3093 struct ib_uverbs_create_xsrq xcmd
;
3094 struct ib_uverbs_create_srq_resp resp
;
3095 struct ib_udata udata
;
3098 if (out_len
< sizeof resp
)
3101 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
3104 xcmd
.response
= cmd
.response
;
3105 xcmd
.user_handle
= cmd
.user_handle
;
3106 xcmd
.srq_type
= IB_SRQT_BASIC
;
3107 xcmd
.pd_handle
= cmd
.pd_handle
;
3108 xcmd
.max_wr
= cmd
.max_wr
;
3109 xcmd
.max_sge
= cmd
.max_sge
;
3110 xcmd
.srq_limit
= cmd
.srq_limit
;
3112 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
3113 (unsigned long) cmd
.response
+ sizeof resp
,
3114 in_len
- sizeof cmd
, out_len
- sizeof resp
);
3116 ret
= __uverbs_create_xsrq(file
, &xcmd
, &udata
);
3123 ssize_t
ib_uverbs_create_xsrq(struct ib_uverbs_file
*file
,
3124 const char __user
*buf
, int in_len
, int out_len
)
3126 struct ib_uverbs_create_xsrq cmd
;
3127 struct ib_uverbs_create_srq_resp resp
;
3128 struct ib_udata udata
;
3131 if (out_len
< sizeof resp
)
3134 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
3137 INIT_UDATA(&udata
, buf
+ sizeof cmd
,
3138 (unsigned long) cmd
.response
+ sizeof resp
,
3139 in_len
- sizeof cmd
, out_len
- sizeof resp
);
3141 ret
= __uverbs_create_xsrq(file
, &cmd
, &udata
);
3148 ssize_t
ib_uverbs_modify_srq(struct ib_uverbs_file
*file
,
3149 const char __user
*buf
, int in_len
,
3152 struct ib_uverbs_modify_srq cmd
;
3153 struct ib_udata udata
;
3155 struct ib_srq_attr attr
;
3158 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
3161 INIT_UDATA(&udata
, buf
+ sizeof cmd
, NULL
, in_len
- sizeof cmd
,
3164 srq
= idr_read_srq(cmd
.srq_handle
, file
->ucontext
);
3168 attr
.max_wr
= cmd
.max_wr
;
3169 attr
.srq_limit
= cmd
.srq_limit
;
3171 ret
= srq
->device
->modify_srq(srq
, &attr
, cmd
.attr_mask
, &udata
);
3175 return ret
? ret
: in_len
;
3178 ssize_t
ib_uverbs_query_srq(struct ib_uverbs_file
*file
,
3179 const char __user
*buf
,
3180 int in_len
, int out_len
)
3182 struct ib_uverbs_query_srq cmd
;
3183 struct ib_uverbs_query_srq_resp resp
;
3184 struct ib_srq_attr attr
;
3188 if (out_len
< sizeof resp
)
3191 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
3194 srq
= idr_read_srq(cmd
.srq_handle
, file
->ucontext
);
3198 ret
= ib_query_srq(srq
, &attr
);
3205 memset(&resp
, 0, sizeof resp
);
3207 resp
.max_wr
= attr
.max_wr
;
3208 resp
.max_sge
= attr
.max_sge
;
3209 resp
.srq_limit
= attr
.srq_limit
;
3211 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
3212 &resp
, sizeof resp
))
3218 ssize_t
ib_uverbs_destroy_srq(struct ib_uverbs_file
*file
,
3219 const char __user
*buf
, int in_len
,
3222 struct ib_uverbs_destroy_srq cmd
;
3223 struct ib_uverbs_destroy_srq_resp resp
;
3224 struct ib_uobject
*uobj
;
3226 struct ib_uevent_object
*obj
;
3228 struct ib_usrq_object
*us
;
3229 enum ib_srq_type srq_type
;
3231 if (copy_from_user(&cmd
, buf
, sizeof cmd
))
3234 uobj
= idr_write_uobj(&ib_uverbs_srq_idr
, cmd
.srq_handle
, file
->ucontext
);
3238 obj
= container_of(uobj
, struct ib_uevent_object
, uobject
);
3239 srq_type
= srq
->srq_type
;
3241 ret
= ib_destroy_srq(srq
);
3245 put_uobj_write(uobj
);
3250 if (srq_type
== IB_SRQT_XRC
) {
3251 us
= container_of(obj
, struct ib_usrq_object
, uevent
);
3252 atomic_dec(&us
->uxrcd
->refcnt
);
3255 idr_remove_uobj(&ib_uverbs_srq_idr
, uobj
);
3257 mutex_lock(&file
->mutex
);
3258 list_del(&uobj
->list
);
3259 mutex_unlock(&file
->mutex
);
3261 ib_uverbs_release_uevent(file
, obj
);
3263 memset(&resp
, 0, sizeof resp
);
3264 resp
.events_reported
= obj
->events_reported
;
3268 if (copy_to_user((void __user
*) (unsigned long) cmd
.response
,
3269 &resp
, sizeof resp
))
3272 return ret
? ret
: in_len
;
3275 int ib_uverbs_ex_query_device(struct ib_uverbs_file
*file
,
3276 struct ib_udata
*ucore
,
3277 struct ib_udata
*uhw
)
3279 struct ib_uverbs_ex_query_device_resp resp
;
3280 struct ib_uverbs_ex_query_device cmd
;
3281 struct ib_device_attr attr
;
3282 struct ib_device
*device
;
3285 device
= file
->device
->ib_dev
;
3286 if (ucore
->inlen
< sizeof(cmd
))
3289 err
= ib_copy_from_udata(&cmd
, ucore
, sizeof(cmd
));
3296 err
= device
->query_device(device
, &attr
);
3300 memset(&resp
, 0, sizeof(resp
));
3301 copy_query_dev_fields(file
, &resp
.base
, &attr
);
3304 #ifdef CONFIG_INFINIBAND_ON_DEMAND_PAGING
3305 if (cmd
.comp_mask
& IB_USER_VERBS_EX_QUERY_DEVICE_ODP
) {
3306 resp
.odp_caps
.general_caps
= attr
.odp_caps
.general_caps
;
3307 resp
.odp_caps
.per_transport_caps
.rc_odp_caps
=
3308 attr
.odp_caps
.per_transport_caps
.rc_odp_caps
;
3309 resp
.odp_caps
.per_transport_caps
.uc_odp_caps
=
3310 attr
.odp_caps
.per_transport_caps
.uc_odp_caps
;
3311 resp
.odp_caps
.per_transport_caps
.ud_odp_caps
=
3312 attr
.odp_caps
.per_transport_caps
.ud_odp_caps
;
3313 resp
.comp_mask
|= IB_USER_VERBS_EX_QUERY_DEVICE_ODP
;
3317 err
= ib_copy_to_udata(ucore
, &resp
, sizeof(resp
));