2 * Copyright (c) 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Cisco Systems. All rights reserved.
4 * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
5 * Copyright (c) 2005 Voltaire, Inc. 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
35 * $Id: uverbs_main.c 2733 2005-06-28 19:14:34Z roland $
38 #include <linux/module.h>
39 #include <linux/init.h>
40 #include <linux/device.h>
41 #include <linux/err.h>
43 #include <linux/poll.h>
44 #include <linux/file.h>
45 #include <linux/mount.h>
47 #include <asm/uaccess.h>
51 MODULE_AUTHOR("Roland Dreier");
52 MODULE_DESCRIPTION("InfiniBand userspace verbs access");
53 MODULE_LICENSE("Dual BSD/GPL");
55 #define INFINIBANDEVENTFS_MAGIC 0x49426576 /* "IBev" */
58 IB_UVERBS_MAJOR = 231,
59 IB_UVERBS_BASE_MINOR = 192,
60 IB_UVERBS_MAX_DEVICES = 32
63 #define IB_UVERBS_BASE_DEV MKDEV(IB_UVERBS_MAJOR, IB_UVERBS_BASE_MINOR)
65 DECLARE_MUTEX(ib_uverbs_idr_mutex);
66 DEFINE_IDR(ib_uverbs_pd_idr);
67 DEFINE_IDR(ib_uverbs_mr_idr);
68 DEFINE_IDR(ib_uverbs_mw_idr);
69 DEFINE_IDR(ib_uverbs_ah_idr);
70 DEFINE_IDR(ib_uverbs_cq_idr);
71 DEFINE_IDR(ib_uverbs_qp_idr);
72 DEFINE_IDR(ib_uverbs_srq_idr);
74 static spinlock_t map_lock;
75 static DECLARE_BITMAP(dev_map, IB_UVERBS_MAX_DEVICES);
77 static ssize_t (*uverbs_cmd_table[])(struct ib_uverbs_file *file,
78 const char __user *buf, int in_len,
80 [IB_USER_VERBS_CMD_GET_CONTEXT] = ib_uverbs_get_context,
81 [IB_USER_VERBS_CMD_QUERY_DEVICE] = ib_uverbs_query_device,
82 [IB_USER_VERBS_CMD_QUERY_PORT] = ib_uverbs_query_port,
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_COMP_CHANNEL] = ib_uverbs_create_comp_channel,
88 [IB_USER_VERBS_CMD_CREATE_CQ] = ib_uverbs_create_cq,
89 [IB_USER_VERBS_CMD_DESTROY_CQ] = ib_uverbs_destroy_cq,
90 [IB_USER_VERBS_CMD_CREATE_QP] = ib_uverbs_create_qp,
91 [IB_USER_VERBS_CMD_MODIFY_QP] = ib_uverbs_modify_qp,
92 [IB_USER_VERBS_CMD_DESTROY_QP] = ib_uverbs_destroy_qp,
93 [IB_USER_VERBS_CMD_ATTACH_MCAST] = ib_uverbs_attach_mcast,
94 [IB_USER_VERBS_CMD_DETACH_MCAST] = ib_uverbs_detach_mcast,
95 [IB_USER_VERBS_CMD_CREATE_SRQ] = ib_uverbs_create_srq,
96 [IB_USER_VERBS_CMD_MODIFY_SRQ] = ib_uverbs_modify_srq,
97 [IB_USER_VERBS_CMD_DESTROY_SRQ] = ib_uverbs_destroy_srq,
100 static struct vfsmount *uverbs_event_mnt;
102 static void ib_uverbs_add_one(struct ib_device *device);
103 static void ib_uverbs_remove_one(struct ib_device *device);
105 static int ib_dealloc_ucontext(struct ib_ucontext *context)
107 struct ib_uobject *uobj, *tmp;
112 down(&ib_uverbs_idr_mutex);
116 list_for_each_entry_safe(uobj, tmp, &context->qp_list, list) {
117 struct ib_qp *qp = idr_find(&ib_uverbs_qp_idr, uobj->id);
118 idr_remove(&ib_uverbs_qp_idr, uobj->id);
120 list_del(&uobj->list);
121 kfree(container_of(uobj, struct ib_uevent_object, uobject));
124 list_for_each_entry_safe(uobj, tmp, &context->cq_list, list) {
125 struct ib_cq *cq = idr_find(&ib_uverbs_cq_idr, uobj->id);
126 idr_remove(&ib_uverbs_cq_idr, uobj->id);
128 list_del(&uobj->list);
129 kfree(container_of(uobj, struct ib_ucq_object, uobject));
132 list_for_each_entry_safe(uobj, tmp, &context->srq_list, list) {
133 struct ib_srq *srq = idr_find(&ib_uverbs_srq_idr, uobj->id);
134 idr_remove(&ib_uverbs_srq_idr, uobj->id);
136 list_del(&uobj->list);
137 kfree(container_of(uobj, struct ib_uevent_object, uobject));
142 list_for_each_entry_safe(uobj, tmp, &context->mr_list, list) {
143 struct ib_mr *mr = idr_find(&ib_uverbs_mr_idr, uobj->id);
144 struct ib_device *mrdev = mr->device;
145 struct ib_umem_object *memobj;
147 idr_remove(&ib_uverbs_mr_idr, uobj->id);
150 memobj = container_of(uobj, struct ib_umem_object, uobject);
151 ib_umem_release_on_close(mrdev, &memobj->umem);
153 list_del(&uobj->list);
157 list_for_each_entry_safe(uobj, tmp, &context->pd_list, list) {
158 struct ib_pd *pd = idr_find(&ib_uverbs_pd_idr, uobj->id);
159 idr_remove(&ib_uverbs_pd_idr, uobj->id);
161 list_del(&uobj->list);
165 up(&ib_uverbs_idr_mutex);
167 return context->device->dealloc_ucontext(context);
170 static void ib_uverbs_release_file(struct kref *ref)
172 struct ib_uverbs_file *file =
173 container_of(ref, struct ib_uverbs_file, ref);
175 module_put(file->device->ib_dev->owner);
179 static ssize_t ib_uverbs_event_read(struct file *filp, char __user *buf,
180 size_t count, loff_t *pos)
182 struct ib_uverbs_event_file *file = filp->private_data;
183 struct ib_uverbs_event *event;
187 spin_lock_irq(&file->lock);
189 while (list_empty(&file->event_list)) {
190 spin_unlock_irq(&file->lock);
192 if (filp->f_flags & O_NONBLOCK)
195 if (wait_event_interruptible(file->poll_wait,
196 !list_empty(&file->event_list)))
199 spin_lock_irq(&file->lock);
202 event = list_entry(file->event_list.next, struct ib_uverbs_event, list);
205 eventsz = sizeof (struct ib_uverbs_async_event_desc);
207 eventsz = sizeof (struct ib_uverbs_comp_event_desc);
209 if (eventsz > count) {
213 list_del(file->event_list.next);
214 if (event->counter) {
216 list_del(&event->obj_list);
220 spin_unlock_irq(&file->lock);
223 if (copy_to_user(buf, event, eventsz))
234 static unsigned int ib_uverbs_event_poll(struct file *filp,
235 struct poll_table_struct *wait)
237 unsigned int pollflags = 0;
238 struct ib_uverbs_event_file *file = filp->private_data;
240 poll_wait(filp, &file->poll_wait, wait);
242 spin_lock_irq(&file->lock);
243 if (!list_empty(&file->event_list))
244 pollflags = POLLIN | POLLRDNORM;
245 spin_unlock_irq(&file->lock);
250 void ib_uverbs_release_event_file(struct kref *ref)
252 struct ib_uverbs_event_file *file =
253 container_of(ref, struct ib_uverbs_event_file, ref);
258 static int ib_uverbs_event_fasync(int fd, struct file *filp, int on)
260 struct ib_uverbs_event_file *file = filp->private_data;
262 return fasync_helper(fd, filp, on, &file->async_queue);
265 static int ib_uverbs_event_close(struct inode *inode, struct file *filp)
267 struct ib_uverbs_event_file *file = filp->private_data;
268 struct ib_uverbs_event *entry, *tmp;
270 spin_lock_irq(&file->lock);
272 list_for_each_entry_safe(entry, tmp, &file->event_list, list) {
274 list_del(&entry->obj_list);
277 spin_unlock_irq(&file->lock);
279 ib_uverbs_event_fasync(-1, filp, 0);
281 if (file->is_async) {
282 ib_unregister_event_handler(&file->uverbs_file->event_handler);
283 kref_put(&file->uverbs_file->ref, ib_uverbs_release_file);
285 kref_put(&file->ref, ib_uverbs_release_event_file);
290 static struct file_operations uverbs_event_fops = {
291 .owner = THIS_MODULE,
292 .read = ib_uverbs_event_read,
293 .poll = ib_uverbs_event_poll,
294 .release = ib_uverbs_event_close,
295 .fasync = ib_uverbs_event_fasync
298 void ib_uverbs_comp_handler(struct ib_cq *cq, void *cq_context)
300 struct ib_uverbs_event_file *file = cq_context;
301 struct ib_ucq_object *uobj;
302 struct ib_uverbs_event *entry;
308 spin_lock_irqsave(&file->lock, flags);
310 spin_unlock_irqrestore(&file->lock, flags);
314 entry = kmalloc(sizeof *entry, GFP_ATOMIC);
318 uobj = container_of(cq->uobject, struct ib_ucq_object, uobject);
320 entry->desc.comp.cq_handle = cq->uobject->user_handle;
321 entry->counter = &uobj->comp_events_reported;
323 list_add_tail(&entry->list, &file->event_list);
324 list_add_tail(&entry->obj_list, &uobj->comp_list);
325 spin_unlock_irqrestore(&file->lock, flags);
327 wake_up_interruptible(&file->poll_wait);
328 kill_fasync(&file->async_queue, SIGIO, POLL_IN);
331 static void ib_uverbs_async_handler(struct ib_uverbs_file *file,
332 __u64 element, __u64 event,
333 struct list_head *obj_list,
336 struct ib_uverbs_event *entry;
339 spin_lock_irqsave(&file->async_file->lock, flags);
340 if (!file->async_file->file) {
341 spin_unlock_irqrestore(&file->async_file->lock, flags);
345 entry = kmalloc(sizeof *entry, GFP_ATOMIC);
349 entry->desc.async.element = element;
350 entry->desc.async.event_type = event;
351 entry->counter = counter;
353 list_add_tail(&entry->list, &file->async_file->event_list);
355 list_add_tail(&entry->obj_list, obj_list);
356 spin_unlock_irqrestore(&file->async_file->lock, flags);
358 wake_up_interruptible(&file->async_file->poll_wait);
359 kill_fasync(&file->async_file->async_queue, SIGIO, POLL_IN);
362 void ib_uverbs_cq_event_handler(struct ib_event *event, void *context_ptr)
364 struct ib_uverbs_event_file *ev_file = context_ptr;
365 struct ib_ucq_object *uobj;
367 uobj = container_of(event->element.cq->uobject,
368 struct ib_ucq_object, uobject);
370 ib_uverbs_async_handler(ev_file->uverbs_file, uobj->uobject.user_handle,
371 event->event, &uobj->async_list,
372 &uobj->async_events_reported);
376 void ib_uverbs_qp_event_handler(struct ib_event *event, void *context_ptr)
378 struct ib_uevent_object *uobj;
380 uobj = container_of(event->element.qp->uobject,
381 struct ib_uevent_object, uobject);
383 ib_uverbs_async_handler(context_ptr, uobj->uobject.user_handle,
384 event->event, &uobj->event_list,
385 &uobj->events_reported);
388 void ib_uverbs_srq_event_handler(struct ib_event *event, void *context_ptr)
390 struct ib_uevent_object *uobj;
392 uobj = container_of(event->element.srq->uobject,
393 struct ib_uevent_object, uobject);
395 ib_uverbs_async_handler(context_ptr, uobj->uobject.user_handle,
396 event->event, &uobj->event_list,
397 &uobj->events_reported);
400 void ib_uverbs_event_handler(struct ib_event_handler *handler,
401 struct ib_event *event)
403 struct ib_uverbs_file *file =
404 container_of(handler, struct ib_uverbs_file, event_handler);
406 ib_uverbs_async_handler(file, event->element.port_num, event->event,
410 struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file,
411 int is_async, int *fd)
413 struct ib_uverbs_event_file *ev_file;
417 ev_file = kmalloc(sizeof *ev_file, GFP_KERNEL);
419 return ERR_PTR(-ENOMEM);
421 kref_init(&ev_file->ref);
422 spin_lock_init(&ev_file->lock);
423 INIT_LIST_HEAD(&ev_file->event_list);
424 init_waitqueue_head(&ev_file->poll_wait);
425 ev_file->uverbs_file = uverbs_file;
426 ev_file->async_queue = NULL;
427 ev_file->is_async = is_async;
429 *fd = get_unused_fd();
435 filp = get_empty_filp();
441 ev_file->file = filp;
444 * fops_get() can't fail here, because we're coming from a
445 * system call on a uverbs file, which will already have a
448 filp->f_op = fops_get(&uverbs_event_fops);
449 filp->f_vfsmnt = mntget(uverbs_event_mnt);
450 filp->f_dentry = dget(uverbs_event_mnt->mnt_root);
451 filp->f_mapping = filp->f_dentry->d_inode->i_mapping;
452 filp->f_flags = O_RDONLY;
453 filp->f_mode = FMODE_READ;
454 filp->private_data = ev_file;
467 * Look up a completion event file by FD. If lookup is successful,
468 * takes a ref to the event file struct that it returns; if
469 * unsuccessful, returns NULL.
471 struct ib_uverbs_event_file *ib_uverbs_lookup_comp_file(int fd)
473 struct ib_uverbs_event_file *ev_file = NULL;
480 if (filp->f_op != &uverbs_event_fops)
483 ev_file = filp->private_data;
484 if (ev_file->is_async) {
489 kref_get(&ev_file->ref);
496 static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
497 size_t count, loff_t *pos)
499 struct ib_uverbs_file *file = filp->private_data;
500 struct ib_uverbs_cmd_hdr hdr;
502 if (count < sizeof hdr)
505 if (copy_from_user(&hdr, buf, sizeof hdr))
508 if (hdr.in_words * 4 != count)
511 if (hdr.command < 0 ||
512 hdr.command >= ARRAY_SIZE(uverbs_cmd_table) ||
513 !uverbs_cmd_table[hdr.command])
516 if (!file->ucontext &&
517 hdr.command != IB_USER_VERBS_CMD_GET_CONTEXT)
520 return uverbs_cmd_table[hdr.command](file, buf + sizeof hdr,
521 hdr.in_words * 4, hdr.out_words * 4);
524 static int ib_uverbs_mmap(struct file *filp, struct vm_area_struct *vma)
526 struct ib_uverbs_file *file = filp->private_data;
531 return file->device->ib_dev->mmap(file->ucontext, vma);
534 static int ib_uverbs_open(struct inode *inode, struct file *filp)
536 struct ib_uverbs_device *dev =
537 container_of(inode->i_cdev, struct ib_uverbs_device, dev);
538 struct ib_uverbs_file *file;
540 if (!try_module_get(dev->ib_dev->owner))
543 file = kmalloc(sizeof *file, GFP_KERNEL);
545 module_put(dev->ib_dev->owner);
550 file->ucontext = NULL;
551 kref_init(&file->ref);
552 init_MUTEX(&file->mutex);
554 filp->private_data = file;
559 static int ib_uverbs_close(struct inode *inode, struct file *filp)
561 struct ib_uverbs_file *file = filp->private_data;
563 ib_dealloc_ucontext(file->ucontext);
565 kref_put(&file->async_file->ref, ib_uverbs_release_event_file);
566 kref_put(&file->ref, ib_uverbs_release_file);
571 static struct file_operations uverbs_fops = {
572 .owner = THIS_MODULE,
573 .write = ib_uverbs_write,
574 .open = ib_uverbs_open,
575 .release = ib_uverbs_close
578 static struct file_operations uverbs_mmap_fops = {
579 .owner = THIS_MODULE,
580 .write = ib_uverbs_write,
581 .mmap = ib_uverbs_mmap,
582 .open = ib_uverbs_open,
583 .release = ib_uverbs_close
586 static struct ib_client uverbs_client = {
588 .add = ib_uverbs_add_one,
589 .remove = ib_uverbs_remove_one
592 static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
594 struct ib_uverbs_device *dev =
595 container_of(class_dev, struct ib_uverbs_device, class_dev);
597 return sprintf(buf, "%s\n", dev->ib_dev->name);
599 static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
601 static ssize_t show_dev_abi_version(struct class_device *class_dev, char *buf)
603 struct ib_uverbs_device *dev =
604 container_of(class_dev, struct ib_uverbs_device, class_dev);
606 return sprintf(buf, "%d\n", dev->ib_dev->uverbs_abi_ver);
608 static CLASS_DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL);
610 static void ib_uverbs_release_class_dev(struct class_device *class_dev)
612 struct ib_uverbs_device *dev =
613 container_of(class_dev, struct ib_uverbs_device, class_dev);
616 clear_bit(dev->devnum, dev_map);
620 static struct class uverbs_class = {
621 .name = "infiniband_verbs",
622 .release = ib_uverbs_release_class_dev
625 static ssize_t show_abi_version(struct class *class, char *buf)
627 return sprintf(buf, "%d\n", IB_USER_VERBS_ABI_VERSION);
629 static CLASS_ATTR(abi_version, S_IRUGO, show_abi_version, NULL);
631 static void ib_uverbs_add_one(struct ib_device *device)
633 struct ib_uverbs_device *uverbs_dev;
635 if (!device->alloc_ucontext)
638 uverbs_dev = kmalloc(sizeof *uverbs_dev, GFP_KERNEL);
642 memset(uverbs_dev, 0, sizeof *uverbs_dev);
644 spin_lock(&map_lock);
645 uverbs_dev->devnum = find_first_zero_bit(dev_map, IB_UVERBS_MAX_DEVICES);
646 if (uverbs_dev->devnum >= IB_UVERBS_MAX_DEVICES) {
647 spin_unlock(&map_lock);
650 set_bit(uverbs_dev->devnum, dev_map);
651 spin_unlock(&map_lock);
653 uverbs_dev->ib_dev = device;
654 uverbs_dev->num_comp_vectors = 1;
657 cdev_init(&uverbs_dev->dev, &uverbs_mmap_fops);
659 cdev_init(&uverbs_dev->dev, &uverbs_fops);
660 uverbs_dev->dev.owner = THIS_MODULE;
661 kobject_set_name(&uverbs_dev->dev.kobj, "uverbs%d", uverbs_dev->devnum);
662 if (cdev_add(&uverbs_dev->dev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1))
665 uverbs_dev->class_dev.class = &uverbs_class;
666 uverbs_dev->class_dev.dev = device->dma_device;
667 uverbs_dev->class_dev.devt = uverbs_dev->dev.dev;
668 snprintf(uverbs_dev->class_dev.class_id, BUS_ID_SIZE, "uverbs%d", uverbs_dev->devnum);
669 if (class_device_register(&uverbs_dev->class_dev))
672 if (class_device_create_file(&uverbs_dev->class_dev, &class_device_attr_ibdev))
674 if (class_device_create_file(&uverbs_dev->class_dev, &class_device_attr_abi_version))
677 ib_set_client_data(device, &uverbs_client, uverbs_dev);
682 class_device_unregister(&uverbs_dev->class_dev);
685 cdev_del(&uverbs_dev->dev);
686 clear_bit(uverbs_dev->devnum, dev_map);
693 static void ib_uverbs_remove_one(struct ib_device *device)
695 struct ib_uverbs_device *uverbs_dev = ib_get_client_data(device, &uverbs_client);
700 class_device_unregister(&uverbs_dev->class_dev);
703 static struct super_block *uverbs_event_get_sb(struct file_system_type *fs_type, int flags,
704 const char *dev_name, void *data)
706 return get_sb_pseudo(fs_type, "infinibandevent:", NULL,
707 INFINIBANDEVENTFS_MAGIC);
710 static struct file_system_type uverbs_event_fs = {
711 /* No owner field so module can be unloaded */
712 .name = "infinibandeventfs",
713 .get_sb = uverbs_event_get_sb,
714 .kill_sb = kill_litter_super
717 static int __init ib_uverbs_init(void)
721 spin_lock_init(&map_lock);
723 ret = register_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES,
726 printk(KERN_ERR "user_verbs: couldn't register device number\n");
730 ret = class_register(&uverbs_class);
732 printk(KERN_ERR "user_verbs: couldn't create class infiniband_verbs\n");
736 ret = class_create_file(&uverbs_class, &class_attr_abi_version);
738 printk(KERN_ERR "user_verbs: couldn't create abi_version attribute\n");
742 ret = register_filesystem(&uverbs_event_fs);
744 printk(KERN_ERR "user_verbs: couldn't register infinibandeventfs\n");
748 uverbs_event_mnt = kern_mount(&uverbs_event_fs);
749 if (IS_ERR(uverbs_event_mnt)) {
750 ret = PTR_ERR(uverbs_event_mnt);
751 printk(KERN_ERR "user_verbs: couldn't mount infinibandeventfs\n");
755 ret = ib_register_client(&uverbs_client);
757 printk(KERN_ERR "user_verbs: couldn't register client\n");
764 mntput(uverbs_event_mnt);
767 unregister_filesystem(&uverbs_event_fs);
770 class_unregister(&uverbs_class);
773 unregister_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES);
779 static void __exit ib_uverbs_cleanup(void)
781 ib_unregister_client(&uverbs_client);
782 mntput(uverbs_event_mnt);
783 unregister_filesystem(&uverbs_event_fs);
784 class_unregister(&uverbs_class);
785 unregister_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES);
788 module_init(ib_uverbs_init);
789 module_exit(ib_uverbs_cleanup);