2 * Copyright (c) 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Cisco Systems. 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: uverbs_main.c 2733 2005-06-28 19:14:34Z roland $
36 #include <linux/module.h>
37 #include <linux/init.h>
38 #include <linux/device.h>
39 #include <linux/err.h>
41 #include <linux/poll.h>
42 #include <linux/file.h>
43 #include <linux/mount.h>
45 #include <asm/uaccess.h>
49 MODULE_AUTHOR("Roland Dreier");
50 MODULE_DESCRIPTION("InfiniBand userspace verbs access");
51 MODULE_LICENSE("Dual BSD/GPL");
53 #define INFINIBANDEVENTFS_MAGIC 0x49426576 /* "IBev" */
56 IB_UVERBS_MAJOR
= 231,
57 IB_UVERBS_BASE_MINOR
= 192,
58 IB_UVERBS_MAX_DEVICES
= 32
61 #define IB_UVERBS_BASE_DEV MKDEV(IB_UVERBS_MAJOR, IB_UVERBS_BASE_MINOR)
63 DECLARE_MUTEX(ib_uverbs_idr_mutex
);
64 DEFINE_IDR(ib_uverbs_pd_idr
);
65 DEFINE_IDR(ib_uverbs_mr_idr
);
66 DEFINE_IDR(ib_uverbs_mw_idr
);
67 DEFINE_IDR(ib_uverbs_ah_idr
);
68 DEFINE_IDR(ib_uverbs_cq_idr
);
69 DEFINE_IDR(ib_uverbs_qp_idr
);
71 static spinlock_t map_lock
;
72 static DECLARE_BITMAP(dev_map
, IB_UVERBS_MAX_DEVICES
);
74 static ssize_t (*uverbs_cmd_table
[])(struct ib_uverbs_file
*file
,
75 const char __user
*buf
, int in_len
,
77 [IB_USER_VERBS_CMD_QUERY_PARAMS
] = ib_uverbs_query_params
,
78 [IB_USER_VERBS_CMD_GET_CONTEXT
] = ib_uverbs_get_context
,
79 [IB_USER_VERBS_CMD_QUERY_DEVICE
] = ib_uverbs_query_device
,
80 [IB_USER_VERBS_CMD_QUERY_PORT
] = ib_uverbs_query_port
,
81 [IB_USER_VERBS_CMD_QUERY_GID
] = ib_uverbs_query_gid
,
82 [IB_USER_VERBS_CMD_QUERY_PKEY
] = ib_uverbs_query_pkey
,
83 [IB_USER_VERBS_CMD_ALLOC_PD
] = ib_uverbs_alloc_pd
,
84 [IB_USER_VERBS_CMD_DEALLOC_PD
] = ib_uverbs_dealloc_pd
,
85 [IB_USER_VERBS_CMD_REG_MR
] = ib_uverbs_reg_mr
,
86 [IB_USER_VERBS_CMD_DEREG_MR
] = ib_uverbs_dereg_mr
,
87 [IB_USER_VERBS_CMD_CREATE_CQ
] = ib_uverbs_create_cq
,
88 [IB_USER_VERBS_CMD_DESTROY_CQ
] = ib_uverbs_destroy_cq
,
89 [IB_USER_VERBS_CMD_CREATE_QP
] = ib_uverbs_create_qp
,
90 [IB_USER_VERBS_CMD_MODIFY_QP
] = ib_uverbs_modify_qp
,
91 [IB_USER_VERBS_CMD_DESTROY_QP
] = ib_uverbs_destroy_qp
,
92 [IB_USER_VERBS_CMD_ATTACH_MCAST
] = ib_uverbs_attach_mcast
,
93 [IB_USER_VERBS_CMD_DETACH_MCAST
] = ib_uverbs_detach_mcast
,
96 static struct vfsmount
*uverbs_event_mnt
;
98 static void ib_uverbs_add_one(struct ib_device
*device
);
99 static void ib_uverbs_remove_one(struct ib_device
*device
);
101 static int ib_dealloc_ucontext(struct ib_ucontext
*context
)
103 struct ib_uobject
*uobj
, *tmp
;
108 down(&ib_uverbs_idr_mutex
);
112 list_for_each_entry_safe(uobj
, tmp
, &context
->qp_list
, list
) {
113 struct ib_qp
*qp
= idr_find(&ib_uverbs_qp_idr
, uobj
->id
);
114 idr_remove(&ib_uverbs_qp_idr
, uobj
->id
);
116 list_del(&uobj
->list
);
120 list_for_each_entry_safe(uobj
, tmp
, &context
->cq_list
, list
) {
121 struct ib_cq
*cq
= idr_find(&ib_uverbs_cq_idr
, uobj
->id
);
122 idr_remove(&ib_uverbs_cq_idr
, uobj
->id
);
124 list_del(&uobj
->list
);
131 list_for_each_entry_safe(uobj
, tmp
, &context
->mr_list
, list
) {
132 struct ib_mr
*mr
= idr_find(&ib_uverbs_mr_idr
, uobj
->id
);
133 struct ib_umem_object
*memobj
;
135 idr_remove(&ib_uverbs_mr_idr
, uobj
->id
);
138 memobj
= container_of(uobj
, struct ib_umem_object
, uobject
);
139 ib_umem_release_on_close(mr
->device
, &memobj
->umem
);
141 list_del(&uobj
->list
);
145 list_for_each_entry_safe(uobj
, tmp
, &context
->pd_list
, list
) {
146 struct ib_pd
*pd
= idr_find(&ib_uverbs_pd_idr
, uobj
->id
);
147 idr_remove(&ib_uverbs_pd_idr
, uobj
->id
);
149 list_del(&uobj
->list
);
153 up(&ib_uverbs_idr_mutex
);
155 return context
->device
->dealloc_ucontext(context
);
158 static void ib_uverbs_release_file(struct kref
*ref
)
160 struct ib_uverbs_file
*file
=
161 container_of(ref
, struct ib_uverbs_file
, ref
);
163 module_put(file
->device
->ib_dev
->owner
);
167 static ssize_t
ib_uverbs_event_read(struct file
*filp
, char __user
*buf
,
168 size_t count
, loff_t
*pos
)
170 struct ib_uverbs_event_file
*file
= filp
->private_data
;
175 spin_lock_irq(&file
->lock
);
177 while (list_empty(&file
->event_list
) && file
->fd
>= 0) {
178 spin_unlock_irq(&file
->lock
);
180 if (filp
->f_flags
& O_NONBLOCK
)
183 if (wait_event_interruptible(file
->poll_wait
,
184 !list_empty(&file
->event_list
) ||
188 spin_lock_irq(&file
->lock
);
192 spin_unlock_irq(&file
->lock
);
196 if (file
->is_async
) {
197 event
= list_entry(file
->event_list
.next
,
198 struct ib_uverbs_async_event
, list
);
199 eventsz
= sizeof (struct ib_uverbs_async_event_desc
);
201 event
= list_entry(file
->event_list
.next
,
202 struct ib_uverbs_comp_event
, list
);
203 eventsz
= sizeof (struct ib_uverbs_comp_event_desc
);
206 if (eventsz
> count
) {
210 list_del(file
->event_list
.next
);
212 spin_unlock_irq(&file
->lock
);
215 if (copy_to_user(buf
, event
, eventsz
))
226 static unsigned int ib_uverbs_event_poll(struct file
*filp
,
227 struct poll_table_struct
*wait
)
229 unsigned int pollflags
= 0;
230 struct ib_uverbs_event_file
*file
= filp
->private_data
;
232 poll_wait(filp
, &file
->poll_wait
, wait
);
234 spin_lock_irq(&file
->lock
);
237 else if (!list_empty(&file
->event_list
))
238 pollflags
= POLLIN
| POLLRDNORM
;
239 spin_unlock_irq(&file
->lock
);
244 static void ib_uverbs_event_release(struct ib_uverbs_event_file
*file
)
246 struct list_head
*entry
, *tmp
;
248 spin_lock_irq(&file
->lock
);
249 if (file
->fd
!= -1) {
251 list_for_each_safe(entry
, tmp
, &file
->event_list
)
253 kfree(list_entry(entry
, struct ib_uverbs_async_event
, list
));
255 kfree(list_entry(entry
, struct ib_uverbs_comp_event
, list
));
257 spin_unlock_irq(&file
->lock
);
260 static int ib_uverbs_event_close(struct inode
*inode
, struct file
*filp
)
262 struct ib_uverbs_event_file
*file
= filp
->private_data
;
264 ib_uverbs_event_release(file
);
265 kref_put(&file
->uverbs_file
->ref
, ib_uverbs_release_file
);
270 static struct file_operations uverbs_event_fops
= {
272 * No .owner field since we artificially create event files,
273 * so there is no increment to the module reference count in
274 * the open path. All event files come from a uverbs command
275 * file, which already takes a module reference, so this is OK.
277 .read
= ib_uverbs_event_read
,
278 .poll
= ib_uverbs_event_poll
,
279 .release
= ib_uverbs_event_close
282 void ib_uverbs_comp_handler(struct ib_cq
*cq
, void *cq_context
)
284 struct ib_uverbs_file
*file
= cq_context
;
285 struct ib_uverbs_comp_event
*entry
;
288 entry
= kmalloc(sizeof *entry
, GFP_ATOMIC
);
292 entry
->desc
.cq_handle
= cq
->uobject
->user_handle
;
294 spin_lock_irqsave(&file
->comp_file
[0].lock
, flags
);
295 list_add_tail(&entry
->list
, &file
->comp_file
[0].event_list
);
296 spin_unlock_irqrestore(&file
->comp_file
[0].lock
, flags
);
298 wake_up_interruptible(&file
->comp_file
[0].poll_wait
);
301 static void ib_uverbs_async_handler(struct ib_uverbs_file
*file
,
302 __u64 element
, __u64 event
)
304 struct ib_uverbs_async_event
*entry
;
307 entry
= kmalloc(sizeof *entry
, GFP_ATOMIC
);
311 entry
->desc
.element
= element
;
312 entry
->desc
.event_type
= event
;
314 spin_lock_irqsave(&file
->async_file
.lock
, flags
);
315 list_add_tail(&entry
->list
, &file
->async_file
.event_list
);
316 spin_unlock_irqrestore(&file
->async_file
.lock
, flags
);
318 wake_up_interruptible(&file
->async_file
.poll_wait
);
321 void ib_uverbs_cq_event_handler(struct ib_event
*event
, void *context_ptr
)
323 ib_uverbs_async_handler(context_ptr
,
324 event
->element
.cq
->uobject
->user_handle
,
328 void ib_uverbs_qp_event_handler(struct ib_event
*event
, void *context_ptr
)
330 ib_uverbs_async_handler(context_ptr
,
331 event
->element
.qp
->uobject
->user_handle
,
335 static void ib_uverbs_event_handler(struct ib_event_handler
*handler
,
336 struct ib_event
*event
)
338 struct ib_uverbs_file
*file
=
339 container_of(handler
, struct ib_uverbs_file
, event_handler
);
341 ib_uverbs_async_handler(file
, event
->element
.port_num
, event
->event
);
344 static int ib_uverbs_event_init(struct ib_uverbs_event_file
*file
,
345 struct ib_uverbs_file
*uverbs_file
)
349 spin_lock_init(&file
->lock
);
350 INIT_LIST_HEAD(&file
->event_list
);
351 init_waitqueue_head(&file
->poll_wait
);
352 file
->uverbs_file
= uverbs_file
;
354 file
->fd
= get_unused_fd();
358 filp
= get_empty_filp();
360 put_unused_fd(file
->fd
);
364 filp
->f_op
= &uverbs_event_fops
;
365 filp
->f_vfsmnt
= mntget(uverbs_event_mnt
);
366 filp
->f_dentry
= dget(uverbs_event_mnt
->mnt_root
);
367 filp
->f_mapping
= filp
->f_dentry
->d_inode
->i_mapping
;
368 filp
->f_flags
= O_RDONLY
;
369 filp
->f_mode
= FMODE_READ
;
370 filp
->private_data
= file
;
372 fd_install(file
->fd
, filp
);
377 static ssize_t
ib_uverbs_write(struct file
*filp
, const char __user
*buf
,
378 size_t count
, loff_t
*pos
)
380 struct ib_uverbs_file
*file
= filp
->private_data
;
381 struct ib_uverbs_cmd_hdr hdr
;
383 if (count
< sizeof hdr
)
386 if (copy_from_user(&hdr
, buf
, sizeof hdr
))
389 if (hdr
.in_words
* 4 != count
)
392 if (hdr
.command
< 0 || hdr
.command
>= ARRAY_SIZE(uverbs_cmd_table
))
395 if (!file
->ucontext
&&
396 hdr
.command
!= IB_USER_VERBS_CMD_QUERY_PARAMS
&&
397 hdr
.command
!= IB_USER_VERBS_CMD_GET_CONTEXT
)
400 return uverbs_cmd_table
[hdr
.command
](file
, buf
+ sizeof hdr
,
401 hdr
.in_words
* 4, hdr
.out_words
* 4);
404 static int ib_uverbs_mmap(struct file
*filp
, struct vm_area_struct
*vma
)
406 struct ib_uverbs_file
*file
= filp
->private_data
;
411 return file
->device
->ib_dev
->mmap(file
->ucontext
, vma
);
414 static int ib_uverbs_open(struct inode
*inode
, struct file
*filp
)
416 struct ib_uverbs_device
*dev
=
417 container_of(inode
->i_cdev
, struct ib_uverbs_device
, dev
);
418 struct ib_uverbs_file
*file
;
422 if (!try_module_get(dev
->ib_dev
->owner
))
425 file
= kmalloc(sizeof *file
+
426 (dev
->num_comp
- 1) * sizeof (struct ib_uverbs_event_file
),
432 kref_init(&file
->ref
);
434 file
->ucontext
= NULL
;
436 ret
= ib_uverbs_event_init(&file
->async_file
, file
);
440 file
->async_file
.is_async
= 1;
442 kref_get(&file
->ref
);
444 for (i
= 0; i
< dev
->num_comp
; ++i
) {
445 ret
= ib_uverbs_event_init(&file
->comp_file
[i
], file
);
448 kref_get(&file
->ref
);
449 file
->comp_file
[i
].is_async
= 0;
453 filp
->private_data
= file
;
455 INIT_IB_EVENT_HANDLER(&file
->event_handler
, dev
->ib_dev
,
456 ib_uverbs_event_handler
);
457 if (ib_register_event_handler(&file
->event_handler
))
464 ib_uverbs_event_release(&file
->comp_file
[i
]);
466 ib_uverbs_event_release(&file
->async_file
);
469 kref_put(&file
->ref
, ib_uverbs_release_file
);
474 static int ib_uverbs_close(struct inode
*inode
, struct file
*filp
)
476 struct ib_uverbs_file
*file
= filp
->private_data
;
479 ib_unregister_event_handler(&file
->event_handler
);
480 ib_uverbs_event_release(&file
->async_file
);
481 ib_dealloc_ucontext(file
->ucontext
);
483 for (i
= 0; i
< file
->device
->num_comp
; ++i
)
484 ib_uverbs_event_release(&file
->comp_file
[i
]);
486 kref_put(&file
->ref
, ib_uverbs_release_file
);
491 static struct file_operations uverbs_fops
= {
492 .owner
= THIS_MODULE
,
493 .write
= ib_uverbs_write
,
494 .open
= ib_uverbs_open
,
495 .release
= ib_uverbs_close
498 static struct file_operations uverbs_mmap_fops
= {
499 .owner
= THIS_MODULE
,
500 .write
= ib_uverbs_write
,
501 .mmap
= ib_uverbs_mmap
,
502 .open
= ib_uverbs_open
,
503 .release
= ib_uverbs_close
506 static struct ib_client uverbs_client
= {
508 .add
= ib_uverbs_add_one
,
509 .remove
= ib_uverbs_remove_one
512 static ssize_t
show_ibdev(struct class_device
*class_dev
, char *buf
)
514 struct ib_uverbs_device
*dev
=
515 container_of(class_dev
, struct ib_uverbs_device
, class_dev
);
517 return sprintf(buf
, "%s\n", dev
->ib_dev
->name
);
519 static CLASS_DEVICE_ATTR(ibdev
, S_IRUGO
, show_ibdev
, NULL
);
521 static void ib_uverbs_release_class_dev(struct class_device
*class_dev
)
523 struct ib_uverbs_device
*dev
=
524 container_of(class_dev
, struct ib_uverbs_device
, class_dev
);
527 clear_bit(dev
->devnum
, dev_map
);
531 static struct class uverbs_class
= {
532 .name
= "infiniband_verbs",
533 .release
= ib_uverbs_release_class_dev
536 static ssize_t
show_abi_version(struct class *class, char *buf
)
538 return sprintf(buf
, "%d\n", IB_USER_VERBS_ABI_VERSION
);
540 static CLASS_ATTR(abi_version
, S_IRUGO
, show_abi_version
, NULL
);
542 static void ib_uverbs_add_one(struct ib_device
*device
)
544 struct ib_uverbs_device
*uverbs_dev
;
546 if (!device
->alloc_ucontext
)
549 uverbs_dev
= kmalloc(sizeof *uverbs_dev
, GFP_KERNEL
);
553 memset(uverbs_dev
, 0, sizeof *uverbs_dev
);
555 spin_lock(&map_lock
);
556 uverbs_dev
->devnum
= find_first_zero_bit(dev_map
, IB_UVERBS_MAX_DEVICES
);
557 if (uverbs_dev
->devnum
>= IB_UVERBS_MAX_DEVICES
) {
558 spin_unlock(&map_lock
);
561 set_bit(uverbs_dev
->devnum
, dev_map
);
562 spin_unlock(&map_lock
);
564 uverbs_dev
->ib_dev
= device
;
565 uverbs_dev
->num_comp
= 1;
568 cdev_init(&uverbs_dev
->dev
, &uverbs_mmap_fops
);
570 cdev_init(&uverbs_dev
->dev
, &uverbs_fops
);
571 uverbs_dev
->dev
.owner
= THIS_MODULE
;
572 kobject_set_name(&uverbs_dev
->dev
.kobj
, "uverbs%d", uverbs_dev
->devnum
);
573 if (cdev_add(&uverbs_dev
->dev
, IB_UVERBS_BASE_DEV
+ uverbs_dev
->devnum
, 1))
576 uverbs_dev
->class_dev
.class = &uverbs_class
;
577 uverbs_dev
->class_dev
.dev
= device
->dma_device
;
578 uverbs_dev
->class_dev
.devt
= uverbs_dev
->dev
.dev
;
579 snprintf(uverbs_dev
->class_dev
.class_id
, BUS_ID_SIZE
, "uverbs%d", uverbs_dev
->devnum
);
580 if (class_device_register(&uverbs_dev
->class_dev
))
583 if (class_device_create_file(&uverbs_dev
->class_dev
, &class_device_attr_ibdev
))
586 ib_set_client_data(device
, &uverbs_client
, uverbs_dev
);
591 class_device_unregister(&uverbs_dev
->class_dev
);
594 cdev_del(&uverbs_dev
->dev
);
595 clear_bit(uverbs_dev
->devnum
, dev_map
);
602 static void ib_uverbs_remove_one(struct ib_device
*device
)
604 struct ib_uverbs_device
*uverbs_dev
= ib_get_client_data(device
, &uverbs_client
);
609 class_device_unregister(&uverbs_dev
->class_dev
);
612 static struct super_block
*uverbs_event_get_sb(struct file_system_type
*fs_type
, int flags
,
613 const char *dev_name
, void *data
)
615 return get_sb_pseudo(fs_type
, "infinibandevent:", NULL
,
616 INFINIBANDEVENTFS_MAGIC
);
619 static struct file_system_type uverbs_event_fs
= {
620 /* No owner field so module can be unloaded */
621 .name
= "infinibandeventfs",
622 .get_sb
= uverbs_event_get_sb
,
623 .kill_sb
= kill_litter_super
626 static int __init
ib_uverbs_init(void)
630 spin_lock_init(&map_lock
);
632 ret
= register_chrdev_region(IB_UVERBS_BASE_DEV
, IB_UVERBS_MAX_DEVICES
,
635 printk(KERN_ERR
"user_verbs: couldn't register device number\n");
639 ret
= class_register(&uverbs_class
);
641 printk(KERN_ERR
"user_verbs: couldn't create class infiniband_verbs\n");
645 ret
= class_create_file(&uverbs_class
, &class_attr_abi_version
);
647 printk(KERN_ERR
"user_verbs: couldn't create abi_version attribute\n");
651 ret
= register_filesystem(&uverbs_event_fs
);
653 printk(KERN_ERR
"user_verbs: couldn't register infinibandeventfs\n");
657 uverbs_event_mnt
= kern_mount(&uverbs_event_fs
);
658 if (IS_ERR(uverbs_event_mnt
)) {
659 ret
= PTR_ERR(uverbs_event_mnt
);
660 printk(KERN_ERR
"user_verbs: couldn't mount infinibandeventfs\n");
664 ret
= ib_register_client(&uverbs_client
);
666 printk(KERN_ERR
"user_verbs: couldn't register client\n");
673 mntput(uverbs_event_mnt
);
676 unregister_filesystem(&uverbs_event_fs
);
679 class_unregister(&uverbs_class
);
682 unregister_chrdev_region(IB_UVERBS_BASE_DEV
, IB_UVERBS_MAX_DEVICES
);
688 static void __exit
ib_uverbs_cleanup(void)
690 ib_unregister_client(&uverbs_client
);
691 mntput(uverbs_event_mnt
);
692 unregister_filesystem(&uverbs_event_fs
);
693 class_unregister(&uverbs_class
);
694 unregister_chrdev_region(IB_UVERBS_BASE_DEV
, IB_UVERBS_MAX_DEVICES
);
697 module_init(ib_uverbs_init
);
698 module_exit(ib_uverbs_cleanup
);