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 semaphore 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 down(&ctx
->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 up(&ctx
->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
= kmalloc(uvt
->data_len
, GFP_KERNEL
);
335 memcpy(uvt
->data
, evt
->private_data
, uvt
->data_len
);
336 uvt
->resp
.present
|= IB_UCM_PRES_DATA
;
340 uvt
->info
= kmalloc(uvt
->info_len
, GFP_KERNEL
);
344 memcpy(uvt
->info
, info
, uvt
->info_len
);
345 uvt
->resp
.present
|= IB_UCM_PRES_INFO
;
355 static int ib_ucm_event_handler(struct ib_cm_id
*cm_id
,
356 struct ib_cm_event
*event
)
358 struct ib_ucm_event
*uevent
;
359 struct ib_ucm_context
*ctx
;
362 ctx
= cm_id
->context
;
364 uevent
= kzalloc(sizeof *uevent
, GFP_KERNEL
);
369 uevent
->cm_id
= cm_id
;
370 uevent
->resp
.uid
= ctx
->uid
;
371 uevent
->resp
.id
= ctx
->id
;
372 uevent
->resp
.event
= event
->event
;
374 result
= ib_ucm_event_process(event
, uevent
);
378 down(&ctx
->file
->mutex
);
379 list_add_tail(&uevent
->file_list
, &ctx
->file
->events
);
380 list_add_tail(&uevent
->ctx_list
, &ctx
->events
);
381 wake_up_interruptible(&ctx
->file
->poll_wait
);
382 up(&ctx
->file
->mutex
);
388 /* Destroy new cm_id's */
389 return ib_ucm_new_cm_id(event
->event
);
392 static ssize_t
ib_ucm_event(struct ib_ucm_file
*file
,
393 const char __user
*inbuf
,
394 int in_len
, int out_len
)
396 struct ib_ucm_context
*ctx
;
397 struct ib_ucm_event_get cmd
;
398 struct ib_ucm_event
*uevent
;
402 if (out_len
< sizeof(struct ib_ucm_event_resp
))
405 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
409 while (list_empty(&file
->events
)) {
411 if (file
->filp
->f_flags
& O_NONBLOCK
) {
416 if (signal_pending(current
)) {
417 result
= -ERESTARTSYS
;
421 prepare_to_wait(&file
->poll_wait
, &wait
, TASK_INTERRUPTIBLE
);
427 finish_wait(&file
->poll_wait
, &wait
);
433 uevent
= list_entry(file
->events
.next
, struct ib_ucm_event
, file_list
);
435 if (ib_ucm_new_cm_id(uevent
->resp
.event
)) {
436 ctx
= ib_ucm_ctx_alloc(file
);
442 ctx
->cm_id
= uevent
->cm_id
;
443 ctx
->cm_id
->context
= ctx
;
444 uevent
->resp
.id
= ctx
->id
;
447 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
448 &uevent
->resp
, sizeof(uevent
->resp
))) {
454 if (cmd
.data_len
< uevent
->data_len
) {
458 if (copy_to_user((void __user
*)(unsigned long)cmd
.data
,
459 uevent
->data
, uevent
->data_len
)) {
466 if (cmd
.info_len
< uevent
->info_len
) {
470 if (copy_to_user((void __user
*)(unsigned long)cmd
.info
,
471 uevent
->info
, uevent
->info_len
)) {
477 list_del(&uevent
->file_list
);
478 list_del(&uevent
->ctx_list
);
479 uevent
->ctx
->events_reported
++;
489 static ssize_t
ib_ucm_create_id(struct ib_ucm_file
*file
,
490 const char __user
*inbuf
,
491 int in_len
, int out_len
)
493 struct ib_ucm_create_id cmd
;
494 struct ib_ucm_create_id_resp resp
;
495 struct ib_ucm_context
*ctx
;
498 if (out_len
< sizeof(resp
))
501 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
505 ctx
= ib_ucm_ctx_alloc(file
);
511 ctx
->cm_id
= ib_create_cm_id(file
->device
->ib_dev
,
512 ib_ucm_event_handler
, ctx
);
513 if (IS_ERR(ctx
->cm_id
)) {
514 result
= PTR_ERR(ctx
->cm_id
);
519 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
520 &resp
, sizeof(resp
))) {
527 ib_destroy_cm_id(ctx
->cm_id
);
529 mutex_lock(&ctx_id_mutex
);
530 idr_remove(&ctx_id_table
, ctx
->id
);
531 mutex_unlock(&ctx_id_mutex
);
536 static ssize_t
ib_ucm_destroy_id(struct ib_ucm_file
*file
,
537 const char __user
*inbuf
,
538 int in_len
, int out_len
)
540 struct ib_ucm_destroy_id cmd
;
541 struct ib_ucm_destroy_id_resp resp
;
542 struct ib_ucm_context
*ctx
;
545 if (out_len
< sizeof(resp
))
548 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
551 mutex_lock(&ctx_id_mutex
);
552 ctx
= idr_find(&ctx_id_table
, cmd
.id
);
554 ctx
= ERR_PTR(-ENOENT
);
555 else if (ctx
->file
!= file
)
556 ctx
= ERR_PTR(-EINVAL
);
558 idr_remove(&ctx_id_table
, ctx
->id
);
559 mutex_unlock(&ctx_id_mutex
);
565 wait_for_completion(&ctx
->comp
);
567 /* No new events will be generated after destroying the cm_id. */
568 ib_destroy_cm_id(ctx
->cm_id
);
569 /* Cleanup events not yet reported to the user. */
570 ib_ucm_cleanup_events(ctx
);
572 resp
.events_reported
= ctx
->events_reported
;
573 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
574 &resp
, sizeof(resp
)))
581 static ssize_t
ib_ucm_attr_id(struct ib_ucm_file
*file
,
582 const char __user
*inbuf
,
583 int in_len
, int out_len
)
585 struct ib_ucm_attr_id_resp resp
;
586 struct ib_ucm_attr_id cmd
;
587 struct ib_ucm_context
*ctx
;
590 if (out_len
< sizeof(resp
))
593 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
596 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
600 resp
.service_id
= ctx
->cm_id
->service_id
;
601 resp
.service_mask
= ctx
->cm_id
->service_mask
;
602 resp
.local_id
= ctx
->cm_id
->local_id
;
603 resp
.remote_id
= ctx
->cm_id
->remote_id
;
605 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
606 &resp
, sizeof(resp
)))
613 static ssize_t
ib_ucm_init_qp_attr(struct ib_ucm_file
*file
,
614 const char __user
*inbuf
,
615 int in_len
, int out_len
)
617 struct ib_uverbs_qp_attr resp
;
618 struct ib_ucm_init_qp_attr cmd
;
619 struct ib_ucm_context
*ctx
;
620 struct ib_qp_attr qp_attr
;
623 if (out_len
< sizeof(resp
))
626 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
629 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
633 resp
.qp_attr_mask
= 0;
634 memset(&qp_attr
, 0, sizeof qp_attr
);
635 qp_attr
.qp_state
= cmd
.qp_state
;
636 result
= ib_cm_init_qp_attr(ctx
->cm_id
, &qp_attr
, &resp
.qp_attr_mask
);
640 ib_copy_qp_attr_to_user(&resp
, &qp_attr
);
642 if (copy_to_user((void __user
*)(unsigned long)cmd
.response
,
643 &resp
, sizeof(resp
)))
651 static ssize_t
ib_ucm_listen(struct ib_ucm_file
*file
,
652 const char __user
*inbuf
,
653 int in_len
, int out_len
)
655 struct ib_ucm_listen cmd
;
656 struct ib_ucm_context
*ctx
;
659 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
662 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
666 result
= ib_cm_listen(ctx
->cm_id
, cmd
.service_id
, cmd
.service_mask
);
671 static ssize_t
ib_ucm_establish(struct ib_ucm_file
*file
,
672 const char __user
*inbuf
,
673 int in_len
, int out_len
)
675 struct ib_ucm_establish cmd
;
676 struct ib_ucm_context
*ctx
;
679 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
682 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
686 result
= ib_cm_establish(ctx
->cm_id
);
691 static int ib_ucm_alloc_data(const void **dest
, u64 src
, u32 len
)
700 data
= kmalloc(len
, GFP_KERNEL
);
704 if (copy_from_user(data
, (void __user
*)(unsigned long)src
, len
)) {
713 static int ib_ucm_path_get(struct ib_sa_path_rec
**path
, u64 src
)
715 struct ib_user_path_rec upath
;
716 struct ib_sa_path_rec
*sa_path
;
723 sa_path
= kmalloc(sizeof(*sa_path
), GFP_KERNEL
);
727 if (copy_from_user(&upath
, (void __user
*)(unsigned long)src
,
734 ib_copy_path_rec_from_user(sa_path
, &upath
);
739 static ssize_t
ib_ucm_send_req(struct ib_ucm_file
*file
,
740 const char __user
*inbuf
,
741 int in_len
, int out_len
)
743 struct ib_cm_req_param param
;
744 struct ib_ucm_context
*ctx
;
745 struct ib_ucm_req cmd
;
748 param
.private_data
= NULL
;
749 param
.primary_path
= NULL
;
750 param
.alternate_path
= NULL
;
752 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
755 result
= ib_ucm_alloc_data(¶m
.private_data
, cmd
.data
, cmd
.len
);
759 result
= ib_ucm_path_get(¶m
.primary_path
, cmd
.primary_path
);
763 result
= ib_ucm_path_get(¶m
.alternate_path
, cmd
.alternate_path
);
767 param
.private_data_len
= cmd
.len
;
768 param
.service_id
= cmd
.sid
;
769 param
.qp_num
= cmd
.qpn
;
770 param
.qp_type
= cmd
.qp_type
;
771 param
.starting_psn
= cmd
.psn
;
772 param
.peer_to_peer
= cmd
.peer_to_peer
;
773 param
.responder_resources
= cmd
.responder_resources
;
774 param
.initiator_depth
= cmd
.initiator_depth
;
775 param
.remote_cm_response_timeout
= cmd
.remote_cm_response_timeout
;
776 param
.flow_control
= cmd
.flow_control
;
777 param
.local_cm_response_timeout
= cmd
.local_cm_response_timeout
;
778 param
.retry_count
= cmd
.retry_count
;
779 param
.rnr_retry_count
= cmd
.rnr_retry_count
;
780 param
.max_cm_retries
= cmd
.max_cm_retries
;
783 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
785 result
= ib_send_cm_req(ctx
->cm_id
, ¶m
);
788 result
= PTR_ERR(ctx
);
791 kfree(param
.private_data
);
792 kfree(param
.primary_path
);
793 kfree(param
.alternate_path
);
797 static ssize_t
ib_ucm_send_rep(struct ib_ucm_file
*file
,
798 const char __user
*inbuf
,
799 int in_len
, int out_len
)
801 struct ib_cm_rep_param param
;
802 struct ib_ucm_context
*ctx
;
803 struct ib_ucm_rep cmd
;
806 param
.private_data
= NULL
;
808 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
811 result
= ib_ucm_alloc_data(¶m
.private_data
, cmd
.data
, cmd
.len
);
815 param
.qp_num
= cmd
.qpn
;
816 param
.starting_psn
= cmd
.psn
;
817 param
.private_data_len
= cmd
.len
;
818 param
.responder_resources
= cmd
.responder_resources
;
819 param
.initiator_depth
= cmd
.initiator_depth
;
820 param
.target_ack_delay
= cmd
.target_ack_delay
;
821 param
.failover_accepted
= cmd
.failover_accepted
;
822 param
.flow_control
= cmd
.flow_control
;
823 param
.rnr_retry_count
= cmd
.rnr_retry_count
;
826 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
829 result
= ib_send_cm_rep(ctx
->cm_id
, ¶m
);
832 result
= PTR_ERR(ctx
);
834 kfree(param
.private_data
);
838 static ssize_t
ib_ucm_send_private_data(struct ib_ucm_file
*file
,
839 const char __user
*inbuf
, int in_len
,
840 int (*func
)(struct ib_cm_id
*cm_id
,
841 const void *private_data
,
842 u8 private_data_len
))
844 struct ib_ucm_private_data cmd
;
845 struct ib_ucm_context
*ctx
;
846 const void *private_data
= NULL
;
849 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
852 result
= ib_ucm_alloc_data(&private_data
, cmd
.data
, cmd
.len
);
856 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
858 result
= func(ctx
->cm_id
, private_data
, cmd
.len
);
861 result
= PTR_ERR(ctx
);
867 static ssize_t
ib_ucm_send_rtu(struct ib_ucm_file
*file
,
868 const char __user
*inbuf
,
869 int in_len
, int out_len
)
871 return ib_ucm_send_private_data(file
, inbuf
, in_len
, ib_send_cm_rtu
);
874 static ssize_t
ib_ucm_send_dreq(struct ib_ucm_file
*file
,
875 const char __user
*inbuf
,
876 int in_len
, int out_len
)
878 return ib_ucm_send_private_data(file
, inbuf
, in_len
, ib_send_cm_dreq
);
881 static ssize_t
ib_ucm_send_drep(struct ib_ucm_file
*file
,
882 const char __user
*inbuf
,
883 int in_len
, int out_len
)
885 return ib_ucm_send_private_data(file
, inbuf
, in_len
, ib_send_cm_drep
);
888 static ssize_t
ib_ucm_send_info(struct ib_ucm_file
*file
,
889 const char __user
*inbuf
, int in_len
,
890 int (*func
)(struct ib_cm_id
*cm_id
,
897 struct ib_ucm_context
*ctx
;
898 struct ib_ucm_info cmd
;
899 const void *data
= NULL
;
900 const void *info
= NULL
;
903 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
906 result
= ib_ucm_alloc_data(&data
, cmd
.data
, cmd
.data_len
);
910 result
= ib_ucm_alloc_data(&info
, cmd
.info
, cmd
.info_len
);
914 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
916 result
= func(ctx
->cm_id
, cmd
.status
, info
, cmd
.info_len
,
920 result
= PTR_ERR(ctx
);
928 static ssize_t
ib_ucm_send_rej(struct ib_ucm_file
*file
,
929 const char __user
*inbuf
,
930 int in_len
, int out_len
)
932 return ib_ucm_send_info(file
, inbuf
, in_len
, (void *)ib_send_cm_rej
);
935 static ssize_t
ib_ucm_send_apr(struct ib_ucm_file
*file
,
936 const char __user
*inbuf
,
937 int in_len
, int out_len
)
939 return ib_ucm_send_info(file
, inbuf
, in_len
, (void *)ib_send_cm_apr
);
942 static ssize_t
ib_ucm_send_mra(struct ib_ucm_file
*file
,
943 const char __user
*inbuf
,
944 int in_len
, int out_len
)
946 struct ib_ucm_context
*ctx
;
947 struct ib_ucm_mra cmd
;
948 const void *data
= NULL
;
951 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
954 result
= ib_ucm_alloc_data(&data
, cmd
.data
, cmd
.len
);
958 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
960 result
= ib_send_cm_mra(ctx
->cm_id
, cmd
.timeout
, data
, cmd
.len
);
963 result
= PTR_ERR(ctx
);
969 static ssize_t
ib_ucm_send_lap(struct ib_ucm_file
*file
,
970 const char __user
*inbuf
,
971 int in_len
, int out_len
)
973 struct ib_ucm_context
*ctx
;
974 struct ib_sa_path_rec
*path
= NULL
;
975 struct ib_ucm_lap cmd
;
976 const void *data
= NULL
;
979 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
982 result
= ib_ucm_alloc_data(&data
, cmd
.data
, cmd
.len
);
986 result
= ib_ucm_path_get(&path
, cmd
.path
);
990 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
992 result
= ib_send_cm_lap(ctx
->cm_id
, path
, data
, cmd
.len
);
995 result
= PTR_ERR(ctx
);
1003 static ssize_t
ib_ucm_send_sidr_req(struct ib_ucm_file
*file
,
1004 const char __user
*inbuf
,
1005 int in_len
, int out_len
)
1007 struct ib_cm_sidr_req_param param
;
1008 struct ib_ucm_context
*ctx
;
1009 struct ib_ucm_sidr_req cmd
;
1012 param
.private_data
= NULL
;
1015 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
1018 result
= ib_ucm_alloc_data(¶m
.private_data
, cmd
.data
, cmd
.len
);
1022 result
= ib_ucm_path_get(¶m
.path
, cmd
.path
);
1026 param
.private_data_len
= cmd
.len
;
1027 param
.service_id
= cmd
.sid
;
1028 param
.timeout_ms
= cmd
.timeout
;
1029 param
.max_cm_retries
= cmd
.max_cm_retries
;
1030 param
.pkey
= cmd
.pkey
;
1032 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
1034 result
= ib_send_cm_sidr_req(ctx
->cm_id
, ¶m
);
1035 ib_ucm_ctx_put(ctx
);
1037 result
= PTR_ERR(ctx
);
1040 kfree(param
.private_data
);
1045 static ssize_t
ib_ucm_send_sidr_rep(struct ib_ucm_file
*file
,
1046 const char __user
*inbuf
,
1047 int in_len
, int out_len
)
1049 struct ib_cm_sidr_rep_param param
;
1050 struct ib_ucm_sidr_rep cmd
;
1051 struct ib_ucm_context
*ctx
;
1056 if (copy_from_user(&cmd
, inbuf
, sizeof(cmd
)))
1059 result
= ib_ucm_alloc_data(¶m
.private_data
,
1060 cmd
.data
, cmd
.data_len
);
1064 result
= ib_ucm_alloc_data(¶m
.info
, cmd
.info
, cmd
.info_len
);
1068 param
.qp_num
= cmd
.qpn
;
1069 param
.qkey
= cmd
.qkey
;
1070 param
.status
= cmd
.status
;
1071 param
.info_length
= cmd
.info_len
;
1072 param
.private_data_len
= cmd
.data_len
;
1074 ctx
= ib_ucm_ctx_get(file
, cmd
.id
);
1076 result
= ib_send_cm_sidr_rep(ctx
->cm_id
, ¶m
);
1077 ib_ucm_ctx_put(ctx
);
1079 result
= PTR_ERR(ctx
);
1082 kfree(param
.private_data
);
1087 static ssize_t (*ucm_cmd_table
[])(struct ib_ucm_file
*file
,
1088 const char __user
*inbuf
,
1089 int in_len
, int out_len
) = {
1090 [IB_USER_CM_CMD_CREATE_ID
] = ib_ucm_create_id
,
1091 [IB_USER_CM_CMD_DESTROY_ID
] = ib_ucm_destroy_id
,
1092 [IB_USER_CM_CMD_ATTR_ID
] = ib_ucm_attr_id
,
1093 [IB_USER_CM_CMD_LISTEN
] = ib_ucm_listen
,
1094 [IB_USER_CM_CMD_ESTABLISH
] = ib_ucm_establish
,
1095 [IB_USER_CM_CMD_SEND_REQ
] = ib_ucm_send_req
,
1096 [IB_USER_CM_CMD_SEND_REP
] = ib_ucm_send_rep
,
1097 [IB_USER_CM_CMD_SEND_RTU
] = ib_ucm_send_rtu
,
1098 [IB_USER_CM_CMD_SEND_DREQ
] = ib_ucm_send_dreq
,
1099 [IB_USER_CM_CMD_SEND_DREP
] = ib_ucm_send_drep
,
1100 [IB_USER_CM_CMD_SEND_REJ
] = ib_ucm_send_rej
,
1101 [IB_USER_CM_CMD_SEND_MRA
] = ib_ucm_send_mra
,
1102 [IB_USER_CM_CMD_SEND_LAP
] = ib_ucm_send_lap
,
1103 [IB_USER_CM_CMD_SEND_APR
] = ib_ucm_send_apr
,
1104 [IB_USER_CM_CMD_SEND_SIDR_REQ
] = ib_ucm_send_sidr_req
,
1105 [IB_USER_CM_CMD_SEND_SIDR_REP
] = ib_ucm_send_sidr_rep
,
1106 [IB_USER_CM_CMD_EVENT
] = ib_ucm_event
,
1107 [IB_USER_CM_CMD_INIT_QP_ATTR
] = ib_ucm_init_qp_attr
,
1110 static ssize_t
ib_ucm_write(struct file
*filp
, const char __user
*buf
,
1111 size_t len
, loff_t
*pos
)
1113 struct ib_ucm_file
*file
= filp
->private_data
;
1114 struct ib_ucm_cmd_hdr hdr
;
1117 if (len
< sizeof(hdr
))
1120 if (copy_from_user(&hdr
, buf
, sizeof(hdr
)))
1123 if (hdr
.cmd
< 0 || hdr
.cmd
>= ARRAY_SIZE(ucm_cmd_table
))
1126 if (hdr
.in
+ sizeof(hdr
) > len
)
1129 result
= ucm_cmd_table
[hdr
.cmd
](file
, buf
+ sizeof(hdr
),
1137 static unsigned int ib_ucm_poll(struct file
*filp
,
1138 struct poll_table_struct
*wait
)
1140 struct ib_ucm_file
*file
= filp
->private_data
;
1141 unsigned int mask
= 0;
1143 poll_wait(filp
, &file
->poll_wait
, wait
);
1145 if (!list_empty(&file
->events
))
1146 mask
= POLLIN
| POLLRDNORM
;
1151 static int ib_ucm_open(struct inode
*inode
, struct file
*filp
)
1153 struct ib_ucm_file
*file
;
1155 file
= kmalloc(sizeof(*file
), GFP_KERNEL
);
1159 INIT_LIST_HEAD(&file
->events
);
1160 INIT_LIST_HEAD(&file
->ctxs
);
1161 init_waitqueue_head(&file
->poll_wait
);
1163 init_MUTEX(&file
->mutex
);
1165 filp
->private_data
= file
;
1167 file
->device
= container_of(inode
->i_cdev
, struct ib_ucm_device
, dev
);
1172 static int ib_ucm_close(struct inode
*inode
, struct file
*filp
)
1174 struct ib_ucm_file
*file
= filp
->private_data
;
1175 struct ib_ucm_context
*ctx
;
1178 while (!list_empty(&file
->ctxs
)) {
1179 ctx
= list_entry(file
->ctxs
.next
,
1180 struct ib_ucm_context
, file_list
);
1183 mutex_lock(&ctx_id_mutex
);
1184 idr_remove(&ctx_id_table
, ctx
->id
);
1185 mutex_unlock(&ctx_id_mutex
);
1187 ib_destroy_cm_id(ctx
->cm_id
);
1188 ib_ucm_cleanup_events(ctx
);
1198 static void ib_ucm_release_class_dev(struct class_device
*class_dev
)
1200 struct ib_ucm_device
*dev
;
1202 dev
= container_of(class_dev
, struct ib_ucm_device
, class_dev
);
1203 cdev_del(&dev
->dev
);
1204 clear_bit(dev
->devnum
, dev_map
);
1208 static struct file_operations ucm_fops
= {
1209 .owner
= THIS_MODULE
,
1210 .open
= ib_ucm_open
,
1211 .release
= ib_ucm_close
,
1212 .write
= ib_ucm_write
,
1213 .poll
= ib_ucm_poll
,
1216 static struct class ucm_class
= {
1217 .name
= "infiniband_cm",
1218 .release
= ib_ucm_release_class_dev
1221 static ssize_t
show_ibdev(struct class_device
*class_dev
, char *buf
)
1223 struct ib_ucm_device
*dev
;
1225 dev
= container_of(class_dev
, struct ib_ucm_device
, class_dev
);
1226 return sprintf(buf
, "%s\n", dev
->ib_dev
->name
);
1228 static CLASS_DEVICE_ATTR(ibdev
, S_IRUGO
, show_ibdev
, NULL
);
1230 static void ib_ucm_add_one(struct ib_device
*device
)
1232 struct ib_ucm_device
*ucm_dev
;
1234 if (!device
->alloc_ucontext
)
1237 ucm_dev
= kzalloc(sizeof *ucm_dev
, GFP_KERNEL
);
1241 ucm_dev
->ib_dev
= device
;
1243 ucm_dev
->devnum
= find_first_zero_bit(dev_map
, IB_UCM_MAX_DEVICES
);
1244 if (ucm_dev
->devnum
>= IB_UCM_MAX_DEVICES
)
1247 set_bit(ucm_dev
->devnum
, dev_map
);
1249 cdev_init(&ucm_dev
->dev
, &ucm_fops
);
1250 ucm_dev
->dev
.owner
= THIS_MODULE
;
1251 kobject_set_name(&ucm_dev
->dev
.kobj
, "ucm%d", ucm_dev
->devnum
);
1252 if (cdev_add(&ucm_dev
->dev
, IB_UCM_BASE_DEV
+ ucm_dev
->devnum
, 1))
1255 ucm_dev
->class_dev
.class = &ucm_class
;
1256 ucm_dev
->class_dev
.dev
= device
->dma_device
;
1257 ucm_dev
->class_dev
.devt
= ucm_dev
->dev
.dev
;
1258 snprintf(ucm_dev
->class_dev
.class_id
, BUS_ID_SIZE
, "ucm%d",
1260 if (class_device_register(&ucm_dev
->class_dev
))
1263 if (class_device_create_file(&ucm_dev
->class_dev
,
1264 &class_device_attr_ibdev
))
1267 ib_set_client_data(device
, &ucm_client
, ucm_dev
);
1271 class_device_unregister(&ucm_dev
->class_dev
);
1273 cdev_del(&ucm_dev
->dev
);
1274 clear_bit(ucm_dev
->devnum
, dev_map
);
1280 static void ib_ucm_remove_one(struct ib_device
*device
)
1282 struct ib_ucm_device
*ucm_dev
= ib_get_client_data(device
, &ucm_client
);
1287 class_device_unregister(&ucm_dev
->class_dev
);
1290 static ssize_t
show_abi_version(struct class *class, char *buf
)
1292 return sprintf(buf
, "%d\n", IB_USER_CM_ABI_VERSION
);
1294 static CLASS_ATTR(abi_version
, S_IRUGO
, show_abi_version
, NULL
);
1296 static int __init
ib_ucm_init(void)
1300 ret
= register_chrdev_region(IB_UCM_BASE_DEV
, IB_UCM_MAX_DEVICES
,
1303 printk(KERN_ERR
"ucm: couldn't register device number\n");
1307 ret
= class_register(&ucm_class
);
1309 printk(KERN_ERR
"ucm: couldn't create class infiniband_cm\n");
1313 ret
= class_create_file(&ucm_class
, &class_attr_abi_version
);
1315 printk(KERN_ERR
"ucm: couldn't create abi_version attribute\n");
1319 ret
= ib_register_client(&ucm_client
);
1321 printk(KERN_ERR
"ucm: couldn't register client\n");
1327 class_unregister(&ucm_class
);
1329 unregister_chrdev_region(IB_UCM_BASE_DEV
, IB_UCM_MAX_DEVICES
);
1334 static void __exit
ib_ucm_cleanup(void)
1336 ib_unregister_client(&ucm_client
);
1337 class_unregister(&ucm_class
);
1338 unregister_chrdev_region(IB_UCM_BASE_DEV
, IB_UCM_MAX_DEVICES
);
1339 idr_destroy(&ctx_id_table
);
1342 module_init(ib_ucm_init
);
1343 module_exit(ib_ucm_cleanup
);