2 * Copyright (c) 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Intel Corporation. All rights reserved.
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 * $Id: ucm.c 4311 2005-12-05 18:42:01Z sean.hefty $
36 #include <linux/completion.h>
37 #include <linux/init.h>
39 #include <linux/module.h>
40 #include <linux/device.h>
41 #include <linux/err.h>
42 #include <linux/poll.h>
43 #include <linux/file.h>
44 #include <linux/mount.h>
45 #include <linux/cdev.h>
46 #include <linux/idr.h>
47 #include <linux/mutex.h>
49 #include <asm/uaccess.h>
51 #include <rdma/ib_cm.h>
52 #include <rdma/ib_user_cm.h>
53 #include <rdma/ib_marshall.h>
55 MODULE_AUTHOR("Libor Michalek");
56 MODULE_DESCRIPTION("InfiniBand userspace Connection Manager access");
57 MODULE_LICENSE("Dual BSD/GPL");
59 struct ib_ucm_device
{
62 struct class_device class_dev
;
63 struct ib_device
*ib_dev
;
67 struct mutex file_mutex
;
69 struct ib_ucm_device
*device
;
71 struct list_head ctxs
;
72 struct list_head events
;
73 wait_queue_head_t poll_wait
;
76 struct ib_ucm_context
{
78 struct completion comp
;
82 struct ib_ucm_file
*file
;
83 struct ib_cm_id
*cm_id
;
86 struct list_head events
; /* list of pending events. */
87 struct list_head file_list
; /* member in file ctx list */
91 struct ib_ucm_context
*ctx
;
92 struct list_head file_list
; /* member in file event list */
93 struct list_head ctx_list
; /* member in ctx event list */
95 struct ib_cm_id
*cm_id
;
96 struct ib_ucm_event_resp resp
;
105 IB_UCM_BASE_MINOR
= 224,
106 IB_UCM_MAX_DEVICES
= 32
109 #define IB_UCM_BASE_DEV MKDEV(IB_UCM_MAJOR, IB_UCM_BASE_MINOR)
111 static void ib_ucm_add_one(struct ib_device
*device
);
112 static void ib_ucm_remove_one(struct ib_device
*device
);
114 static struct ib_client ucm_client
= {
116 .add
= ib_ucm_add_one
,
117 .remove
= ib_ucm_remove_one
120 static DEFINE_MUTEX(ctx_id_mutex
);
121 static DEFINE_IDR(ctx_id_table
);
122 static DECLARE_BITMAP(dev_map
, IB_UCM_MAX_DEVICES
);
124 static struct ib_ucm_context
*ib_ucm_ctx_get(struct ib_ucm_file
*file
, int id
)
126 struct ib_ucm_context
*ctx
;
128 mutex_lock(&ctx_id_mutex
);
129 ctx
= idr_find(&ctx_id_table
, id
);
131 ctx
= ERR_PTR(-ENOENT
);
132 else if (ctx
->file
!= file
)
133 ctx
= ERR_PTR(-EINVAL
);
135 atomic_inc(&ctx
->ref
);
136 mutex_unlock(&ctx_id_mutex
);
141 static void ib_ucm_ctx_put(struct ib_ucm_context
*ctx
)
143 if (atomic_dec_and_test(&ctx
->ref
))
144 complete(&ctx
->comp
);
147 static inline int ib_ucm_new_cm_id(int event
)
149 return event
== IB_CM_REQ_RECEIVED
|| event
== IB_CM_SIDR_REQ_RECEIVED
;
152 static void ib_ucm_cleanup_events(struct ib_ucm_context
*ctx
)
154 struct ib_ucm_event
*uevent
;
156 mutex_lock(&ctx
->file
->file_mutex
);
157 list_del(&ctx
->file_list
);
158 while (!list_empty(&ctx
->events
)) {
160 uevent
= list_entry(ctx
->events
.next
,
161 struct ib_ucm_event
, ctx_list
);
162 list_del(&uevent
->file_list
);
163 list_del(&uevent
->ctx_list
);
165 /* clear incoming connections. */
166 if (ib_ucm_new_cm_id(uevent
->resp
.event
))
167 ib_destroy_cm_id(uevent
->cm_id
);
171 mutex_unlock(&ctx
->file
->file_mutex
);
174 static struct ib_ucm_context
*ib_ucm_ctx_alloc(struct ib_ucm_file
*file
)
176 struct ib_ucm_context
*ctx
;
179 ctx
= kzalloc(sizeof *ctx
, GFP_KERNEL
);
183 atomic_set(&ctx
->ref
, 1);
184 init_completion(&ctx
->comp
);
186 INIT_LIST_HEAD(&ctx
->events
);
189 result
= idr_pre_get(&ctx_id_table
, GFP_KERNEL
);
193 mutex_lock(&ctx_id_mutex
);
194 result
= idr_get_new(&ctx_id_table
, ctx
, &ctx
->id
);
195 mutex_unlock(&ctx_id_mutex
);
196 } while (result
== -EAGAIN
);
201 list_add_tail(&ctx
->file_list
, &file
->ctxs
);
209 static void ib_ucm_event_req_get(struct ib_ucm_req_event_resp
*ureq
,
210 struct ib_cm_req_event_param
*kreq
)
212 ureq
->remote_ca_guid
= kreq
->remote_ca_guid
;
213 ureq
->remote_qkey
= kreq
->remote_qkey
;
214 ureq
->remote_qpn
= kreq
->remote_qpn
;
215 ureq
->qp_type
= kreq
->qp_type
;
216 ureq
->starting_psn
= kreq
->starting_psn
;
217 ureq
->responder_resources
= kreq
->responder_resources
;
218 ureq
->initiator_depth
= kreq
->initiator_depth
;
219 ureq
->local_cm_response_timeout
= kreq
->local_cm_response_timeout
;
220 ureq
->flow_control
= kreq
->flow_control
;
221 ureq
->remote_cm_response_timeout
= kreq
->remote_cm_response_timeout
;
222 ureq
->retry_count
= kreq
->retry_count
;
223 ureq
->rnr_retry_count
= kreq
->rnr_retry_count
;
224 ureq
->srq
= kreq
->srq
;
225 ureq
->port
= kreq
->port
;
227 ib_copy_path_rec_to_user(&ureq
->primary_path
, kreq
->primary_path
);
228 if (kreq
->alternate_path
)
229 ib_copy_path_rec_to_user(&ureq
->alternate_path
,
230 kreq
->alternate_path
);
233 static void ib_ucm_event_rep_get(struct ib_ucm_rep_event_resp
*urep
,
234 struct ib_cm_rep_event_param
*krep
)
236 urep
->remote_ca_guid
= krep
->remote_ca_guid
;
237 urep
->remote_qkey
= krep
->remote_qkey
;
238 urep
->remote_qpn
= krep
->remote_qpn
;
239 urep
->starting_psn
= krep
->starting_psn
;
240 urep
->responder_resources
= krep
->responder_resources
;
241 urep
->initiator_depth
= krep
->initiator_depth
;
242 urep
->target_ack_delay
= krep
->target_ack_delay
;
243 urep
->failover_accepted
= krep
->failover_accepted
;
244 urep
->flow_control
= krep
->flow_control
;
245 urep
->rnr_retry_count
= krep
->rnr_retry_count
;
246 urep
->srq
= krep
->srq
;
249 static void ib_ucm_event_sidr_rep_get(struct ib_ucm_sidr_rep_event_resp
*urep
,
250 struct ib_cm_sidr_rep_event_param
*krep
)
252 urep
->status
= krep
->status
;
253 urep
->qkey
= krep
->qkey
;
254 urep
->qpn
= krep
->qpn
;
257 static int ib_ucm_event_process(struct ib_cm_event
*evt
,
258 struct ib_ucm_event
*uvt
)
262 switch (evt
->event
) {
263 case IB_CM_REQ_RECEIVED
:
264 ib_ucm_event_req_get(&uvt
->resp
.u
.req_resp
,
265 &evt
->param
.req_rcvd
);
266 uvt
->data_len
= IB_CM_REQ_PRIVATE_DATA_SIZE
;
267 uvt
->resp
.present
= IB_UCM_PRES_PRIMARY
;
268 uvt
->resp
.present
|= (evt
->param
.req_rcvd
.alternate_path
?
269 IB_UCM_PRES_ALTERNATE
: 0);
271 case IB_CM_REP_RECEIVED
:
272 ib_ucm_event_rep_get(&uvt
->resp
.u
.rep_resp
,
273 &evt
->param
.rep_rcvd
);
274 uvt
->data_len
= IB_CM_REP_PRIVATE_DATA_SIZE
;
276 case IB_CM_RTU_RECEIVED
:
277 uvt
->data_len
= IB_CM_RTU_PRIVATE_DATA_SIZE
;
278 uvt
->resp
.u
.send_status
= evt
->param
.send_status
;
280 case IB_CM_DREQ_RECEIVED
:
281 uvt
->data_len
= IB_CM_DREQ_PRIVATE_DATA_SIZE
;
282 uvt
->resp
.u
.send_status
= evt
->param
.send_status
;
284 case IB_CM_DREP_RECEIVED
:
285 uvt
->data_len
= IB_CM_DREP_PRIVATE_DATA_SIZE
;
286 uvt
->resp
.u
.send_status
= evt
->param
.send_status
;
288 case IB_CM_MRA_RECEIVED
:
289 uvt
->resp
.u
.mra_resp
.timeout
=
290 evt
->param
.mra_rcvd
.service_timeout
;
291 uvt
->data_len
= IB_CM_MRA_PRIVATE_DATA_SIZE
;
293 case IB_CM_REJ_RECEIVED
:
294 uvt
->resp
.u
.rej_resp
.reason
= evt
->param
.rej_rcvd
.reason
;
295 uvt
->data_len
= IB_CM_REJ_PRIVATE_DATA_SIZE
;
296 uvt
->info_len
= evt
->param
.rej_rcvd
.ari_length
;
297 info
= evt
->param
.rej_rcvd
.ari
;
299 case IB_CM_LAP_RECEIVED
:
300 ib_copy_path_rec_to_user(&uvt
->resp
.u
.lap_resp
.path
,
301 evt
->param
.lap_rcvd
.alternate_path
);
302 uvt
->data_len
= IB_CM_LAP_PRIVATE_DATA_SIZE
;
303 uvt
->resp
.present
= IB_UCM_PRES_ALTERNATE
;
305 case IB_CM_APR_RECEIVED
:
306 uvt
->resp
.u
.apr_resp
.status
= evt
->param
.apr_rcvd
.ap_status
;
307 uvt
->data_len
= IB_CM_APR_PRIVATE_DATA_SIZE
;
308 uvt
->info_len
= evt
->param
.apr_rcvd
.info_len
;
309 info
= evt
->param
.apr_rcvd
.apr_info
;
311 case IB_CM_SIDR_REQ_RECEIVED
:
312 uvt
->resp
.u
.sidr_req_resp
.pkey
=
313 evt
->param
.sidr_req_rcvd
.pkey
;
314 uvt
->resp
.u
.sidr_req_resp
.port
=
315 evt
->param
.sidr_req_rcvd
.port
;
316 uvt
->data_len
= IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE
;
318 case IB_CM_SIDR_REP_RECEIVED
:
319 ib_ucm_event_sidr_rep_get(&uvt
->resp
.u
.sidr_rep_resp
,
320 &evt
->param
.sidr_rep_rcvd
);
321 uvt
->data_len
= IB_CM_SIDR_REP_PRIVATE_DATA_SIZE
;
322 uvt
->info_len
= evt
->param
.sidr_rep_rcvd
.info_len
;
323 info
= evt
->param
.sidr_rep_rcvd
.info
;
326 uvt
->resp
.u
.send_status
= evt
->param
.send_status
;
331 uvt
->data
= kmemdup(evt
->private_data
, uvt
->data_len
, GFP_KERNEL
);
335 uvt
->resp
.present
|= IB_UCM_PRES_DATA
;
339 uvt
->info
= kmemdup(info
, uvt
->info_len
, GFP_KERNEL
);
343 uvt
->resp
.present
|= IB_UCM_PRES_INFO
;
353 static int ib_ucm_event_handler(struct ib_cm_id
*cm_id
,
354 struct ib_cm_event
*event
)
356 struct ib_ucm_event
*uevent
;
357 struct ib_ucm_context
*ctx
;
360 ctx
= cm_id
->context
;
362 uevent
= kzalloc(sizeof *uevent
, GFP_KERNEL
);
367 uevent
->cm_id
= cm_id
;
368 uevent
->resp
.uid
= ctx
->uid
;
369 uevent
->resp
.id
= ctx
->id
;
370 uevent
->resp
.event
= event
->event
;
372 result
= ib_ucm_event_process(event
, uevent
);
376 mutex_lock(&ctx
->file
->file_mutex
);
377 list_add_tail(&uevent
->file_list
, &ctx
->file
->events
);
378 list_add_tail(&uevent
->ctx_list
, &ctx
->events
);
379 wake_up_interruptible(&ctx
->file
->poll_wait
);
380 mutex_unlock(&ctx
->file
->file_mutex
);
386 /* Destroy new cm_id's */
387 return ib_ucm_new_cm_id(event
->event
);
390 static ssize_t
ib_ucm_event(struct ib_ucm_file
*file
,
391 const char __user
*inbuf
,
392 int in_len
, int out_len
)
394 struct ib_ucm_context
*ctx
;
395 struct ib_ucm_event_get cmd
;
396 struct ib_ucm_event
*uevent
;
400 if (out_len
< sizeof(struct ib_ucm_event_resp
))
403 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
406 mutex_lock(&file
->file_mutex
);
407 while (list_empty(&file
->events
)) {
409 if (file
->filp
->f_flags
& O_NONBLOCK
) {
414 if (signal_pending(current
)) {
415 result
= -ERESTARTSYS
;
419 prepare_to_wait(&file
->poll_wait
, &wait
, TASK_INTERRUPTIBLE
);
421 mutex_unlock(&file
->file_mutex
);
423 mutex_lock(&file
->file_mutex
);
425 finish_wait(&file
->poll_wait
, &wait
);
431 uevent
= list_entry(file
->events
.next
, struct ib_ucm_event
, file_list
);
433 if (ib_ucm_new_cm_id(uevent
->resp
.event
)) {
434 ctx
= ib_ucm_ctx_alloc(file
);
440 ctx
->cm_id
= uevent
->cm_id
;
441 ctx
->cm_id
->context
= ctx
;
442 uevent
->resp
.id
= ctx
->id
;
445 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
446 &uevent
->resp
, sizeof(uevent
->resp
))) {
452 if (cmd
.data_len
< uevent
->data_len
) {
456 if (copy_to_user((void __user
*)(unsigned long)cmd
.data
,
457 uevent
->data
, uevent
->data_len
)) {
464 if (cmd
.info_len
< uevent
->info_len
) {
468 if (copy_to_user((void __user
*)(unsigned long)cmd
.info
,
469 uevent
->info
, uevent
->info_len
)) {
475 list_del(&uevent
->file_list
);
476 list_del(&uevent
->ctx_list
);
477 uevent
->ctx
->events_reported
++;
483 mutex_unlock(&file
->file_mutex
);
487 static ssize_t
ib_ucm_create_id(struct ib_ucm_file
*file
,
488 const char __user
*inbuf
,
489 int in_len
, int out_len
)
491 struct ib_ucm_create_id cmd
;
492 struct ib_ucm_create_id_resp resp
;
493 struct ib_ucm_context
*ctx
;
496 if (out_len
< sizeof(resp
))
499 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
502 mutex_lock(&file
->file_mutex
);
503 ctx
= ib_ucm_ctx_alloc(file
);
504 mutex_unlock(&file
->file_mutex
);
509 ctx
->cm_id
= ib_create_cm_id(file
->device
->ib_dev
,
510 ib_ucm_event_handler
, ctx
);
511 if (IS_ERR(ctx
->cm_id
)) {
512 result
= PTR_ERR(ctx
->cm_id
);
517 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
518 &resp
, sizeof(resp
))) {
525 ib_destroy_cm_id(ctx
->cm_id
);
527 mutex_lock(&ctx_id_mutex
);
528 idr_remove(&ctx_id_table
, ctx
->id
);
529 mutex_unlock(&ctx_id_mutex
);
534 static ssize_t
ib_ucm_destroy_id(struct ib_ucm_file
*file
,
535 const char __user
*inbuf
,
536 int in_len
, int out_len
)
538 struct ib_ucm_destroy_id cmd
;
539 struct ib_ucm_destroy_id_resp resp
;
540 struct ib_ucm_context
*ctx
;
543 if (out_len
< sizeof(resp
))
546 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
549 mutex_lock(&ctx_id_mutex
);
550 ctx
= idr_find(&ctx_id_table
, cmd
.id
);
552 ctx
= ERR_PTR(-ENOENT
);
553 else if (ctx
->file
!= file
)
554 ctx
= ERR_PTR(-EINVAL
);
556 idr_remove(&ctx_id_table
, ctx
->id
);
557 mutex_unlock(&ctx_id_mutex
);
563 wait_for_completion(&ctx
->comp
);
565 /* No new events will be generated after destroying the cm_id. */
566 ib_destroy_cm_id(ctx
->cm_id
);
567 /* Cleanup events not yet reported to the user. */
568 ib_ucm_cleanup_events(ctx
);
570 resp
.events_reported
= ctx
->events_reported
;
571 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
572 &resp
, sizeof(resp
)))
579 static ssize_t
ib_ucm_attr_id(struct ib_ucm_file
*file
,
580 const char __user
*inbuf
,
581 int in_len
, int out_len
)
583 struct ib_ucm_attr_id_resp resp
;
584 struct ib_ucm_attr_id cmd
;
585 struct ib_ucm_context
*ctx
;
588 if (out_len
< sizeof(resp
))
591 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
594 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
598 resp
.service_id
= ctx
->cm_id
->service_id
;
599 resp
.service_mask
= ctx
->cm_id
->service_mask
;
600 resp
.local_id
= ctx
->cm_id
->local_id
;
601 resp
.remote_id
= ctx
->cm_id
->remote_id
;
603 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
604 &resp
, sizeof(resp
)))
611 static ssize_t
ib_ucm_init_qp_attr(struct ib_ucm_file
*file
,
612 const char __user
*inbuf
,
613 int in_len
, int out_len
)
615 struct ib_uverbs_qp_attr resp
;
616 struct ib_ucm_init_qp_attr cmd
;
617 struct ib_ucm_context
*ctx
;
618 struct ib_qp_attr qp_attr
;
621 if (out_len
< sizeof(resp
))
624 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
627 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
631 resp
.qp_attr_mask
= 0;
632 memset(&qp_attr
, 0, sizeof qp_attr
);
633 qp_attr
.qp_state
= cmd
.qp_state
;
634 result
= ib_cm_init_qp_attr(ctx
->cm_id
, &qp_attr
, &resp
.qp_attr_mask
);
638 ib_copy_qp_attr_to_user(&resp
, &qp_attr
);
640 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
641 &resp
, sizeof(resp
)))
649 static int ucm_validate_listen(__be64 service_id
, __be64 service_mask
)
651 service_id
&= service_mask
;
653 if (((service_id
& IB_CMA_SERVICE_ID_MASK
) == IB_CMA_SERVICE_ID
) ||
654 ((service_id
& IB_SDP_SERVICE_ID_MASK
) == IB_SDP_SERVICE_ID
))
660 static ssize_t
ib_ucm_listen(struct ib_ucm_file
*file
,
661 const char __user
*inbuf
,
662 int in_len
, int out_len
)
664 struct ib_ucm_listen cmd
;
665 struct ib_ucm_context
*ctx
;
668 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
671 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
675 result
= ucm_validate_listen(cmd
.service_id
, cmd
.service_mask
);
679 result
= ib_cm_listen(ctx
->cm_id
, cmd
.service_id
, cmd
.service_mask
,
686 static ssize_t
ib_ucm_establish(struct ib_ucm_file
*file
,
687 const char __user
*inbuf
,
688 int in_len
, int out_len
)
690 struct ib_ucm_establish cmd
;
691 struct ib_ucm_context
*ctx
;
694 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
697 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
701 result
= ib_cm_establish(ctx
->cm_id
);
706 static int ib_ucm_alloc_data(const void **dest
, u64 src
, u32 len
)
715 data
= kmalloc(len
, GFP_KERNEL
);
719 if (copy_from_user(data
, (void __user
*)(unsigned long)src
, len
)) {
728 static int ib_ucm_path_get(struct ib_sa_path_rec
**path
, u64 src
)
730 struct ib_user_path_rec upath
;
731 struct ib_sa_path_rec
*sa_path
;
738 sa_path
= kmalloc(sizeof(*sa_path
), GFP_KERNEL
);
742 if (copy_from_user(&upath
, (void __user
*)(unsigned long)src
,
749 ib_copy_path_rec_from_user(sa_path
, &upath
);
754 static ssize_t
ib_ucm_send_req(struct ib_ucm_file
*file
,
755 const char __user
*inbuf
,
756 int in_len
, int out_len
)
758 struct ib_cm_req_param param
;
759 struct ib_ucm_context
*ctx
;
760 struct ib_ucm_req cmd
;
763 param
.private_data
= NULL
;
764 param
.primary_path
= NULL
;
765 param
.alternate_path
= NULL
;
767 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
770 result
= ib_ucm_alloc_data(¶m
.private_data
, cmd
.data
, cmd
.len
);
774 result
= ib_ucm_path_get(¶m
.primary_path
, cmd
.primary_path
);
778 result
= ib_ucm_path_get(¶m
.alternate_path
, cmd
.alternate_path
);
782 param
.private_data_len
= cmd
.len
;
783 param
.service_id
= cmd
.sid
;
784 param
.qp_num
= cmd
.qpn
;
785 param
.qp_type
= cmd
.qp_type
;
786 param
.starting_psn
= cmd
.psn
;
787 param
.peer_to_peer
= cmd
.peer_to_peer
;
788 param
.responder_resources
= cmd
.responder_resources
;
789 param
.initiator_depth
= cmd
.initiator_depth
;
790 param
.remote_cm_response_timeout
= cmd
.remote_cm_response_timeout
;
791 param
.flow_control
= cmd
.flow_control
;
792 param
.local_cm_response_timeout
= cmd
.local_cm_response_timeout
;
793 param
.retry_count
= cmd
.retry_count
;
794 param
.rnr_retry_count
= cmd
.rnr_retry_count
;
795 param
.max_cm_retries
= cmd
.max_cm_retries
;
798 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
800 result
= ib_send_cm_req(ctx
->cm_id
, ¶m
);
803 result
= PTR_ERR(ctx
);
806 kfree(param
.private_data
);
807 kfree(param
.primary_path
);
808 kfree(param
.alternate_path
);
812 static ssize_t
ib_ucm_send_rep(struct ib_ucm_file
*file
,
813 const char __user
*inbuf
,
814 int in_len
, int out_len
)
816 struct ib_cm_rep_param param
;
817 struct ib_ucm_context
*ctx
;
818 struct ib_ucm_rep cmd
;
821 param
.private_data
= NULL
;
823 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
826 result
= ib_ucm_alloc_data(¶m
.private_data
, cmd
.data
, cmd
.len
);
830 param
.qp_num
= cmd
.qpn
;
831 param
.starting_psn
= cmd
.psn
;
832 param
.private_data_len
= cmd
.len
;
833 param
.responder_resources
= cmd
.responder_resources
;
834 param
.initiator_depth
= cmd
.initiator_depth
;
835 param
.target_ack_delay
= cmd
.target_ack_delay
;
836 param
.failover_accepted
= cmd
.failover_accepted
;
837 param
.flow_control
= cmd
.flow_control
;
838 param
.rnr_retry_count
= cmd
.rnr_retry_count
;
841 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
844 result
= ib_send_cm_rep(ctx
->cm_id
, ¶m
);
847 result
= PTR_ERR(ctx
);
849 kfree(param
.private_data
);
853 static ssize_t
ib_ucm_send_private_data(struct ib_ucm_file
*file
,
854 const char __user
*inbuf
, int in_len
,
855 int (*func
)(struct ib_cm_id
*cm_id
,
856 const void *private_data
,
857 u8 private_data_len
))
859 struct ib_ucm_private_data cmd
;
860 struct ib_ucm_context
*ctx
;
861 const void *private_data
= NULL
;
864 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
867 result
= ib_ucm_alloc_data(&private_data
, cmd
.data
, cmd
.len
);
871 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
873 result
= func(ctx
->cm_id
, private_data
, cmd
.len
);
876 result
= PTR_ERR(ctx
);
882 static ssize_t
ib_ucm_send_rtu(struct ib_ucm_file
*file
,
883 const char __user
*inbuf
,
884 int in_len
, int out_len
)
886 return ib_ucm_send_private_data(file
, inbuf
, in_len
, ib_send_cm_rtu
);
889 static ssize_t
ib_ucm_send_dreq(struct ib_ucm_file
*file
,
890 const char __user
*inbuf
,
891 int in_len
, int out_len
)
893 return ib_ucm_send_private_data(file
, inbuf
, in_len
, ib_send_cm_dreq
);
896 static ssize_t
ib_ucm_send_drep(struct ib_ucm_file
*file
,
897 const char __user
*inbuf
,
898 int in_len
, int out_len
)
900 return ib_ucm_send_private_data(file
, inbuf
, in_len
, ib_send_cm_drep
);
903 static ssize_t
ib_ucm_send_info(struct ib_ucm_file
*file
,
904 const char __user
*inbuf
, int in_len
,
905 int (*func
)(struct ib_cm_id
*cm_id
,
912 struct ib_ucm_context
*ctx
;
913 struct ib_ucm_info cmd
;
914 const void *data
= NULL
;
915 const void *info
= NULL
;
918 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
921 result
= ib_ucm_alloc_data(&data
, cmd
.data
, cmd
.data_len
);
925 result
= ib_ucm_alloc_data(&info
, cmd
.info
, cmd
.info_len
);
929 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
931 result
= func(ctx
->cm_id
, cmd
.status
, info
, cmd
.info_len
,
935 result
= PTR_ERR(ctx
);
943 static ssize_t
ib_ucm_send_rej(struct ib_ucm_file
*file
,
944 const char __user
*inbuf
,
945 int in_len
, int out_len
)
947 return ib_ucm_send_info(file
, inbuf
, in_len
, (void *)ib_send_cm_rej
);
950 static ssize_t
ib_ucm_send_apr(struct ib_ucm_file
*file
,
951 const char __user
*inbuf
,
952 int in_len
, int out_len
)
954 return ib_ucm_send_info(file
, inbuf
, in_len
, (void *)ib_send_cm_apr
);
957 static ssize_t
ib_ucm_send_mra(struct ib_ucm_file
*file
,
958 const char __user
*inbuf
,
959 int in_len
, int out_len
)
961 struct ib_ucm_context
*ctx
;
962 struct ib_ucm_mra cmd
;
963 const void *data
= NULL
;
966 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
969 result
= ib_ucm_alloc_data(&data
, cmd
.data
, cmd
.len
);
973 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
975 result
= ib_send_cm_mra(ctx
->cm_id
, cmd
.timeout
, data
, cmd
.len
);
978 result
= PTR_ERR(ctx
);
984 static ssize_t
ib_ucm_send_lap(struct ib_ucm_file
*file
,
985 const char __user
*inbuf
,
986 int in_len
, int out_len
)
988 struct ib_ucm_context
*ctx
;
989 struct ib_sa_path_rec
*path
= NULL
;
990 struct ib_ucm_lap cmd
;
991 const void *data
= NULL
;
994 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
997 result
= ib_ucm_alloc_data(&data
, cmd
.data
, cmd
.len
);
1001 result
= ib_ucm_path_get(&path
, cmd
.path
);
1005 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
1007 result
= ib_send_cm_lap(ctx
->cm_id
, path
, data
, cmd
.len
);
1008 ib_ucm_ctx_put(ctx
);
1010 result
= PTR_ERR(ctx
);
1018 static ssize_t
ib_ucm_send_sidr_req(struct ib_ucm_file
*file
,
1019 const char __user
*inbuf
,
1020 int in_len
, int out_len
)
1022 struct ib_cm_sidr_req_param param
;
1023 struct ib_ucm_context
*ctx
;
1024 struct ib_ucm_sidr_req cmd
;
1027 param
.private_data
= NULL
;
1030 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
1033 result
= ib_ucm_alloc_data(¶m
.private_data
, cmd
.data
, cmd
.len
);
1037 result
= ib_ucm_path_get(¶m
.path
, cmd
.path
);
1041 param
.private_data_len
= cmd
.len
;
1042 param
.service_id
= cmd
.sid
;
1043 param
.timeout_ms
= cmd
.timeout
;
1044 param
.max_cm_retries
= cmd
.max_cm_retries
;
1046 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
1048 result
= ib_send_cm_sidr_req(ctx
->cm_id
, ¶m
);
1049 ib_ucm_ctx_put(ctx
);
1051 result
= PTR_ERR(ctx
);
1054 kfree(param
.private_data
);
1059 static ssize_t
ib_ucm_send_sidr_rep(struct ib_ucm_file
*file
,
1060 const char __user
*inbuf
,
1061 int in_len
, int out_len
)
1063 struct ib_cm_sidr_rep_param param
;
1064 struct ib_ucm_sidr_rep cmd
;
1065 struct ib_ucm_context
*ctx
;
1070 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
1073 result
= ib_ucm_alloc_data(¶m
.private_data
,
1074 cmd
.data
, cmd
.data_len
);
1078 result
= ib_ucm_alloc_data(¶m
.info
, cmd
.info
, cmd
.info_len
);
1082 param
.qp_num
= cmd
.qpn
;
1083 param
.qkey
= cmd
.qkey
;
1084 param
.status
= cmd
.status
;
1085 param
.info_length
= cmd
.info_len
;
1086 param
.private_data_len
= cmd
.data_len
;
1088 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
1090 result
= ib_send_cm_sidr_rep(ctx
->cm_id
, ¶m
);
1091 ib_ucm_ctx_put(ctx
);
1093 result
= PTR_ERR(ctx
);
1096 kfree(param
.private_data
);
1101 static ssize_t (*ucm_cmd_table
[])(struct ib_ucm_file
*file
,
1102 const char __user
*inbuf
,
1103 int in_len
, int out_len
) = {
1104 [IB_USER_CM_CMD_CREATE_ID
] = ib_ucm_create_id
,
1105 [IB_USER_CM_CMD_DESTROY_ID
] = ib_ucm_destroy_id
,
1106 [IB_USER_CM_CMD_ATTR_ID
] = ib_ucm_attr_id
,
1107 [IB_USER_CM_CMD_LISTEN
] = ib_ucm_listen
,
1108 [IB_USER_CM_CMD_ESTABLISH
] = ib_ucm_establish
,
1109 [IB_USER_CM_CMD_SEND_REQ
] = ib_ucm_send_req
,
1110 [IB_USER_CM_CMD_SEND_REP
] = ib_ucm_send_rep
,
1111 [IB_USER_CM_CMD_SEND_RTU
] = ib_ucm_send_rtu
,
1112 [IB_USER_CM_CMD_SEND_DREQ
] = ib_ucm_send_dreq
,
1113 [IB_USER_CM_CMD_SEND_DREP
] = ib_ucm_send_drep
,
1114 [IB_USER_CM_CMD_SEND_REJ
] = ib_ucm_send_rej
,
1115 [IB_USER_CM_CMD_SEND_MRA
] = ib_ucm_send_mra
,
1116 [IB_USER_CM_CMD_SEND_LAP
] = ib_ucm_send_lap
,
1117 [IB_USER_CM_CMD_SEND_APR
] = ib_ucm_send_apr
,
1118 [IB_USER_CM_CMD_SEND_SIDR_REQ
] = ib_ucm_send_sidr_req
,
1119 [IB_USER_CM_CMD_SEND_SIDR_REP
] = ib_ucm_send_sidr_rep
,
1120 [IB_USER_CM_CMD_EVENT
] = ib_ucm_event
,
1121 [IB_USER_CM_CMD_INIT_QP_ATTR
] = ib_ucm_init_qp_attr
,
1124 static ssize_t
ib_ucm_write(struct file
*filp
, const char __user
*buf
,
1125 size_t len
, loff_t
*pos
)
1127 struct ib_ucm_file
*file
= filp
->private_data
;
1128 struct ib_ucm_cmd_hdr hdr
;
1131 if (len
< sizeof(hdr
))
1134 if (copy_from_user(&hdr
, buf
, sizeof(hdr
)))
1137 if (hdr
.cmd
< 0 || hdr
.cmd
>= ARRAY_SIZE(ucm_cmd_table
))
1140 if (hdr
.in
+ sizeof(hdr
) > len
)
1143 result
= ucm_cmd_table
[hdr
.cmd
](file
, buf
+ sizeof(hdr
),
1151 static unsigned int ib_ucm_poll(struct file
*filp
,
1152 struct poll_table_struct
*wait
)
1154 struct ib_ucm_file
*file
= filp
->private_data
;
1155 unsigned int mask
= 0;
1157 poll_wait(filp
, &file
->poll_wait
, wait
);
1159 if (!list_empty(&file
->events
))
1160 mask
= POLLIN
| POLLRDNORM
;
1165 static int ib_ucm_open(struct inode
*inode
, struct file
*filp
)
1167 struct ib_ucm_file
*file
;
1169 file
= kmalloc(sizeof(*file
), GFP_KERNEL
);
1173 INIT_LIST_HEAD(&file
->events
);
1174 INIT_LIST_HEAD(&file
->ctxs
);
1175 init_waitqueue_head(&file
->poll_wait
);
1177 mutex_init(&file
->file_mutex
);
1179 filp
->private_data
= file
;
1181 file
->device
= container_of(inode
->i_cdev
, struct ib_ucm_device
, dev
);
1186 static int ib_ucm_close(struct inode
*inode
, struct file
*filp
)
1188 struct ib_ucm_file
*file
= filp
->private_data
;
1189 struct ib_ucm_context
*ctx
;
1191 mutex_lock(&file
->file_mutex
);
1192 while (!list_empty(&file
->ctxs
)) {
1193 ctx
= list_entry(file
->ctxs
.next
,
1194 struct ib_ucm_context
, file_list
);
1195 mutex_unlock(&file
->file_mutex
);
1197 mutex_lock(&ctx_id_mutex
);
1198 idr_remove(&ctx_id_table
, ctx
->id
);
1199 mutex_unlock(&ctx_id_mutex
);
1201 ib_destroy_cm_id(ctx
->cm_id
);
1202 ib_ucm_cleanup_events(ctx
);
1205 mutex_lock(&file
->file_mutex
);
1207 mutex_unlock(&file
->file_mutex
);
1212 static void ib_ucm_release_class_dev(struct class_device
*class_dev
)
1214 struct ib_ucm_device
*dev
;
1216 dev
= container_of(class_dev
, struct ib_ucm_device
, class_dev
);
1217 cdev_del(&dev
->dev
);
1218 clear_bit(dev
->devnum
, dev_map
);
1222 static struct file_operations ucm_fops
= {
1223 .owner
= THIS_MODULE
,
1224 .open
= ib_ucm_open
,
1225 .release
= ib_ucm_close
,
1226 .write
= ib_ucm_write
,
1227 .poll
= ib_ucm_poll
,
1230 static struct class ucm_class
= {
1231 .name
= "infiniband_cm",
1232 .release
= ib_ucm_release_class_dev
1235 static ssize_t
show_ibdev(struct class_device
*class_dev
, char *buf
)
1237 struct ib_ucm_device
*dev
;
1239 dev
= container_of(class_dev
, struct ib_ucm_device
, class_dev
);
1240 return sprintf(buf
, "%s\n", dev
->ib_dev
->name
);
1242 static CLASS_DEVICE_ATTR(ibdev
, S_IRUGO
, show_ibdev
, NULL
);
1244 static void ib_ucm_add_one(struct ib_device
*device
)
1246 struct ib_ucm_device
*ucm_dev
;
1248 if (!device
->alloc_ucontext
||
1249 rdma_node_get_transport(device
->node_type
) != RDMA_TRANSPORT_IB
)
1252 ucm_dev
= kzalloc(sizeof *ucm_dev
, GFP_KERNEL
);
1256 ucm_dev
->ib_dev
= device
;
1258 ucm_dev
->devnum
= find_first_zero_bit(dev_map
, IB_UCM_MAX_DEVICES
);
1259 if (ucm_dev
->devnum
>= IB_UCM_MAX_DEVICES
)
1262 set_bit(ucm_dev
->devnum
, dev_map
);
1264 cdev_init(&ucm_dev
->dev
, &ucm_fops
);
1265 ucm_dev
->dev
.owner
= THIS_MODULE
;
1266 kobject_set_name(&ucm_dev
->dev
.kobj
, "ucm%d", ucm_dev
->devnum
);
1267 if (cdev_add(&ucm_dev
->dev
, IB_UCM_BASE_DEV
+ ucm_dev
->devnum
, 1))
1270 ucm_dev
->class_dev
.class = &ucm_class
;
1271 ucm_dev
->class_dev
.dev
= device
->dma_device
;
1272 ucm_dev
->class_dev
.devt
= ucm_dev
->dev
.dev
;
1273 snprintf(ucm_dev
->class_dev
.class_id
, BUS_ID_SIZE
, "ucm%d",
1275 if (class_device_register(&ucm_dev
->class_dev
))
1278 if (class_device_create_file(&ucm_dev
->class_dev
,
1279 &class_device_attr_ibdev
))
1282 ib_set_client_data(device
, &ucm_client
, ucm_dev
);
1286 class_device_unregister(&ucm_dev
->class_dev
);
1288 cdev_del(&ucm_dev
->dev
);
1289 clear_bit(ucm_dev
->devnum
, dev_map
);
1295 static void ib_ucm_remove_one(struct ib_device
*device
)
1297 struct ib_ucm_device
*ucm_dev
= ib_get_client_data(device
, &ucm_client
);
1302 class_device_unregister(&ucm_dev
->class_dev
);
1305 static ssize_t
show_abi_version(struct class *class, char *buf
)
1307 return sprintf(buf
, "%d\n", IB_USER_CM_ABI_VERSION
);
1309 static CLASS_ATTR(abi_version
, S_IRUGO
, show_abi_version
, NULL
);
1311 static int __init
ib_ucm_init(void)
1315 ret
= register_chrdev_region(IB_UCM_BASE_DEV
, IB_UCM_MAX_DEVICES
,
1318 printk(KERN_ERR
"ucm: couldn't register device number\n");
1322 ret
= class_register(&ucm_class
);
1324 printk(KERN_ERR
"ucm: couldn't create class infiniband_cm\n");
1328 ret
= class_create_file(&ucm_class
, &class_attr_abi_version
);
1330 printk(KERN_ERR
"ucm: couldn't create abi_version attribute\n");
1334 ret
= ib_register_client(&ucm_client
);
1336 printk(KERN_ERR
"ucm: couldn't register client\n");
1342 class_unregister(&ucm_class
);
1344 unregister_chrdev_region(IB_UCM_BASE_DEV
, IB_UCM_MAX_DEVICES
);
1349 static void __exit
ib_ucm_cleanup(void)
1351 ib_unregister_client(&ucm_client
);
1352 class_unregister(&ucm_class
);
1353 unregister_chrdev_region(IB_UCM_BASE_DEV
, IB_UCM_MAX_DEVICES
);
1354 idr_destroy(&ctx_id_table
);
1357 module_init(ib_ucm_init
);
1358 module_exit(ib_ucm_cleanup
);