1 files changed, 321 insertions, 182 deletions

diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 12511808de2..0eb38f479b3 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -3,6 +3,7 @@
  * Copyright (c) 2005 Cisco Systems.  All rights reserved.
  * Copyright (c) 2005 Mellanox Technologies. All rights reserved.
  * Copyright (c) 2005 Voltaire, Inc. All rights reserved.
+ * Copyright (c) 2005 PathScale, Inc. All rights reserved.
  *
  * This software is available to you under a choice of one of two
  * licenses.  You may choose to be licensed under the terms of the GNU
@@ -43,6 +44,7 @@
 #include <linux/poll.h>
 #include <linux/file.h>
 #include <linux/mount.h>
+#include <linux/cdev.h>
 
 #include <asm/uaccess.h>
 
@@ -62,6 +64,8 @@ enum {
 
 #define IB_UVERBS_BASE_DEV      MKDEV(IB_UVERBS_MAJOR, IB_UVERBS_BASE_MINOR)
 
+static struct class *uverbs_class;
+
 DECLARE_MUTEX(ib_uverbs_idr_mutex);
 DEFINE_IDR(ib_uverbs_pd_idr);
 DEFINE_IDR(ib_uverbs_mr_idr);
@@ -72,31 +76,37 @@ DEFINE_IDR(ib_uverbs_qp_idr);
 DEFINE_IDR(ib_uverbs_srq_idr);
 
 static spinlock_t map_lock;
+static struct ib_uverbs_device *dev_table[IB_UVERBS_MAX_DEVICES];
 static DECLARE_BITMAP(dev_map, IB_UVERBS_MAX_DEVICES);
 
 static ssize_t (*uverbs_cmd_table[])(struct ib_uverbs_file *file,
                                      const char __user *buf, int in_len,
                                      int out_len) = {
-        [IB_USER_VERBS_CMD_QUERY_PARAMS]  = ib_uverbs_query_params,
-        [IB_USER_VERBS_CMD_GET_CONTEXT]   = ib_uverbs_get_context,
-        [IB_USER_VERBS_CMD_QUERY_DEVICE]  = ib_uverbs_query_device,
-        [IB_USER_VERBS_CMD_QUERY_PORT]    = ib_uverbs_query_port,
-        [IB_USER_VERBS_CMD_QUERY_GID]     = ib_uverbs_query_gid,
-        [IB_USER_VERBS_CMD_QUERY_PKEY]    = ib_uverbs_query_pkey,
-        [IB_USER_VERBS_CMD_ALLOC_PD]      = ib_uverbs_alloc_pd,
-        [IB_USER_VERBS_CMD_DEALLOC_PD]    = ib_uverbs_dealloc_pd,
-        [IB_USER_VERBS_CMD_REG_MR]        = ib_uverbs_reg_mr,
-        [IB_USER_VERBS_CMD_DEREG_MR]      = ib_uverbs_dereg_mr,
-        [IB_USER_VERBS_CMD_CREATE_CQ]     = ib_uverbs_create_cq,
-        [IB_USER_VERBS_CMD_DESTROY_CQ]    = ib_uverbs_destroy_cq,
-        [IB_USER_VERBS_CMD_CREATE_QP]     = ib_uverbs_create_qp,
-        [IB_USER_VERBS_CMD_MODIFY_QP]     = ib_uverbs_modify_qp,
-        [IB_USER_VERBS_CMD_DESTROY_QP]    = ib_uverbs_destroy_qp,
-        [IB_USER_VERBS_CMD_ATTACH_MCAST]  = ib_uverbs_attach_mcast,
-        [IB_USER_VERBS_CMD_DETACH_MCAST]  = ib_uverbs_detach_mcast,
-        [IB_USER_VERBS_CMD_CREATE_SRQ]    = ib_uverbs_create_srq,
-        [IB_USER_VERBS_CMD_MODIFY_SRQ]    = ib_uverbs_modify_srq,
-        [IB_USER_VERBS_CMD_DESTROY_SRQ]   = ib_uverbs_destroy_srq,
+        [IB_USER_VERBS_CMD_GET_CONTEXT]         = ib_uverbs_get_context,
+        [IB_USER_VERBS_CMD_QUERY_DEVICE]        = ib_uverbs_query_device,
+        [IB_USER_VERBS_CMD_QUERY_PORT]          = ib_uverbs_query_port,
+        [IB_USER_VERBS_CMD_ALLOC_PD]            = ib_uverbs_alloc_pd,
+        [IB_USER_VERBS_CMD_DEALLOC_PD]          = ib_uverbs_dealloc_pd,
+        [IB_USER_VERBS_CMD_REG_MR]              = ib_uverbs_reg_mr,
+        [IB_USER_VERBS_CMD_DEREG_MR]            = ib_uverbs_dereg_mr,
+        [IB_USER_VERBS_CMD_CREATE_COMP_CHANNEL] = ib_uverbs_create_comp_channel,
+        [IB_USER_VERBS_CMD_CREATE_CQ]           = ib_uverbs_create_cq,
+        [IB_USER_VERBS_CMD_POLL_CQ]             = ib_uverbs_poll_cq,
+        [IB_USER_VERBS_CMD_REQ_NOTIFY_CQ]       = ib_uverbs_req_notify_cq,
+        [IB_USER_VERBS_CMD_DESTROY_CQ]          = ib_uverbs_destroy_cq,
+        [IB_USER_VERBS_CMD_CREATE_QP]           = ib_uverbs_create_qp,
+        [IB_USER_VERBS_CMD_MODIFY_QP]           = ib_uverbs_modify_qp,
+        [IB_USER_VERBS_CMD_DESTROY_QP]          = ib_uverbs_destroy_qp,
+        [IB_USER_VERBS_CMD_POST_SEND]           = ib_uverbs_post_send,
+        [IB_USER_VERBS_CMD_POST_RECV]           = ib_uverbs_post_recv,
+        [IB_USER_VERBS_CMD_POST_SRQ_RECV]       = ib_uverbs_post_srq_recv,
+        [IB_USER_VERBS_CMD_CREATE_AH]           = ib_uverbs_create_ah,
+        [IB_USER_VERBS_CMD_DESTROY_AH]          = ib_uverbs_destroy_ah,
+        [IB_USER_VERBS_CMD_ATTACH_MCAST]        = ib_uverbs_attach_mcast,
+        [IB_USER_VERBS_CMD_DETACH_MCAST]        = ib_uverbs_detach_mcast,
+        [IB_USER_VERBS_CMD_CREATE_SRQ]          = ib_uverbs_create_srq,
+        [IB_USER_VERBS_CMD_MODIFY_SRQ]          = ib_uverbs_modify_srq,
+        [IB_USER_VERBS_CMD_DESTROY_SRQ]         = ib_uverbs_destroy_srq,
 };
 
 static struct vfsmount *uverbs_event_mnt;
@@ -104,7 +114,54 @@ static struct vfsmount *uverbs_event_mnt;
 static void ib_uverbs_add_one(struct ib_device *device);
 static void ib_uverbs_remove_one(struct ib_device *device);
 
-static int ib_dealloc_ucontext(struct ib_ucontext *context)
+static void ib_uverbs_release_dev(struct kref *ref)
+{
+        struct ib_uverbs_device *dev =
+                container_of(ref, struct ib_uverbs_device, ref);
+
+        kfree(dev);
+}
+
+void ib_uverbs_release_ucq(struct ib_uverbs_file *file,
+                          struct ib_uverbs_event_file *ev_file,
+                          struct ib_ucq_object *uobj)
+{
+        struct ib_uverbs_event *evt, *tmp;
+
+        if (ev_file) {
+                spin_lock_irq(&ev_file->lock);
+                list_for_each_entry_safe(evt, tmp, &uobj->comp_list, obj_list) {
+                        list_del(&evt->list);
+                        kfree(evt);
+                }
+                spin_unlock_irq(&ev_file->lock);
+
+                kref_put(&ev_file->ref, ib_uverbs_release_event_file);
+        }
+
+        spin_lock_irq(&file->async_file->lock);
+        list_for_each_entry_safe(evt, tmp, &uobj->async_list, obj_list) {
+                list_del(&evt->list);
+                kfree(evt);
+        }
+        spin_unlock_irq(&file->async_file->lock);
+}
+
+void ib_uverbs_release_uevent(struct ib_uverbs_file *file,
+                              struct ib_uevent_object *uobj)
+{
+        struct ib_uverbs_event *evt, *tmp;
+
+        spin_lock_irq(&file->async_file->lock);
+        list_for_each_entry_safe(evt, tmp, &uobj->event_list, obj_list) {
+                list_del(&evt->list);
+                kfree(evt);
+        }
+        spin_unlock_irq(&file->async_file->lock);
+}
+
+static int ib_uverbs_cleanup_ucontext(struct ib_uverbs_file *file,
+                                      struct ib_ucontext *context)
 {
         struct ib_uobject *uobj, *tmp;
 
@@ -113,30 +170,46 @@ static int ib_dealloc_ucontext(struct ib_ucontext *context)
 
         down(&ib_uverbs_idr_mutex);
 
-        /* XXX Free AHs */
+        list_for_each_entry_safe(uobj, tmp, &context->ah_list, list) {
+                struct ib_ah *ah = idr_find(&ib_uverbs_ah_idr, uobj->id);
+                idr_remove(&ib_uverbs_ah_idr, uobj->id);
+                ib_destroy_ah(ah);
+                list_del(&uobj->list);
+                kfree(uobj);
+        }
 
         list_for_each_entry_safe(uobj, tmp, &context->qp_list, list) {
                 struct ib_qp *qp = idr_find(&ib_uverbs_qp_idr, uobj->id);
+                struct ib_uevent_object *uevent =
+                        container_of(uobj, struct ib_uevent_object, uobject);
                 idr_remove(&ib_uverbs_qp_idr, uobj->id);
                 ib_destroy_qp(qp);
                 list_del(&uobj->list);
-                kfree(container_of(uobj, struct ib_uevent_object, uobject));
+                ib_uverbs_release_uevent(file, uevent);
+                kfree(uevent);
         }
 
         list_for_each_entry_safe(uobj, tmp, &context->cq_list, list) {
                 struct ib_cq *cq = idr_find(&ib_uverbs_cq_idr, uobj->id);
+                struct ib_uverbs_event_file *ev_file = cq->cq_context;
+                struct ib_ucq_object *ucq =
+                        container_of(uobj, struct ib_ucq_object, uobject);
                 idr_remove(&ib_uverbs_cq_idr, uobj->id);
                 ib_destroy_cq(cq);
                 list_del(&uobj->list);
-                kfree(container_of(uobj, struct ib_ucq_object, uobject));
+                ib_uverbs_release_ucq(file, ev_file, ucq);
+                kfree(ucq);
         }
 
         list_for_each_entry_safe(uobj, tmp, &context->srq_list, list) {
                 struct ib_srq *srq = idr_find(&ib_uverbs_srq_idr, uobj->id);
+                struct ib_uevent_object *uevent =
+                        container_of(uobj, struct ib_uevent_object, uobject);
                 idr_remove(&ib_uverbs_srq_idr, uobj->id);
                 ib_destroy_srq(srq);
                 list_del(&uobj->list);
-                kfree(container_of(uobj, struct ib_uevent_object, uobject));
+                ib_uverbs_release_uevent(file, uevent);
+                kfree(uevent);
         }
 
         /* XXX Free MWs */
@@ -175,6 +248,8 @@ static void ib_uverbs_release_file(struct kref *ref)
                 container_of(ref, struct ib_uverbs_file, ref);
 
         module_put(file->device->ib_dev->owner);
+        kref_put(&file->device->ref, ib_uverbs_release_dev);
+
         kfree(file);
 }
 
@@ -188,25 +263,19 @@ static ssize_t ib_uverbs_event_read(struct file *filp, char __user *buf,
 
         spin_lock_irq(&file->lock);
 
-        while (list_empty(&file->event_list) && file->fd >= 0) {
+        while (list_empty(&file->event_list)) {
                 spin_unlock_irq(&file->lock);
 
                 if (filp->f_flags & O_NONBLOCK)
                         return -EAGAIN;
 
                 if (wait_event_interruptible(file->poll_wait,
-                                             !list_empty(&file->event_list) ||
-                                             file->fd < 0))
+                                             !list_empty(&file->event_list)))
                         return -ERESTARTSYS;
 
                 spin_lock_irq(&file->lock);
         }
 
-        if (file->fd < 0) {
-                spin_unlock_irq(&file->lock);
-                return -ENODEV;
-        }
-
         event = list_entry(file->event_list.next, struct ib_uverbs_event, list);
 
         if (file->is_async)
@@ -248,26 +317,19 @@ static unsigned int ib_uverbs_event_poll(struct file *filp,
         poll_wait(filp, &file->poll_wait, wait);
 
         spin_lock_irq(&file->lock);
-        if (file->fd < 0)
-                pollflags = POLLERR;
-        else if (!list_empty(&file->event_list))
+        if (!list_empty(&file->event_list))
                 pollflags = POLLIN | POLLRDNORM;
         spin_unlock_irq(&file->lock);
 
         return pollflags;
 }
 
-static void ib_uverbs_event_release(struct ib_uverbs_event_file *file)
+void ib_uverbs_release_event_file(struct kref *ref)
 {
-        struct ib_uverbs_event *entry, *tmp;
+        struct ib_uverbs_event_file *file =
+                container_of(ref, struct ib_uverbs_event_file, ref);
 
-        spin_lock_irq(&file->lock);
-        if (file->fd != -1) {
-                file->fd = -1;
-                list_for_each_entry_safe(entry, tmp, &file->event_list, list)
-                        kfree(entry);
-        }
-        spin_unlock_irq(&file->lock);
+        kfree(file);
 }
 
 static int ib_uverbs_event_fasync(int fd, struct file *filp, int on)
@@ -280,21 +342,30 @@ static int ib_uverbs_event_fasync(int fd, struct file *filp, int on)
 static int ib_uverbs_event_close(struct inode *inode, struct file *filp)
 {
         struct ib_uverbs_event_file *file = filp->private_data;
+        struct ib_uverbs_event *entry, *tmp;
+
+        spin_lock_irq(&file->lock);
+        file->file = NULL;
+        list_for_each_entry_safe(entry, tmp, &file->event_list, list) {
+                if (entry->counter)
+                        list_del(&entry->obj_list);
+                kfree(entry);
+        }
+        spin_unlock_irq(&file->lock);
 
-        ib_uverbs_event_release(file);
         ib_uverbs_event_fasync(-1, filp, 0);
-        kref_put(&file->uverbs_file->ref, ib_uverbs_release_file);
+
+        if (file->is_async) {
+                ib_unregister_event_handler(&file->uverbs_file->event_handler);
+                kref_put(&file->uverbs_file->ref, ib_uverbs_release_file);
+        }
+        kref_put(&file->ref, ib_uverbs_release_event_file);
 
         return 0;
 }
 
 static struct file_operations uverbs_event_fops = {
-        /*
-         * No .owner field since we artificially create event files,
-         * so there is no increment to the module reference count in
-         * the open path.  All event files come from a uverbs command
-         * file, which already takes a module reference, so this is OK.
-         */
+        .owner   = THIS_MODULE,
         .read    = ib_uverbs_event_read,
         .poll    = ib_uverbs_event_poll,
         .release = ib_uverbs_event_close,
@@ -303,27 +374,37 @@ static struct file_operations uverbs_event_fops = {
 
 void ib_uverbs_comp_handler(struct ib_cq *cq, void *cq_context)
 {
-        struct ib_uverbs_file  *file = cq_context;
-        struct ib_ucq_object   *uobj;
-        struct ib_uverbs_event *entry;
-        unsigned long           flags;
+        struct ib_uverbs_event_file    *file = cq_context;
+        struct ib_ucq_object           *uobj;
+        struct ib_uverbs_event         *entry;
+        unsigned long                   flags;
+
+        if (!file)
+                return;
+
+        spin_lock_irqsave(&file->lock, flags);
+        if (!file->file) {
+                spin_unlock_irqrestore(&file->lock, flags);
+                return;
+        }
 
         entry = kmalloc(sizeof *entry, GFP_ATOMIC);
-        if (!entry)
+        if (!entry) {
+                spin_unlock_irqrestore(&file->lock, flags);
                 return;
+        }
 
         uobj = container_of(cq->uobject, struct ib_ucq_object, uobject);
 
         entry->desc.comp.cq_handle = cq->uobject->user_handle;
         entry->counter             = &uobj->comp_events_reported;
 
-        spin_lock_irqsave(&file->comp_file[0].lock, flags);
-        list_add_tail(&entry->list, &file->comp_file[0].event_list);
+        list_add_tail(&entry->list, &file->event_list);
         list_add_tail(&entry->obj_list, &uobj->comp_list);
-        spin_unlock_irqrestore(&file->comp_file[0].lock, flags);
+        spin_unlock_irqrestore(&file->lock, flags);
 
-        wake_up_interruptible(&file->comp_file[0].poll_wait);
-        kill_fasync(&file->comp_file[0].async_queue, SIGIO, POLL_IN);
+        wake_up_interruptible(&file->poll_wait);
+        kill_fasync(&file->async_queue, SIGIO, POLL_IN);
 }
 
 static void ib_uverbs_async_handler(struct ib_uverbs_file *file,
@@ -334,32 +415,40 @@ static void ib_uverbs_async_handler(struct ib_uverbs_file *file,
         struct ib_uverbs_event *entry;
         unsigned long flags;
 
+        spin_lock_irqsave(&file->async_file->lock, flags);
+        if (!file->async_file->file) {
+                spin_unlock_irqrestore(&file->async_file->lock, flags);
+                return;
+        }
+
         entry = kmalloc(sizeof *entry, GFP_ATOMIC);
-        if (!entry)
+        if (!entry) {
+                spin_unlock_irqrestore(&file->async_file->lock, flags);
                 return;
+        }
 
         entry->desc.async.element    = element;
         entry->desc.async.event_type = event;
         entry->counter               = counter;
 
-        spin_lock_irqsave(&file->async_file.lock, flags);
-        list_add_tail(&entry->list, &file->async_file.event_list);
+        list_add_tail(&entry->list, &file->async_file->event_list);
         if (obj_list)
                 list_add_tail(&entry->obj_list, obj_list);
-        spin_unlock_irqrestore(&file->async_file.lock, flags);
+        spin_unlock_irqrestore(&file->async_file->lock, flags);
 
-        wake_up_interruptible(&file->async_file.poll_wait);
-        kill_fasync(&file->async_file.async_queue, SIGIO, POLL_IN);
+        wake_up_interruptible(&file->async_file->poll_wait);
+        kill_fasync(&file->async_file->async_queue, SIGIO, POLL_IN);
 }
 
 void ib_uverbs_cq_event_handler(struct ib_event *event, void *context_ptr)
 {
+        struct ib_uverbs_event_file *ev_file = context_ptr;
         struct ib_ucq_object *uobj;
 
         uobj = container_of(event->element.cq->uobject,
                             struct ib_ucq_object, uobject);
 
-        ib_uverbs_async_handler(context_ptr, uobj->uobject.user_handle,
+        ib_uverbs_async_handler(ev_file->uverbs_file, uobj->uobject.user_handle,
                                 event->event, &uobj->async_list,
                                 &uobj->async_events_reported);
                                 
@@ -389,8 +478,8 @@ void ib_uverbs_srq_event_handler(struct ib_event *event, void *context_ptr)
                                 &uobj->events_reported);
 }
 
-static void ib_uverbs_event_handler(struct ib_event_handler *handler,
-                                    struct ib_event *event)
+void ib_uverbs_event_handler(struct ib_event_handler *handler,
+                             struct ib_event *event)
 {
         struct ib_uverbs_file *file =
                 container_of(handler, struct ib_uverbs_file, event_handler);
@@ -399,38 +488,90 @@ static void ib_uverbs_event_handler(struct ib_event_handler *handler,
                                 NULL, NULL);
 }
 
-static int ib_uverbs_event_init(struct ib_uverbs_event_file *file,
-                                struct ib_uverbs_file *uverbs_file)
+struct file *ib_uverbs_alloc_event_file(struct ib_uverbs_file *uverbs_file,
+                                        int is_async, int *fd)
 {
+        struct ib_uverbs_event_file *ev_file;
         struct file *filp;
+        int ret;
 
-        spin_lock_init(&file->lock);
-        INIT_LIST_HEAD(&file->event_list);
-        init_waitqueue_head(&file->poll_wait);
-        file->uverbs_file = uverbs_file;
-        file->async_queue = NULL;
-
-        file->fd = get_unused_fd();
-        if (file->fd < 0)
-                return file->fd;
+        ev_file = kmalloc(sizeof *ev_file, GFP_KERNEL);
+        if (!ev_file)
+                return ERR_PTR(-ENOMEM);
+
+        kref_init(&ev_file->ref);
+        spin_lock_init(&ev_file->lock);
+        INIT_LIST_HEAD(&ev_file->event_list);
+        init_waitqueue_head(&ev_file->poll_wait);
+        ev_file->uverbs_file = uverbs_file;
+        ev_file->async_queue = NULL;
+        ev_file->is_async    = is_async;
+
+        *fd = get_unused_fd();
+        if (*fd < 0) {
+                ret = *fd;
+                goto err;
+        }
 
         filp = get_empty_filp();
         if (!filp) {
-                put_unused_fd(file->fd);
-                return -ENFILE;
+                ret = -ENFILE;
+                goto err_fd;
         }
 
-        filp->f_op         = &uverbs_event_fops;
+        ev_file->file      = filp;
+
+        /*
+         * fops_get() can't fail here, because we're coming from a
+         * system call on a uverbs file, which will already have a
+         * module reference.
+         */
+        filp->f_op         = fops_get(&uverbs_event_fops);
         filp->f_vfsmnt     = mntget(uverbs_event_mnt);
         filp->f_dentry     = dget(uverbs_event_mnt->mnt_root);
         filp->f_mapping    = filp->f_dentry->d_inode->i_mapping;
         filp->f_flags      = O_RDONLY;
         filp->f_mode       = FMODE_READ;
-        filp->private_data = file;
+        filp->private_data = ev_file;
 
-        fd_install(file->fd, filp);
+        return filp;
 
-        return 0;
+err_fd:
+        put_unused_fd(*fd);
+
+err:
+        kfree(ev_file);
+        return ERR_PTR(ret);
+}
+
+/*
+ * Look up a completion event file by FD.  If lookup is successful,
+ * takes a ref to the event file struct that it returns; if
+ * unsuccessful, returns NULL.
+ */
+struct ib_uverbs_event_file *ib_uverbs_lookup_comp_file(int fd)
+{
+        struct ib_uverbs_event_file *ev_file = NULL;
+        struct file *filp;
+
+        filp = fget(fd);
+        if (!filp)
+                return NULL;
+
+        if (filp->f_op != &uverbs_event_fops)
+                goto out;
+
+        ev_file = filp->private_data;
+        if (ev_file->is_async) {
+                ev_file = NULL;
+                goto out;
+        }
+
+        kref_get(&ev_file->ref);
+
+out:
+        fput(filp);
+        return ev_file;
 }
 
 static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
@@ -450,11 +591,11 @@ static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
 
         if (hdr.command < 0                             ||
             hdr.command >= ARRAY_SIZE(uverbs_cmd_table) ||
-            !uverbs_cmd_table[hdr.command])
+            !uverbs_cmd_table[hdr.command]              ||
+            !(file->device->ib_dev->uverbs_cmd_mask & (1ull << hdr.command)))
                 return -EINVAL;
 
-        if (!file->ucontext                               &&
-            hdr.command != IB_USER_VERBS_CMD_QUERY_PARAMS &&
+        if (!file->ucontext &&
             hdr.command != IB_USER_VERBS_CMD_GET_CONTEXT)
                 return -EINVAL;
 
@@ -474,84 +615,57 @@ static int ib_uverbs_mmap(struct file *filp, struct vm_area_struct *vma)
 
 static int ib_uverbs_open(struct inode *inode, struct file *filp)
 {
-        struct ib_uverbs_device *dev =
-                container_of(inode->i_cdev, struct ib_uverbs_device, dev);
+        struct ib_uverbs_device *dev;
         struct ib_uverbs_file *file;
-        int i = 0;
         int ret;
 
-        if (!try_module_get(dev->ib_dev->owner))
-                return -ENODEV;
+        spin_lock(&map_lock);
+        dev = dev_table[iminor(inode) - IB_UVERBS_BASE_MINOR];
+        if (dev)
+                kref_get(&dev->ref);
+        spin_unlock(&map_lock);
+
+        if (!dev)
+                return -ENXIO;
+
+        if (!try_module_get(dev->ib_dev->owner)) {
+                ret = -ENODEV;
+                goto err;
+        }
 
-        file = kmalloc(sizeof *file +
-                       (dev->num_comp - 1) * sizeof (struct ib_uverbs_event_file),
-                       GFP_KERNEL);
+        file = kmalloc(sizeof *file, GFP_KERNEL);
         if (!file) {
                 ret = -ENOMEM;
-                goto err;
+                goto err_module;
         }
 
-        file->device = dev;
+        file->device     = dev;
+        file->ucontext   = NULL;
+        file->async_file = NULL;
         kref_init(&file->ref);
         init_MUTEX(&file->mutex);
 
-        file->ucontext = NULL;
-
-        kref_get(&file->ref);
-        ret = ib_uverbs_event_init(&file->async_file, file);
-        if (ret)
-                goto err_kref;
-
-        file->async_file.is_async = 1;
-
-        for (i = 0; i < dev->num_comp; ++i) {
-                kref_get(&file->ref);
-                ret = ib_uverbs_event_init(&file->comp_file[i], file);
-                if (ret)
-                        goto err_async;
-                file->comp_file[i].is_async = 0;
-        }
-
-
         filp->private_data = file;
 
-        INIT_IB_EVENT_HANDLER(&file->event_handler, dev->ib_dev,
-                              ib_uverbs_event_handler);
-        if (ib_register_event_handler(&file->event_handler))
-                goto err_async;
-
         return 0;
 
-err_async:
-        while (i--)
-                ib_uverbs_event_release(&file->comp_file[i]);
-
-        ib_uverbs_event_release(&file->async_file);
-
-err_kref:
-        /*
-         * One extra kref_put() because we took a reference before the
-         * event file creation that failed and got us here.
-         */
-        kref_put(&file->ref, ib_uverbs_release_file);
-        kref_put(&file->ref, ib_uverbs_release_file);
+err_module:
+        module_put(dev->ib_dev->owner);
 
 err:
-        module_put(dev->ib_dev->owner);
+        kref_put(&dev->ref, ib_uverbs_release_dev);
+
         return ret;
 }
 
 static int ib_uverbs_close(struct inode *inode, struct file *filp)
 {
         struct ib_uverbs_file *file = filp->private_data;
-        int i;
 
-        ib_unregister_event_handler(&file->event_handler);
-        ib_uverbs_event_release(&file->async_file);
-        ib_dealloc_ucontext(file->ucontext);
+        ib_uverbs_cleanup_ucontext(file, file->ucontext);
 
-        for (i = 0; i < file->device->num_comp; ++i)
-                ib_uverbs_event_release(&file->comp_file[i]);
+        if (file->async_file)
+                kref_put(&file->async_file->ref, ib_uverbs_release_event_file);
 
         kref_put(&file->ref, ib_uverbs_release_file);
 
@@ -581,27 +695,25 @@ static struct ib_client uverbs_client = {
 
 static ssize_t show_ibdev(struct class_device *class_dev, char *buf)
 {
-        struct ib_uverbs_device *dev =
-                container_of(class_dev, struct ib_uverbs_device, class_dev);
+        struct ib_uverbs_device *dev = class_get_devdata(class_dev);
+
+        if (!dev)
+                return -ENODEV;
 
         return sprintf(buf, "%s\n", dev->ib_dev->name);
 }
 static CLASS_DEVICE_ATTR(ibdev, S_IRUGO, show_ibdev, NULL);
 
-static void ib_uverbs_release_class_dev(struct class_device *class_dev)
+static ssize_t show_dev_abi_version(struct class_device *class_dev, char *buf)
 {
-        struct ib_uverbs_device *dev =
-                container_of(class_dev, struct ib_uverbs_device, class_dev);
+        struct ib_uverbs_device *dev = class_get_devdata(class_dev);
 
-        cdev_del(&dev->dev);
-        clear_bit(dev->devnum, dev_map);
-        kfree(dev);
-}
+        if (!dev)
+                return -ENODEV;
 
-static struct class uverbs_class = {
-        .name    = "infiniband_verbs",
-        .release = ib_uverbs_release_class_dev
-};
+        return sprintf(buf, "%d\n", dev->ib_dev->uverbs_abi_ver);
+}
+static CLASS_DEVICE_ATTR(abi_version, S_IRUGO, show_dev_abi_version, NULL);
 
 static ssize_t show_abi_version(struct class *class, char *buf)
 {
@@ -622,6 +734,8 @@ static void ib_uverbs_add_one(struct ib_device *device)
 
         memset(uverbs_dev, 0, sizeof *uverbs_dev);
 
+        kref_init(&uverbs_dev->ref);
+
         spin_lock(&map_lock);
         uverbs_dev->devnum = find_first_zero_bit(dev_map, IB_UVERBS_MAX_DEVICES);
         if (uverbs_dev->devnum >= IB_UVERBS_MAX_DEVICES) {
@@ -631,41 +745,49 @@ static void ib_uverbs_add_one(struct ib_device *device)
         set_bit(uverbs_dev->devnum, dev_map);
         spin_unlock(&map_lock);
 
-        uverbs_dev->ib_dev   = device;
-        uverbs_dev->num_comp = 1;
+        uverbs_dev->ib_dev           = device;
+        uverbs_dev->num_comp_vectors = 1;
 
-        if (device->mmap)
-                cdev_init(&uverbs_dev->dev, &uverbs_mmap_fops);
-        else
-                cdev_init(&uverbs_dev->dev, &uverbs_fops);
-        uverbs_dev->dev.owner = THIS_MODULE;
-        kobject_set_name(&uverbs_dev->dev.kobj, "uverbs%d", uverbs_dev->devnum);
-        if (cdev_add(&uverbs_dev->dev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1))
+        uverbs_dev->dev = cdev_alloc();
+        if (!uverbs_dev->dev)
                 goto err;
+        uverbs_dev->dev->owner = THIS_MODULE;
+        uverbs_dev->dev->ops = device->mmap ? &uverbs_mmap_fops : &uverbs_fops;
+        kobject_set_name(&uverbs_dev->dev->kobj, "uverbs%d", uverbs_dev->devnum);
+        if (cdev_add(uverbs_dev->dev, IB_UVERBS_BASE_DEV + uverbs_dev->devnum, 1))
+                goto err_cdev;
 
-        uverbs_dev->class_dev.class = &uverbs_class;
-        uverbs_dev->class_dev.dev   = device->dma_device;
-        uverbs_dev->class_dev.devt  = uverbs_dev->dev.dev;
-        snprintf(uverbs_dev->class_dev.class_id, BUS_ID_SIZE, "uverbs%d", uverbs_dev->devnum);
-        if (class_device_register(&uverbs_dev->class_dev))
+        uverbs_dev->class_dev = class_device_create(uverbs_class, NULL,
+                                                    uverbs_dev->dev->dev,
+                                                    device->dma_device,
+                                                    "uverbs%d", uverbs_dev->devnum);
+        if (IS_ERR(uverbs_dev->class_dev))
                 goto err_cdev;
 
-        if (class_device_create_file(&uverbs_dev->class_dev, &class_device_attr_ibdev))
+        class_set_devdata(uverbs_dev->class_dev, uverbs_dev);
+
+        if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_ibdev))
                 goto err_class;
+        if (class_device_create_file(uverbs_dev->class_dev, &class_device_attr_abi_version))
+                goto err_class;
+
+        spin_lock(&map_lock);
+        dev_table[uverbs_dev->devnum] = uverbs_dev;
+        spin_unlock(&map_lock);
 
         ib_set_client_data(device, &uverbs_client, uverbs_dev);
 
         return;
 
 err_class:
-        class_device_unregister(&uverbs_dev->class_dev);
+        class_device_destroy(uverbs_class, uverbs_dev->dev->dev);
 
 err_cdev:
-        cdev_del(&uverbs_dev->dev);
+        cdev_del(uverbs_dev->dev);
         clear_bit(uverbs_dev->devnum, dev_map);
 
 err:
-        kfree(uverbs_dev);
+        kref_put(&uverbs_dev->ref, ib_uverbs_release_dev);
         return;
 }
 
@@ -676,7 +798,16 @@ static void ib_uverbs_remove_one(struct ib_device *device)
         if (!uverbs_dev)
                 return;
 
-        class_device_unregister(&uverbs_dev->class_dev);
+        class_set_devdata(uverbs_dev->class_dev, NULL);
+        class_device_destroy(uverbs_class, uverbs_dev->dev->dev);
+        cdev_del(uverbs_dev->dev);
+
+        spin_lock(&map_lock);
+        dev_table[uverbs_dev->devnum] = NULL;
+        spin_unlock(&map_lock);
+
+        clear_bit(uverbs_dev->devnum, dev_map);
+        kref_put(&uverbs_dev->ref, ib_uverbs_release_dev);
 }
 
 static struct super_block *uverbs_event_get_sb(struct file_system_type *fs_type, int flags,
@@ -706,13 +837,14 @@ static int __init ib_uverbs_init(void)
                 goto out;
         }
 
-        ret = class_register(&uverbs_class);
-        if (ret) {
+        uverbs_class = class_create(THIS_MODULE, "infiniband_verbs");
+        if (IS_ERR(uverbs_class)) {
+                ret = PTR_ERR(uverbs_class);
                 printk(KERN_ERR "user_verbs: couldn't create class infiniband_verbs\n");
                 goto out_chrdev;
         }
 
-        ret = class_create_file(&uverbs_class, &class_attr_abi_version);
+        ret = class_create_file(uverbs_class, &class_attr_abi_version);
         if (ret) {
                 printk(KERN_ERR "user_verbs: couldn't create abi_version attribute\n");
                 goto out_class;
@@ -746,7 +878,7 @@ out_fs:
         unregister_filesystem(&uverbs_event_fs);
 
 out_class:
-        class_unregister(&uverbs_class);
+        class_destroy(uverbs_class);
 
 out_chrdev:
         unregister_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES);
@@ -760,8 +892,15 @@ static void __exit ib_uverbs_cleanup(void)
         ib_unregister_client(&uverbs_client);
         mntput(uverbs_event_mnt);
         unregister_filesystem(&uverbs_event_fs);
-        class_unregister(&uverbs_class);
+        class_destroy(uverbs_class);
         unregister_chrdev_region(IB_UVERBS_BASE_DEV, IB_UVERBS_MAX_DEVICES);
+        idr_destroy(&ib_uverbs_pd_idr);
+        idr_destroy(&ib_uverbs_mr_idr);
+        idr_destroy(&ib_uverbs_mw_idr);
+        idr_destroy(&ib_uverbs_ah_idr);
+        idr_destroy(&ib_uverbs_cq_idr);
+        idr_destroy(&ib_uverbs_qp_idr);
+        idr_destroy(&ib_uverbs_srq_idr);
 }
 
 module_init(ib_uverbs_init);